Commit 7f9d22a4 authored by Daniel Verkamp's avatar Daniel Verkamp
Browse files

nvme: clean up nvme_ctrlr_cmd_ut 



Replace a bunch of allocations with stack variables.

Remove many unnecessary variables.

The actual tests are unchanged (and still not testing very much), but
this removes a lot of cruft that should make it easier to see what the
tests are actually doing.

Change-Id: I2c4810391cbf4d8edde88d5bc1c0dddcba3ae175
Signed-off-by: default avatarDaniel Verkamp <daniel.verkamp@intel.com>
parent 18ce4323

test/lib/nvme/unit/nvme_ctrlr_cmd_c/nvme_ctrlr_cmd_ut.c

+43 −132
Original line number Diff line number Diff line
@@ -32,83 +32,56 @@ 
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */



#include <stdbool.h>

#include "nvme/nvme_internal.h"



#include "CUnit/Basic.h"



#include "nvme/nvme_ctrlr_cmd.c"



char outbuf[OUTBUF_SIZE];



struct nvme_command *cmd = NULL;



uint64_t nvme_vtophys(void *buf)

{

	return (uintptr_t)buf;

}

struct nvme_request g_req;



typedef void (*verify_request_fn_t)(struct nvme_request *req);

verify_request_fn_t verify_fn;



void verify_firmware_log_page(struct nvme_request *req)

{

	cmd = &req->cmd;

	CU_ASSERT(cmd->opc == NVME_OPC_GET_LOG_PAGE);

	nvme_free_request(req);

	CU_ASSERT(req->cmd.opc == NVME_OPC_GET_LOG_PAGE);

}



void verify_health_log_page(struct nvme_request *req)

{

	cmd = &req->cmd;

	CU_ASSERT(cmd->opc == NVME_OPC_GET_LOG_PAGE);

	nvme_free_request(req);

	CU_ASSERT(req->cmd.opc == NVME_OPC_GET_LOG_PAGE);

}



void verify_error_log_page(struct nvme_request *req)

{

	cmd = &req->cmd;

	CU_ASSERT(cmd->opc == NVME_OPC_GET_LOG_PAGE);

	nvme_free_request(req);

	CU_ASSERT(req->cmd.opc == NVME_OPC_GET_LOG_PAGE);

}



void verify_get_feature_cmd(struct nvme_request *req)

{

	cmd = &req->cmd;

	CU_ASSERT(cmd->opc == NVME_OPC_GET_FEATURES);

	nvme_free_request(req);

	CU_ASSERT(req->cmd.opc == NVME_OPC_GET_FEATURES);

}



void verify_abort_cmd(struct nvme_request *req)

{

	cmd = &req->cmd;

	CU_ASSERT(cmd->opc == NVME_OPC_ABORT);

	nvme_free_request(req);

	CU_ASSERT(req->cmd.opc == NVME_OPC_ABORT);

}



void verify_io_raw_cmd(struct nvme_request *req)

{

	struct nvme_command	command = {0};

	uint64_t		phys_addr = 0;

	int			rc = 100;





	cmd = &req->cmd;

	CU_ASSERT(cmd != NULL);

	rc = memcmp(cmd, &command, sizeof(cmd));

	CU_ASSERT(rc == 0);

	nvme_free_request(req);

	CU_ASSERT(memcmp(&req->cmd, &command, sizeof(req->cmd)) == 0);

}



struct nvme_request *

nvme_allocate_request(void *payload, uint32_t payload_size,

		      nvme_cb_fn_t cb_fn, void *cb_arg)

