ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

nvme:replacing spdk_dma_malloc with spdk_z/malloc

Browse Source 
Change-Id: I755d36495e7d8e55c26c4103a9520102223798ef
Signed-off-by: zkhatami88 <z.khatami88@gmail.com>
Reviewed-on: https://review.gerrithub.io/409960
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Chandler-Test-Pool: SPDK Automated Test System <sys_sgsw@intel.com>
This commit is contained in:
zkhatami88 2018-07-17 17:08:04 -07:00 committed by Jim Harris
parent 4c8a350d02
commit eb6a2cb8f5
6 changed files with 82 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
examples/nvme/hello_world/hello_world.c
View File

@ -109,7 +109,7 @@ read_complete(void *arg, const struct spdk_nvme_cpl *completion)
* to exit its polling loop. * to exit its polling loop.
*/ */
printf("%s", sequence->buf); printf("%s", sequence->buf);
spdk_dma_free(sequence->buf); spdk_free(sequence->buf);
sequence->is_completed = 1; sequence->is_completed = 1;
} }
@ -128,9 +128,9 @@ write_complete(void *arg, const struct spdk_nvme_cpl *completion)
if (sequence->using_cmb_io) { if (sequence->using_cmb_io) {
spdk_nvme_ctrlr_free_cmb_io_buffer(ns_entry->ctrlr, sequence->buf, 0x1000); spdk_nvme_ctrlr_free_cmb_io_buffer(ns_entry->ctrlr, sequence->buf, 0x1000);
} else { } else {
spdk_dma_free(sequence->buf); spdk_free(sequence->buf);
} }
sequence->buf = spdk_dma_zmalloc(0x1000, 0x1000, NULL); sequence->buf = spdk_zmalloc(0x1000, 0x1000, NULL, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_DMA);
rc = spdk_nvme_ns_cmd_read(ns_entry->ns, ns_entry->qpair, sequence->buf, rc = spdk_nvme_ns_cmd_read(ns_entry->ns, ns_entry->qpair, sequence->buf,
0, /* LBA start */ 0, /* LBA start */
@ -178,7 +178,7 @@ hello_world(void)
sequence.buf = spdk_nvme_ctrlr_alloc_cmb_io_buffer(ns_entry->ctrlr, 0x1000); sequence.buf = spdk_nvme_ctrlr_alloc_cmb_io_buffer(ns_entry->ctrlr, 0x1000);
if (sequence.buf == NULL) { if (sequence.buf == NULL) {
sequence.using_cmb_io = 0; sequence.using_cmb_io = 0;
sequence.buf = spdk_dma_zmalloc(0x1000, 0x1000, NULL); sequence.buf = spdk_zmalloc(0x1000, 0x1000, NULL, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_DMA);
} }
if (sequence.buf == NULL) { if (sequence.buf == NULL) {
printf("ERROR: write buffer allocation failed\n"); printf("ERROR: write buffer allocation failed\n");

5
lib/nvme/nvme.c
View File

@ -181,7 +181,8 @@ nvme_allocate_request_user_copy(struct spdk_nvme_qpair *qpair,
uint64_t phys_addr; uint64_t phys_addr;
if (buffer && payload_size) { if (buffer && payload_size) {
dma_buffer = spdk_dma_zmalloc(payload_size, 4096, &phys_addr); dma_buffer = spdk_zmalloc(payload_size, 4096, &phys_addr,
SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_DMA);
if (!dma_buffer) { if (!dma_buffer) {
return NULL; return NULL;
} }
@ -194,7 +195,7 @@ nvme_allocate_request_user_copy(struct spdk_nvme_qpair *qpair,
req = nvme_allocate_request_contig(qpair, dma_buffer, payload_size, nvme_user_copy_cmd_complete, req = nvme_allocate_request_contig(qpair, dma_buffer, payload_size, nvme_user_copy_cmd_complete,
NULL); NULL);
if (!req) { if (!req) {
spdk_dma_free(dma_buffer); spdk_free(dma_buffer);
return NULL; return NULL;
} }

25
lib/nvme/nvme_ctrlr.c
View File

@ -370,8 +370,8 @@ static int nvme_ctrlr_set_intel_support_log_pages(struct spdk_nvme_ctrlr *ctrlr)
struct nvme_completion_poll_status status; struct nvme_completion_poll_status status;
struct spdk_nvme_intel_log_page_directory *log_page_directory; struct spdk_nvme_intel_log_page_directory *log_page_directory;
log_page_directory = spdk_dma_zmalloc(sizeof(struct spdk_nvme_intel_log_page_directory), log_page_directory = spdk_zmalloc(sizeof(struct spdk_nvme_intel_log_page_directory),
64, &phys_addr); 64, &phys_addr, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_DMA);
if (log_page_directory == NULL) { if (log_page_directory == NULL) {
SPDK_ERRLOG("could not allocate log_page_directory\n"); SPDK_ERRLOG("could not allocate log_page_directory\n");
return -ENXIO; return -ENXIO;
@ -382,13 +382,13 @@ static int nvme_ctrlr_set_intel_support_log_pages(struct spdk_nvme_ctrlr *ctrlr)
nvme_completion_poll_cb, nvme_completion_poll_cb,
&status); &status);
if (spdk_nvme_wait_for_completion(ctrlr->adminq, &status)) { if (spdk_nvme_wait_for_completion(ctrlr->adminq, &status)) {
spdk_dma_free(log_page_directory); spdk_free(log_page_directory);
SPDK_ERRLOG("nvme_ctrlr_cmd_get_log_page failed!\n"); SPDK_ERRLOG("nvme_ctrlr_cmd_get_log_page failed!\n");
return -ENXIO; return -ENXIO;
} }
nvme_ctrlr_construct_intel_support_log_page_list(ctrlr, log_page_directory); nvme_ctrlr_construct_intel_support_log_page_list(ctrlr, log_page_directory);
spdk_dma_free(log_page_directory); spdk_free(log_page_directory);
return 0; return 0;
} }
@ -1064,13 +1064,13 @@ nvme_ctrlr_destruct_namespaces(struct spdk_nvme_ctrlr *ctrlr)
nvme_ns_destruct(&ctrlr->ns[i]); nvme_ns_destruct(&ctrlr->ns[i]);
} }
spdk_dma_free(ctrlr->ns); spdk_free(ctrlr->ns);
ctrlr->ns = NULL; ctrlr->ns = NULL;
ctrlr->num_ns = 0; ctrlr->num_ns = 0;
} }
if (ctrlr->nsdata) { if (ctrlr->nsdata) {
spdk_dma_free(ctrlr->nsdata); spdk_free(ctrlr->nsdata);
ctrlr->nsdata = NULL; ctrlr->nsdata = NULL;
} }
@ -1124,14 +1124,14 @@ nvme_ctrlr_construct_namespaces(struct spdk_nvme_ctrlr *ctrlr)
return 0; return 0;
} }
ctrlr->ns = spdk_dma_zmalloc(nn * sizeof(struct spdk_nvme_ns), 64, ctrlr->ns = spdk_zmalloc(nn * sizeof(struct spdk_nvme_ns), 64,
&phys_addr); &phys_addr, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
if (ctrlr->ns == NULL) { if (ctrlr->ns == NULL) {
goto fail; goto fail;
} }
ctrlr->nsdata = spdk_dma_zmalloc(nn * sizeof(struct spdk_nvme_ns_data), 64, ctrlr->nsdata = spdk_zmalloc(nn * sizeof(struct spdk_nvme_ns_data), 64,
&phys_addr); &phys_addr, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE | SPDK_MALLOC_DMA);
if (ctrlr->nsdata == NULL) { if (ctrlr->nsdata == NULL) {
goto fail; goto fail;
} }
@ -1311,7 +1311,8 @@ nvme_ctrlr_add_process(struct spdk_nvme_ctrlr *ctrlr, void *devhandle)
} }
/* Initialize the per process properties for this ctrlr */ /* Initialize the per process properties for this ctrlr */
ctrlr_proc = spdk_dma_zmalloc(sizeof(struct spdk_nvme_ctrlr_process), 64, NULL); ctrlr_proc = spdk_zmalloc(sizeof(struct spdk_nvme_ctrlr_process),
64, NULL, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
if (ctrlr_proc == NULL) { if (ctrlr_proc == NULL) {
SPDK_ERRLOG("failed to allocate memory to track the process props\n"); SPDK_ERRLOG("failed to allocate memory to track the process props\n");
@ -1405,7 +1406,7 @@ nvme_ctrlr_free_processes(struct spdk_nvme_ctrlr *ctrlr)
assert(STAILQ_EMPTY(&active_proc->active_reqs)); assert(STAILQ_EMPTY(&active_proc->active_reqs));
spdk_dma_free(active_proc); spdk_free(active_proc);
} }
} }

