Commit eb6a2cb8 authored by zkhatami88's avatar zkhatami88 Committed by Jim Harris
Browse files

nvme:replacing spdk_dma_malloc with spdk_z/malloc 



Change-Id: I755d36495e7d8e55c26c4103a9520102223798ef
Signed-off-by: default avatarzkhatami88 <z.khatami88@gmail.com>
Reviewed-on: https://review.gerrithub.io/409960


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Chandler-Test-Pool: SPDK Automated Test System <sys_sgsw@intel.com>
parent 4c8a350d

examples/nvme/hello_world/hello_world.c

+4 −4
Original line number Diff line number Diff line
@@ -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");

lib/nvme/nvme.c

+3 −2
Original line number Diff line number Diff line
@@ -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;

	}

lib/nvme/nvme_ctrlr.c

+13 −12
Original line number Diff line number Diff line
@@ -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);

	}

}

lib/nvme/nvme_pcie.c

+26 −18
Original line number Diff line number Diff line
@@ -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;

	}

lib/nvme/nvme_qpair.c

+2 −1
Original line number Diff line number Diff line
@@ -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;

	}