{

	struct nvme_request *req = NULL;

	nvme_alloc_request(&req);

	struct nvme_request *req = &g_req;



	if (req != NULL) {

		memset(req, 0, offsetof(struct nvme_request, children));

	memset(req, 0, sizeof(*req));



	if (payload == NULL || payload_size == 0) {

		req->u.payload = NULL;
@@ -121,7 +94,7 @@ nvme_allocate_request(void *payload, uint32_t payload_size, 
	req->cb_fn = cb_fn;

	req->cb_arg = cb_arg;

	req->timeout = true;

	}



	return req;

}
@@ -130,12 +103,16 @@ nvme_ctrlr_submit_io_request(struct nvme_controller *ctrlr, 
			     struct nvme_request *req)

{

	verify_fn(req);

	/* stop analyzer from thinking stack variable addresses are stored in a global */

	memset(req, 0, sizeof(*req));

}



void

nvme_ctrlr_submit_admin_request(struct nvme_controller *ctrlr, struct nvme_request *req)

{

	verify_fn(req);

	/* stop analyzer from thinking stack variable addresses are stored in a global */

	memset(req, 0, sizeof(*req));

}
@@ -143,136 +120,70 @@ void 
test_firmware_get_log_page()

{

	struct nvme_controller			ctrlr = {};

	struct nvme_firmware_page		*payload = NULL;

	nvme_cb_fn_t				cb_fn = NULL;

	void					*cb_arg = NULL;

	uint64_t				phys_addr = 0;



	payload = nvme_malloc("nvme_firmware_page", sizeof(struct nvme_firmware_page),

			      64, &phys_addr);

	CU_ASSERT(payload != NULL);

	struct nvme_firmware_page		payload = {};



	verify_fn = verify_firmware_log_page;



	nvme_ctrlr_cmd_get_firmware_page(&ctrlr,

					 payload, cb_fn, cb_arg);



	nvme_free(payload);

	nvme_ctrlr_cmd_get_firmware_page(&ctrlr, &payload, NULL, NULL);

}



void

test_health_get_log_page()

{

	struct nvme_controller			ctrlr = {};

	struct nvme_health_information_page	*payload = NULL;

	uint32_t				nsid = 0;

	nvme_cb_fn_t				cb_fn = NULL;

	void					*cb_arg = NULL;

	uint64_t				phys_addr = 0;



	payload = nvme_malloc("nvme_health_information_page", sizeof(struct nvme_health_information_page),

			      64, &phys_addr);

	CU_ASSERT(payload != NULL);

	struct nvme_health_information_page	payload = {};



	verify_fn = verify_health_log_page;



	nvme_ctrlr_cmd_get_health_information_page(&ctrlr, nsid,

			payload, cb_fn, cb_arg);



	nvme_free(payload);

	nvme_ctrlr_cmd_get_health_information_page(&ctrlr, 0, &payload, NULL, NULL);

}



void

test_error_get_log_page()

{

	struct nvme_controller			*ctrlr = NULL;

	struct nvme_controller_data		*ctrldata = NULL;

	struct nvme_error_information_entry	*payload = NULL;

	uint32_t				num_entries = 1;

	nvme_cb_fn_t				cb_fn = NULL;

	void					*cb_arg = NULL;

	uint64_t				phys_addr = 0;



	payload = nvme_malloc("nvme_error_information_entry", sizeof(struct nvme_error_information_entry),

			      64, &phys_addr);

	CU_ASSERT(payload != NULL);



	ctrlr = nvme_malloc("nvme_controller", sizeof(struct nvme_controller),

			    64, &phys_addr);

	CU_ASSERT(ctrlr != NULL);



	ctrldata = nvme_malloc("nvme_controller_data", sizeof(struct nvme_controller_data),

			       64, &phys_addr);

	CU_ASSERT(ctrldata != NULL);

	struct nvme_controller			ctrlr = {};

	struct nvme_error_information_entry	payload = {};



	ctrlr->cdata = *ctrldata;

	ctrlr->cdata.elpe = 5;

	ctrlr.cdata.elpe = 5;



	verify_fn = verify_error_log_page;



	nvme_ctrlr_cmd_get_error_page(ctrlr, payload,

				      num_entries, cb_fn, cb_arg);

	num_entries = 50;

	nvme_ctrlr_cmd_get_error_page(ctrlr, payload,

				      num_entries, cb_fn, cb_arg);



	/* valid page */

	nvme_ctrlr_cmd_get_error_page(&ctrlr, &payload, 1, NULL, NULL);



	nvme_free(payload);

	nvme_free(ctrlr);

	nvme_free(ctrldata);

	/* out of range page */

	nvme_ctrlr_cmd_get_error_page(&ctrlr, &payload, 50, NULL, NULL);

}



void

test_get_feature_cmd()

{

	struct nvme_controller	ctrlr = {};

	uint8_t			feature = 1;

	uint32_t		cdw11 = 1;

	void			*payload = NULL;

	uint32_t		payload_size = 0;

	nvme_cb_fn_t		cb_fn = NULL;

	void			*cb_arg = NULL;



	verify_fn = verify_get_feature_cmd;



	nvme_ctrlr_cmd_get_feature(&ctrlr, feature, cdw11, payload,

				   payload_size, cb_fn, cb_arg);

	nvme_ctrlr_cmd_get_feature(&ctrlr, 1, 1, NULL, 0, NULL, NULL);

}



void

test_abort_cmd()

{

	struct nvme_controller	ctrlr = {};

	uint16_t		cid = 0;

	uint16_t		sqid = 0;

	nvme_cb_fn_t		cb_fn = NULL;

	void			*cb_arg = NULL;



	verify_fn = verify_abort_cmd;



	nvme_ctrlr_cmd_abort(&ctrlr, cid, sqid, cb_fn, cb_arg);

	nvme_ctrlr_cmd_abort(&ctrlr, 0, 0, NULL, NULL);

}



void

test_io_raw_cmd()

{

	struct nvme_controller	ctrlr = {};

	struct nvme_command	*cmd = NULL;

	void			*buf = NULL;

	uint32_t		len = 1;

	nvme_cb_fn_t		cb_fn = NULL;

	void			*cb_arg = NULL;

	uint64_t		phys_addr = 0;



	cmd = nvme_malloc("nvme_command", sizeof(struct nvme_command),

			  64, &phys_addr);

	CU_ASSERT(cmd != NULL);

	memset(cmd, 0, sizeof(cmd));

	struct nvme_command	cmd = {};



	verify_fn = verify_io_raw_cmd;



	nvme_ctrlr_cmd_io_raw(&ctrlr, cmd, buf, len, cb_fn, cb_arg);

	nvme_free(cmd);

	nvme_ctrlr_cmd_io_raw(&ctrlr, &cmd, NULL, 1, NULL, NULL);

}



int main(int argc, char **argv)