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.
*/
printf("%s", sequence->buf);
spdk_dma_free(sequence->buf);
spdk_free(sequence->buf);
sequence->is_completed = 1;
}
@ -128,9 +128,9 @@ write_complete(void *arg, const struct spdk_nvme_cpl *completion)
if (sequence->using_cmb_io) {
spdk_nvme_ctrlr_free_cmb_io_buffer(ns_entry->ctrlr, sequence->buf, 0x1000);
} 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,
0, /* LBA start */
@ -178,7 +178,7 @@ hello_world(void)
sequence.buf = spdk_nvme_ctrlr_alloc_cmb_io_buffer(ns_entry->ctrlr, 0x1000);
if (sequence.buf == NULL) {
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) {
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;
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) {
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,
NULL);
if (!req) {
spdk_dma_free(dma_buffer);
spdk_free(dma_buffer);
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 spdk_nvme_intel_log_page_directory *log_page_directory;
log_page_directory = spdk_dma_zmalloc(sizeof(struct spdk_nvme_intel_log_page_directory),
64, &phys_addr);
log_page_directory = spdk_zmalloc(sizeof(struct spdk_nvme_intel_log_page_directory),
64, &phys_addr, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_DMA);
if (log_page_directory == NULL) {
SPDK_ERRLOG("could not allocate log_page_directory\n");
return -ENXIO;
@ -382,13 +382,13 @@ static int nvme_ctrlr_set_intel_support_log_pages(struct spdk_nvme_ctrlr *ctrlr)
nvme_completion_poll_cb,
&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");
return -ENXIO;
}
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;
}
@ -1064,13 +1064,13 @@ nvme_ctrlr_destruct_namespaces(struct spdk_nvme_ctrlr *ctrlr)
nvme_ns_destruct(&ctrlr->ns[i]);
}
spdk_dma_free(ctrlr->ns);
spdk_free(ctrlr->ns);
ctrlr->ns = NULL;
ctrlr->num_ns = 0;
}
if (ctrlr->nsdata) {
spdk_dma_free(ctrlr->nsdata);
spdk_free(ctrlr->nsdata);
ctrlr->nsdata = NULL;
}
@ -1124,14 +1124,14 @@ nvme_ctrlr_construct_namespaces(struct spdk_nvme_ctrlr *ctrlr)
return 0;
}
ctrlr->ns = spdk_dma_zmalloc(nn * sizeof(struct spdk_nvme_ns), 64,
&phys_addr);
ctrlr->ns = spdk_zmalloc(nn * sizeof(struct spdk_nvme_ns), 64,
&phys_addr, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
if (ctrlr->ns == NULL) {
goto fail;
}
ctrlr->nsdata = spdk_dma_zmalloc(nn * sizeof(struct spdk_nvme_ns_data), 64,
&phys_addr);
ctrlr->nsdata = spdk_zmalloc(nn * sizeof(struct spdk_nvme_ns_data), 64,
&phys_addr, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE | SPDK_MALLOC_DMA);
if (ctrlr->nsdata == NULL) {
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 */
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) {
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));
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;
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) {
return -ENOMEM;
}
@ -794,7 +794,8 @@ struct spdk_nvme_ctrlr *nvme_pcie_ctrlr_construct(const struct spdk_nvme_transpo
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) {
close(claim_fd);
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);
if (rc != 0) {
close(claim_fd);
spdk_dma_free(pctrlr);
spdk_free(pctrlr);
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)) {
SPDK_ERRLOG("get_cap() failed\n");
close(claim_fd);
spdk_dma_free(pctrlr);
spdk_free(pctrlr);
return NULL;
}
if (nvme_ctrlr_get_vs(&pctrlr->ctrlr, &vs)) {
SPDK_ERRLOG("get_vs() failed\n");
close(claim_fd);
spdk_dma_free(pctrlr);
spdk_free(pctrlr);
return NULL;
}
@ -923,7 +924,7 @@ nvme_pcie_ctrlr_destruct(struct spdk_nvme_ctrlr *ctrlr)
spdk_pci_device_detach(devhandle);
}
spdk_dma_free(pctrlr);
spdk_free(pctrlr);
return 0;
}
@ -972,6 +973,7 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair)
uint64_t offset;
uint16_t num_trackers;
size_t page_align = 0x200000;
uint32_t flags = SPDK_MALLOC_DMA;
/*
* 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;
if (nvme_qpair_is_admin_queue(&pqpair->qpair)) {
flags |= SPDK_MALLOC_SHARE;
}
/* cmd and cpl rings must be aligned on page size boundaries. */
if (ctrlr->opts.use_cmb_sqs) {
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.
*/
if (pqpair->sq_in_cmb == false) {
pqpair->cmd = spdk_dma_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cmd),
page_align,
&pqpair->cmd_bus_addr);
pqpair->cmd = spdk_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cmd),
page_align, &pqpair->cmd_bus_addr,
SPDK_ENV_SOCKET_ID_ANY, flags);
if (pqpair->cmd == NULL) {
SPDK_ERRLOG("alloc qpair_cmd failed\n");
return -ENOMEM;
}
}
pqpair->cpl = spdk_dma_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cpl),
page_align,
&pqpair->cpl_bus_addr);
pqpair->cpl = spdk_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cpl),
page_align, &pqpair->cpl_bus_addr,
SPDK_ENV_SOCKET_ID_ANY, flags);
if (pqpair->cpl == NULL) {
SPDK_ERRLOG("alloc qpair_cpl failed\n");
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
* 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) {
SPDK_ERRLOG("nvme_tr failed\n");
return -ENOMEM;
@ -1334,18 +1341,18 @@ nvme_pcie_qpair_destroy(struct spdk_nvme_qpair *qpair)
nvme_pcie_admin_qpair_destroy(qpair);
}
if (pqpair->cmd && !pqpair->sq_in_cmb) {
spdk_dma_free(pqpair->cmd);
spdk_free(pqpair->cmd);
}
if (pqpair->cpl) {
spdk_dma_free(pqpair->cpl);
spdk_free(pqpair->cpl);
}
if (pqpair->tr) {
spdk_dma_free(pqpair->tr);
spdk_free(pqpair->tr);
}
nvme_qpair_deinit(qpair);
spdk_dma_free(pqpair);
spdk_free(pqpair);
return 0;
}
@ -1573,7 +1580,8 @@ nvme_pcie_ctrlr_create_io_qpair(struct spdk_nvme_ctrlr *ctrlr, uint16_t qid,
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) {
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;
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) {
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);
}
DEFINE_RETURN_MOCK(spdk_dma_malloc, void *);
DEFINE_RETURN_MOCK(spdk_malloc, 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;
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;
}
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 *);
void *
spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr)
{
HANDLE_RETURN_MOCK(spdk_dma_zmalloc);
void *buf = spdk_dma_malloc(size, align, phys_addr);
if (buf != NULL) {
memset(buf, 0, size);
}
return buf;
return spdk_zmalloc(size, align, phys_addr, -1, 1);
}
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
spdk_dma_free(void *buf)
spdk_free(void *buf)
{
free(buf);
}
void
spdk_dma_free(void *buf)
{
return spdk_free(buf);
}
DEFINE_RETURN_MOCK(spdk_vtophys, uint64_t);
uint64_t
spdk_vtophys(void *buf)