d/numam-spdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

nvme: clean up nvme_ctrlr_cmd_ut

Browse Source 
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>
This commit is contained in:
Daniel Verkamp 2015-09-22 10:42:29 -07:00
parent 18ce432337
commit 7f9d22a494
1 changed files with 41 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
test/lib/nvme/unit/nvme_ctrlr_cmd_c/nvme_ctrlr_cmd_ut.c
View File

@ -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;
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;
req->payload_size = 0;
} else {
req->u.payload = payload;
req->payload_size = payload_size;
}
req->cb_fn = cb_fn;
req->cb_arg = cb_arg;
req->timeout = true;
if (payload == NULL || payload_size == 0) {
req->u.payload = NULL;
req->payload_size = 0;
} else {
req->u.payload = payload;
req->payload_size = 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;
struct nvme_controller ctrlr = {};
struct nvme_error_information_entry payload = {};
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);
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;
struct nvme_controller ctrlr = {};
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_controller ctrlr = {};
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)