44
lib/nvme/nvme_pcie.c
View File

@ -668,7 +668,7 @@ nvme_pcie_ctrlr_construct_admin_qpair(struct spdk_nvme_ctrlr *ctrlr)
struct nvme_pcie_qpair *pqpair; struct nvme_pcie_qpair *pqpair;
int rc; int rc;
pqpair = spdk_dma_zmalloc(sizeof(*pqpair), 64, NULL); pqpair = spdk_zmalloc(sizeof(*pqpair), 64, NULL, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
if (pqpair == NULL) { if (pqpair == NULL) {
return -ENOMEM; return -ENOMEM;
} }
@ -794,7 +794,8 @@ struct spdk_nvme_ctrlr *nvme_pcie_ctrlr_construct(const struct spdk_nvme_transpo
return NULL; return NULL;
} }
pctrlr = spdk_dma_zmalloc(sizeof(struct nvme_pcie_ctrlr), 64, NULL); pctrlr = spdk_zmalloc(sizeof(struct nvme_pcie_ctrlr), 64, NULL,
SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
if (pctrlr == NULL) { if (pctrlr == NULL) {
close(claim_fd); close(claim_fd);
SPDK_ERRLOG("could not allocate ctrlr\n"); SPDK_ERRLOG("could not allocate ctrlr\n");
@ -812,7 +813,7 @@ struct spdk_nvme_ctrlr *nvme_pcie_ctrlr_construct(const struct spdk_nvme_transpo
rc = nvme_pcie_ctrlr_allocate_bars(pctrlr); rc = nvme_pcie_ctrlr_allocate_bars(pctrlr);
if (rc != 0) { if (rc != 0) {
close(claim_fd); close(claim_fd);
spdk_dma_free(pctrlr); spdk_free(pctrlr);
return NULL; return NULL;
} }
@ -824,14 +825,14 @@ struct spdk_nvme_ctrlr *nvme_pcie_ctrlr_construct(const struct spdk_nvme_transpo
if (nvme_ctrlr_get_cap(&pctrlr->ctrlr, &cap)) { if (nvme_ctrlr_get_cap(&pctrlr->ctrlr, &cap)) {
SPDK_ERRLOG("get_cap() failed\n"); SPDK_ERRLOG("get_cap() failed\n");
close(claim_fd); close(claim_fd);
spdk_dma_free(pctrlr); spdk_free(pctrlr);
return NULL; return NULL;
} }
if (nvme_ctrlr_get_vs(&pctrlr->ctrlr, &vs)) { if (nvme_ctrlr_get_vs(&pctrlr->ctrlr, &vs)) {
SPDK_ERRLOG("get_vs() failed\n"); SPDK_ERRLOG("get_vs() failed\n");
close(claim_fd); close(claim_fd);
spdk_dma_free(pctrlr); spdk_free(pctrlr);
return NULL; return NULL;
} }
@ -923,7 +924,7 @@ nvme_pcie_ctrlr_destruct(struct spdk_nvme_ctrlr *ctrlr)
spdk_pci_device_detach(devhandle); spdk_pci_device_detach(devhandle);
} }
spdk_dma_free(pctrlr); spdk_free(pctrlr);
return 0; return 0;
} }
@ -972,6 +973,7 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair)
uint64_t offset; uint64_t offset;
uint16_t num_trackers; uint16_t num_trackers;
size_t page_align = 0x200000; size_t page_align = 0x200000;
uint32_t flags = SPDK_MALLOC_DMA;
/* /*
* Limit the maximum number of completions to return per call to prevent wraparound, * Limit the maximum number of completions to return per call to prevent wraparound,
@ -990,6 +992,10 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair)
pqpair->sq_in_cmb = false; pqpair->sq_in_cmb = false;
if (nvme_qpair_is_admin_queue(&pqpair->qpair)) {
flags |= SPDK_MALLOC_SHARE;
}
/* cmd and cpl rings must be aligned on page size boundaries. */ /* cmd and cpl rings must be aligned on page size boundaries. */
if (ctrlr->opts.use_cmb_sqs) { if (ctrlr->opts.use_cmb_sqs) {
if (nvme_pcie_ctrlr_alloc_cmb(ctrlr, pqpair->num_entries * sizeof(struct spdk_nvme_cmd), if (nvme_pcie_ctrlr_alloc_cmb(ctrlr, pqpair->num_entries * sizeof(struct spdk_nvme_cmd),
@ -1004,18 +1010,18 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair)
* a single hugepage only. See MAX_IO_QUEUE_ENTRIES. * a single hugepage only. See MAX_IO_QUEUE_ENTRIES.
*/ */
if (pqpair->sq_in_cmb == false) { if (pqpair->sq_in_cmb == false) {
pqpair->cmd = spdk_dma_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cmd), pqpair->cmd = spdk_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cmd),
page_align, page_align, &pqpair->cmd_bus_addr,
&pqpair->cmd_bus_addr); SPDK_ENV_SOCKET_ID_ANY, flags);
if (pqpair->cmd == NULL) { if (pqpair->cmd == NULL) {
SPDK_ERRLOG("alloc qpair_cmd failed\n"); SPDK_ERRLOG("alloc qpair_cmd failed\n");
return -ENOMEM; return -ENOMEM;
} }
} }
pqpair->cpl = spdk_dma_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cpl), pqpair->cpl = spdk_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cpl),
page_align, page_align, &pqpair->cpl_bus_addr,
&pqpair->cpl_bus_addr); SPDK_ENV_SOCKET_ID_ANY, flags);
if (pqpair->cpl == NULL) { if (pqpair->cpl == NULL) {
SPDK_ERRLOG("alloc qpair_cpl failed\n"); SPDK_ERRLOG("alloc qpair_cpl failed\n");
return -ENOMEM; return -ENOMEM;
@ -1031,7 +1037,8 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair)
* This ensures the PRP list embedded in the nvme_tracker object will not span a * This ensures the PRP list embedded in the nvme_tracker object will not span a
* 4KB boundary, while allowing access to trackers in tr[] via normal array indexing. * 4KB boundary, while allowing access to trackers in tr[] via normal array indexing.
*/ */
pqpair->tr = spdk_dma_zmalloc(num_trackers * sizeof(*tr), sizeof(*tr), NULL); pqpair->tr = spdk_zmalloc(num_trackers * sizeof(*tr), sizeof(*tr), NULL,
SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
if (pqpair->tr == NULL) { if (pqpair->tr == NULL) {
SPDK_ERRLOG("nvme_tr failed\n"); SPDK_ERRLOG("nvme_tr failed\n");
return -ENOMEM; return -ENOMEM;
@ -1334,18 +1341,18 @@ nvme_pcie_qpair_destroy(struct spdk_nvme_qpair *qpair)
nvme_pcie_admin_qpair_destroy(qpair); nvme_pcie_admin_qpair_destroy(qpair);
} }
if (pqpair->cmd && !pqpair->sq_in_cmb) { if (pqpair->cmd && !pqpair->sq_in_cmb) {
spdk_dma_free(pqpair->cmd); spdk_free(pqpair->cmd);
} }
if (pqpair->cpl) { if (pqpair->cpl) {
spdk_dma_free(pqpair->cpl); spdk_free(pqpair->cpl);
} }
if (pqpair->tr) { if (pqpair->tr) {
spdk_dma_free(pqpair->tr); spdk_free(pqpair->tr);
} }
nvme_qpair_deinit(qpair); nvme_qpair_deinit(qpair);
spdk_dma_free(pqpair); spdk_free(pqpair);
return 0; return 0;
} }
@ -1573,7 +1580,8 @@ nvme_pcie_ctrlr_create_io_qpair(struct spdk_nvme_ctrlr *ctrlr, uint16_t qid,
assert(ctrlr != NULL); assert(ctrlr != NULL);
pqpair = spdk_dma_zmalloc(sizeof(*pqpair), 64, NULL); pqpair = spdk_zmalloc(sizeof(*pqpair), 64, NULL,
SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
if (pqpair == NULL) { if (pqpair == NULL) {
return NULL; return NULL;
} }

3
lib/nvme/nvme_qpair.c
View File

@ -448,7 +448,8 @@ nvme_qpair_init(struct spdk_nvme_qpair *qpair, uint16_t id,
req_size_padded = (sizeof(struct nvme_request) + 63) & ~(size_t)63; req_size_padded = (sizeof(struct nvme_request) + 63) & ~(size_t)63;
qpair->req_buf = spdk_dma_zmalloc(req_size_padded * num_requests, 64, NULL); qpair->req_buf = spdk_zmalloc(req_size_padded * num_requests, 64, NULL,
SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
if (qpair->req_buf == NULL) { if (qpair->req_buf == NULL) {
return -ENOMEM; return -ENOMEM;
} }

44
test/common/lib/test_env.c
View File

@ -65,11 +65,11 @@ spdk_memzone_reserve_aligned(const char *name, size_t len, int socket_id,
return malloc(len); return malloc(len);
} }
DEFINE_RETURN_MOCK(spdk_dma_malloc, void *); DEFINE_RETURN_MOCK(spdk_malloc, void *);
void * void *
spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr) spdk_malloc(size_t size, size_t align, uint64_t *phys_addr, int socket_id, uint32_t flags)
{ {
HANDLE_RETURN_MOCK(spdk_dma_malloc); HANDLE_RETURN_MOCK(spdk_malloc);
void *buf = NULL; void *buf = NULL;
if (posix_memalign(&buf, align, size)) { if (posix_memalign(&buf, align, size)) {
@ -82,18 +82,36 @@ spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr)
return buf; return buf;
} }
DEFINE_RETURN_MOCK(spdk_zmalloc, void *);
void *
spdk_zmalloc(size_t size, size_t align, uint64_t *phys_addr, int socket_id, uint32_t flags)
{
HANDLE_RETURN_MOCK(spdk_zmalloc);
void *buf = spdk_malloc(size, align, phys_addr, -1, 1);
if (buf != NULL) {
memset(buf, 0, size);
}
return buf;
}
DEFINE_RETURN_MOCK(spdk_dma_malloc, void *);
void *
spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr)
{
HANDLE_RETURN_MOCK(spdk_dma_malloc);
return spdk_malloc(size, align, phys_addr, -1, 1);
}
DEFINE_RETURN_MOCK(spdk_dma_zmalloc, void *); DEFINE_RETURN_MOCK(spdk_dma_zmalloc, void *);
void * void *
spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr) spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr)
{ {
HANDLE_RETURN_MOCK(spdk_dma_zmalloc); HANDLE_RETURN_MOCK(spdk_dma_zmalloc);
void *buf = spdk_dma_malloc(size, align, phys_addr); return spdk_zmalloc(size, align, phys_addr, -1, 1);
if (buf != NULL) {
memset(buf, 0, size);
}
return buf;
} }
DEFINE_RETURN_MOCK(spdk_dma_malloc_socket, void *); DEFINE_RETURN_MOCK(spdk_dma_malloc_socket, void *);
@ -124,11 +142,17 @@ spdk_dma_realloc(void *buf, size_t size, size_t align, uint64_t *phys_addr)
} }
void void
spdk_dma_free(void *buf) spdk_free(void *buf)
{ {
free(buf); free(buf);
} }
void
spdk_dma_free(void *buf)
{
return spdk_free(buf);
}
DEFINE_RETURN_MOCK(spdk_vtophys, uint64_t); DEFINE_RETURN_MOCK(spdk_vtophys, uint64_t);
uint64_t uint64_t
spdk_vtophys(void *buf) spdk_vtophys(void *buf)