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: Daniel Verkamp <daniel.verkamp@intel.com>

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

@@ -32,96 +32,69 @@
  *   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;
+struct nvme_request g_req;
-
-uint64_t nvme_vtophys(void *buf)
-{
-	return (uintptr_t)buf;
-}
 
 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(req->cmd.opc == NVME_OPC_GET_LOG_PAGE);
-	CU_ASSERT(cmd->opc == NVME_OPC_GET_LOG_PAGE);
-	nvme_free_request(req);
 }
 
 void verify_health_log_page(struct nvme_request *req)
 {
-	cmd = &req->cmd;
+	CU_ASSERT(req->cmd.opc == NVME_OPC_GET_LOG_PAGE);
-	CU_ASSERT(cmd->opc == NVME_OPC_GET_LOG_PAGE);
-	nvme_free_request(req);
 }
 
 void verify_error_log_page(struct nvme_request *req)
 {
-	cmd = &req->cmd;
+	CU_ASSERT(req->cmd.opc == NVME_OPC_GET_LOG_PAGE);
-	CU_ASSERT(cmd->opc == NVME_OPC_GET_LOG_PAGE);
-	nvme_free_request(req);
 }
 
 void verify_get_feature_cmd(struct nvme_request *req)
 {
-	cmd = &req->cmd;
+	CU_ASSERT(req->cmd.opc == NVME_OPC_GET_FEATURES);
-	CU_ASSERT(cmd->opc == NVME_OPC_GET_FEATURES);
-	nvme_free_request(req);
 }
 
 void verify_abort_cmd(struct nvme_request *req)
 {
-	cmd = &req->cmd;
+	CU_ASSERT(req->cmd.opc == NVME_OPC_ABORT);
-	CU_ASSERT(cmd->opc == NVME_OPC_ABORT);
-	nvme_free_request(req);
 }
 
 void verify_io_raw_cmd(struct nvme_request *req)
 {
 	struct nvme_command	command = {0};
-	uint64_t		phys_addr = 0;
-	int			rc = 100;
 
-
+	CU_ASSERT(memcmp(&req->cmd, &command, sizeof(req->cmd)) == 0);
-	cmd = &req->cmd;
-	CU_ASSERT(cmd != NULL);
-	rc = memcmp(cmd, &command, sizeof(cmd));
-	CU_ASSERT(rc == 0);
-	nvme_free_request(req);
 }
 
 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;
+	struct nvme_request *req = &g_req;
-	nvme_alloc_request(&req);
 
-	if (req != NULL) {
+	memset(req, 0, sizeof(*req));
-		memset(req, 0, offsetof(struct nvme_request, children));
 
-		if (payload == NULL || payload_size == 0) {
+	if (payload == NULL || payload_size == 0) {
-			req->u.payload = NULL;
+		req->u.payload = NULL;
-			req->payload_size = 0;
+		req->payload_size = 0;
-		} else {
+	} else {
-			req->u.payload = payload;
+		req->u.payload = payload;
-			req->payload_size = payload_size;
+		req->payload_size = payload_size;
-		}
-
-		req->cb_fn = cb_fn;
-		req->cb_arg = cb_arg;
-		req->timeout = true;
 	}
+
+	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;
+	struct nvme_firmware_page		payload = {};
-	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);
 
 	verify_fn = verify_firmware_log_page;
 
-	nvme_ctrlr_cmd_get_firmware_page(&ctrlr,
+	nvme_ctrlr_cmd_get_firmware_page(&ctrlr, &payload, NULL, NULL);
-					 payload, cb_fn, cb_arg);
-
-	nvme_free(payload);
 }
 
 void
 test_health_get_log_page()
 {
 	struct nvme_controller			ctrlr = {};
-	struct nvme_health_information_page	*payload = NULL;
+	struct nvme_health_information_page	payload = {};
-	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);
 
 	verify_fn = verify_health_log_page;
 
-	nvme_ctrlr_cmd_get_health_information_page(&ctrlr, nsid,
+	nvme_ctrlr_cmd_get_health_information_page(&ctrlr, 0, &payload, NULL, NULL);
-			payload, cb_fn, cb_arg);
-
-	nvme_free(payload);
 }
 
 void
 test_error_get_log_page()
 {
-	struct nvme_controller			*ctrlr = NULL;
+	struct nvme_controller			ctrlr = {};
-	struct nvme_controller_data		*ctrldata = NULL;
+	struct nvme_error_information_entry	payload = {};
-	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),
+	ctrlr.cdata.elpe = 5;
-			      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);
-
-	ctrlr->cdata = *ctrldata;
-	ctrlr->cdata.elpe = 5;
 
 	verify_fn = verify_error_log_page;
 
-	nvme_ctrlr_cmd_get_error_page(ctrlr, payload,
+	/* valid page */
-				      num_entries, cb_fn, cb_arg);
+	nvme_ctrlr_cmd_get_error_page(&ctrlr, &payload, 1, NULL, NULL);
-	num_entries = 50;
-	nvme_ctrlr_cmd_get_error_page(ctrlr, payload,
-				      num_entries, cb_fn, cb_arg);
 
-
+	/* out of range page */
-	nvme_free(payload);
+	nvme_ctrlr_cmd_get_error_page(&ctrlr, &payload, 50, NULL, NULL);
-	nvme_free(ctrlr);
-	nvme_free(ctrldata);
 }
 
 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,
+	nvme_ctrlr_cmd_get_feature(&ctrlr, 1, 1, NULL, 0, NULL, NULL);
-				   payload_size, cb_fn, cb_arg);
 }
 
 void
 test_abort_cmd()
 {
-	struct nvme_controller ctrlr = {};
+	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_controller	ctrlr = {};
-	struct nvme_command	*cmd = NULL;
+	struct nvme_command	cmd = {};
-	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));
 
 	verify_fn = verify_io_raw_cmd;
 
-	nvme_ctrlr_cmd_io_raw(&ctrlr, cmd, buf, len, cb_fn, cb_arg);
+	nvme_ctrlr_cmd_io_raw(&ctrlr, &cmd, NULL, 1, NULL, NULL);
-	nvme_free(cmd);
 }
 
 int main(int argc, char **argv)