From e6628ef0a2c7b518511f2f1d3008d44c7e11194c Mon Sep 17 00:00:00 2001 From: Dolev Raviv Date: Thu, 10 Oct 2013 09:52:04 +0300 Subject: [PATCH] scsi: ufs: rework unit test infrastructure Upgrade the APIs used. Encapsulate test ops (read/write/open functions) and dentry creation in macros. Fix naming collisions with mmc tests. Change-Id: I5c48b369beaf902f8187ced9d884a2149a8644f0 Signed-off-by: Dolev Raviv --- drivers/scsi/ufs/ufs_test.c | 435 +++++++++++++++--------------------- 1 file changed, 174 insertions(+), 261 deletions(-) diff --git a/drivers/scsi/ufs/ufs_test.c b/drivers/scsi/ufs/ufs_test.c index de55b5a5eb83..e726fbb2d2ef 100644 --- a/drivers/scsi/ufs/ufs_test.c +++ b/drivers/scsi/ufs/ufs_test.c @@ -46,23 +46,44 @@ #define test_pr_info(fmt, args...) pr_info("%s: "fmt"\n", MODULE_NAME, args) #define test_pr_err(fmt, args...) pr_err("%s: "fmt"\n", MODULE_NAME, args) +#define TEST_OPS(test_name, upper_case_name) \ +static int ufs_test_ ## test_name ## _show(struct seq_file *file, \ + void *data) \ +{ return ufs_test_show(file, UFS_TEST_ ## upper_case_name); } \ +static int ufs_test_ ## test_name ## _open(struct inode *inode, \ + struct file *file) \ +{ return single_open(file, ufs_test_ ## test_name ## _show, \ + inode->i_private); } \ +static ssize_t ufs_test_ ## test_name ## _write(struct file *file, \ + const char __user *buf, size_t count, loff_t *ppos) \ +{ return ufs_test_write(file, buf, count, ppos, \ + UFS_TEST_ ## upper_case_name); } \ +const struct file_operations ufs_test_ ## test_name ## _ops = { \ + .open = ufs_test_ ## test_name ## _open, \ + .read = seq_read, \ + .write = ufs_test_ ## test_name ## _write, \ +}; + +#define add_test(utd, test_name, upper_case_name) \ +ufs_test_add_test(utd, UFS_TEST_ ## upper_case_name, "ufs_test_"#test_name,\ + &(ufs_test_ ## test_name ## _ops)); \ + + + + + enum ufs_test_testcases { UFS_TEST_WRITE_READ_TEST, - TEST_LONG_SEQUENTIAL_READ, - TEST_LONG_SEQUENTIAL_WRITE, -}; + UFS_TEST_LONG_SEQUENTIAL_READ, + UFS_TEST_LONG_SEQUENTIAL_WRITE, -struct ufs_test_debug { - struct dentry *write_read_test; /* basic test */ - struct dentry *random_test_seed; /* parameters in utils */ - struct dentry *long_sequential_read_test; - struct dentry *long_sequential_write_test; + NUM_TESTS, }; struct ufs_test_data { /* Data structure for debugfs dentrys */ - struct ufs_test_debug debug; + struct dentry **test_list; /* * Data structure containing individual test information, including * self-defined specific data @@ -72,8 +93,6 @@ struct ufs_test_data { struct blk_dev_test_type bdt; /* A wait queue for OPs to complete */ wait_queue_head_t wait_q; - /* a flag for read compleation */ - bool read_completed; /* a flag for write compleation */ bool write_completed; /* @@ -81,13 +100,40 @@ struct ufs_test_data { * disabled and 2 BIOs are written. */ unsigned int random_test_seed; + struct dentry *random_test_seed_dentry; + /* A counter for the number of test requests completed */ unsigned int completed_req_count; }; static struct ufs_test_data *utd; -static bool message_repeat; +static int ufs_test_add_test(struct ufs_test_data *utd, + enum ufs_test_testcases test_id, char *test_str, + const struct file_operations *test_fops) +{ + int ret = 0; + struct dentry *tests_root; + + if (test_id >= NUM_TESTS) + return -EINVAL; + + tests_root = test_iosched_get_debugfs_tests_root(); + if (!tests_root) { + test_pr_err("%s: Failed to create debugfs root.", __func__); + return -EINVAL; + } + + utd->test_list[test_id] = debugfs_create_file(test_str, + S_IRUGO | S_IWUGO, tests_root, + NULL, test_fops); + if (!utd->test_list[test_id]) { + test_pr_err("%s: Could not create the test %s", test_str, + __func__); + ret = -ENOMEM; + } + return ret; +} static char *ufs_test_get_test_case_str(struct test_data *td) { @@ -100,10 +146,10 @@ static char *ufs_test_get_test_case_str(struct test_data *td) case UFS_TEST_WRITE_READ_TEST: return "UFS write read test"; break; - case TEST_LONG_SEQUENTIAL_READ: + case UFS_TEST_LONG_SEQUENTIAL_READ: return "UFS long sequential read test"; break; - case TEST_LONG_SEQUENTIAL_WRITE: + case UFS_TEST_LONG_SEQUENTIAL_WRITE: return "UFS long sequential write test"; break; default: @@ -140,16 +186,53 @@ static void ufs_test_write_read_test_end_io_fn(struct request *rq, int err) struct test_request *test_rq = (struct test_request *)rq->elv.priv[0]; BUG_ON(!test_rq); + test_pr_info("%s: request %d completed, err=%d", + __func__, test_rq->req_id, err); test_rq->req_completed = 1; test_rq->req_result = err; - test_pr_info("%s: request %d completed, err=%d", - __func__, test_rq->req_id, err); - utd->write_completed = true; wake_up(&utd->wait_q); } +static int ufs_test_show(struct seq_file *file, int test_case) +{ + char *test_description; + + switch (test_case) { + case UFS_TEST_WRITE_READ_TEST: + test_description = "\nufs_write_read_test\n" + "=========\n" + "Description:\n" + "This test write once a random block and than reads it to " + "verify its content. Used to debug first time transactions.\n"; + break; + case UFS_TEST_LONG_SEQUENTIAL_READ: + test_description = "\nufs_long_sequential_read_test\n" + "=========\n" + "Description:\n" + "This test runs the following scenarios\n" + "- Long Sequential Read Test: this test measures read " + "throughput at the driver level by sequentially reading many " + "large requests.\n"; + break; + case UFS_TEST_LONG_SEQUENTIAL_WRITE: + test_description = "\nufs_long_sequential_write_test\n" + "=========\n" + "Description:\n" + "This test runs the following scenarios\n" + "- Long Sequential Write Test: this test measures write " + "throughput at the driver level by sequentially writing many " + "large requests\n"; + break; + default: + test_description = "Unknown test"; + } + + seq_puts(file, test_description); + return 0; +} + static struct gendisk *ufs_test_get_rq_disk(void) { struct request_queue *req_q = test_iosched_get_req_queue(); @@ -200,8 +283,8 @@ static int ufs_test_run_write_read_test(struct test_data *td) , __func__, num_bios, td->wr_rd_next_req_id); utd->write_completed = false; - ret = test_iosched_add_wr_rd_test_req(0, WRITE, start_sec, - num_bios, TEST_PATTERN_5A, + ret = test_iosched_add_wr_rd_test_req(0, WRITE, start_sec, num_bios, + TEST_PATTERN_5A, ufs_test_write_read_test_end_io_fn); if (ret) { @@ -228,81 +311,14 @@ static int ufs_test_run_write_read_test(struct test_data *td) return ret; } -static -int ufs_test_write_read_test_open_cb(struct inode *inode, struct file *file) -{ - file->private_data = inode->i_private; - message_repeat = 1; - test_pr_info("%s:UFS test initialized", __func__); - return 0; -} - -static ssize_t ufs_test_write_read_test_write_cb(struct file *file, - const char __user *buf, - size_t count, loff_t *ppos) -{ - int ret = 0; - int i; - int number; - - sscanf(buf, "%d", &number); - - if (number <= 0) - number = 1; - - test_pr_info("%s:the test will run for %d iterations.", - __func__, number); - memset(&utd->test_info, 0, sizeof(struct test_info)); - - /* Initializing test */ - utd->test_info.data = utd; - utd->test_info.get_test_case_str_fn = ufs_test_get_test_case_str; - utd->test_info.testcase = UFS_TEST_WRITE_READ_TEST; - utd->test_info.get_rq_disk_fn = ufs_test_get_rq_disk; - utd->test_info.run_test_fn = ufs_test_run_write_read_test; - - /* Running the test multiple times */ - for (i = 0; i < number; ++i) { - ret = test_iosched_start_test(&utd->test_info); - if (ret) { - test_pr_err("%s: Test failed.", __func__); - return ret; - } - } - - test_pr_info("%s: Completed all the ufs test iterations.", __func__); - - return count; -} - -static ssize_t ufs_test_write_read_test_read_cb(struct file *file, - char __user *buffer, size_t count, loff_t *offset) -{ - memset((void *) buffer, 0, count); - - snprintf(buffer, count, "\nThis is a UFS write-read test for debug.\n"); - - if (message_repeat == 1) { - message_repeat = 0; - return strnlen(buffer, count); - } else - return 0; -} - -const struct file_operations write_read_test_ops = { - .open = ufs_test_write_read_test_open_cb, - .write = ufs_test_write_read_test_write_cb, - .read = ufs_test_write_read_test_read_cb, -}; - static void long_seq_test_free_end_io_fn(struct request *rq, int err) { struct test_request *test_rq; struct test_data *ptd = test_get_test_data(); - if (rq) + if (rq) { test_rq = (struct test_request *)rq->elv.priv[0]; - else { + } else { test_pr_err("%s: error: NULL request", __func__); return; } @@ -319,8 +335,9 @@ static void long_seq_test_free_end_io_fn(struct request *rq, int err) kfree(test_rq); utd->completed_req_count++; - test_pr_err("%s: request %d completed, err=%d", - __func__, test_rq->req_id, err); + if (err) + test_pr_err("%s: request %d completed, err=%d", __func__, + test_rq->req_id, err); check_test_completion(); @@ -337,7 +354,7 @@ static int run_long_seq_test(struct test_data *td) utd->completed_req_count = 0; inserted_requests = 0; - if (td->test_info.testcase == TEST_LONG_SEQUENTIAL_READ) + if (td->test_info.testcase == UFS_TEST_LONG_SEQUENTIAL_READ) direction = READ; else direction = WRITE; @@ -381,11 +398,13 @@ static int run_long_seq_test(struct test_data *td) return ret; } - -void long_seq_test_calc_throughput(unsigned long mtime, - unsigned long byte_count) +static int long_seq_test_calc_throughput(struct test_data *td) { unsigned long fraction, integer; + unsigned long mtime, byte_count; + + mtime = ktime_to_ms(utd->test_info.test_duration); + byte_count = utd->test_info.test_byte_count; test_pr_info("%s: time is %lu msec, size is %lu.%lu MiB", __func__, mtime, LONG_TEST_SIZE_INTEGER(byte_count), @@ -403,168 +422,80 @@ void long_seq_test_calc_throughput(unsigned long mtime, test_pr_info("%s: Throughput: %lu.%lu MiB/sec\n", __func__, integer, fraction); -} -static ssize_t long_sequential_read_test_write(struct file *file, - const char __user *buf, - size_t count, - loff_t *ppos) -{ - int ret = 0; - int i = 0; - int number = -1; - unsigned long mtime, byte_count; - - test_pr_info("%s: -- UFS Long Sequential Read TEST --", __func__); - - sscanf(buf, "%d", &number); - - if (number <= 0) - number = 1; - - memset(&utd->test_info, 0, sizeof(struct test_info)); - - utd->test_info.data = utd; - utd->test_info.get_rq_disk_fn = ufs_test_get_rq_disk; - utd->test_info.run_test_fn = run_long_seq_test; - utd->test_info.get_test_case_str_fn = ufs_test_get_test_case_str; - utd->test_info.testcase = TEST_LONG_SEQUENTIAL_READ; - - for (i = 0 ; i < number ; ++i) { - test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); - test_pr_info("%s: ====================", __func__); - - ret = test_iosched_start_test(&utd->test_info); - if (ret) - break; - - mtime = ktime_to_ms(utd->test_info.test_duration); - byte_count = utd->test_info.test_byte_count; - - long_seq_test_calc_throughput(mtime, byte_count); - - /* Allow FS requests to be dispatched */ - msleep(1000); - } - - return count; -} - -static ssize_t long_sequential_read_test_read(struct file *file, - char __user *buffer, - size_t count, - loff_t *offset) -{ - memset((void *)buffer, 0, count); - - snprintf(buffer, count, - "\nufs_long_sequential_read_test\n" - "=========\n" - "Description:\n" - "This test runs the following scenarios\n" - "- Long Sequential Read Test: this test measures read " - "throughput at the driver level by sequentially reading many " - "large requests.\n"); - - if (message_repeat == 1) { - message_repeat = 0; - return strnlen(buffer, count); - } else - return 0; -} - -static bool message_repeat; -static int test_open(struct inode *inode, struct file *file) -{ - file->private_data = inode->i_private; - message_repeat = 1; return 0; } -const struct file_operations long_sequential_read_test_ops = { - .open = test_open, - .write = long_sequential_read_test_write, - .read = long_sequential_read_test_read, -}; - -static ssize_t long_sequential_write_test_write(struct file *file, - const char __user *buf, - size_t count, - loff_t *ppos) +static ssize_t ufs_test_write(struct file *file, const char __user *buf, + size_t count, loff_t *ppos, int test_case) { int ret = 0; - int i = 0; - int number = -1; - unsigned long mtime, byte_count; + int i; + int number; - test_pr_info("%s: -- UFS Long Sequential Write TEST --", __func__); - - sscanf(buf, "%d", &number); + ret = kstrtoint_from_user(buf, count, 0, &number); + if (ret < 0) { + test_pr_err("%s: Error while reading test parameter value %d", + __func__, ret); + return ret; + } if (number <= 0) number = 1; + test_pr_info("%s:the test will run for %d iterations.", + __func__, number); memset(&utd->test_info, 0, sizeof(struct test_info)); + /* Initializing test */ utd->test_info.data = utd; - utd->test_info.get_rq_disk_fn = ufs_test_get_rq_disk; utd->test_info.get_test_case_str_fn = ufs_test_get_test_case_str; - utd->test_info.run_test_fn = run_long_seq_test; - utd->test_info.testcase = TEST_LONG_SEQUENTIAL_WRITE; + utd->test_info.testcase = test_case; + utd->test_info.get_rq_disk_fn = ufs_test_get_rq_disk; - for (i = 0 ; i < number ; ++i) { + switch (test_case) { + case UFS_TEST_WRITE_READ_TEST: + utd->test_info.run_test_fn = ufs_test_run_write_read_test; + break; + case UFS_TEST_LONG_SEQUENTIAL_READ: + case UFS_TEST_LONG_SEQUENTIAL_WRITE: + utd->test_info.run_test_fn = run_long_seq_test; + utd->test_info.post_test_fn = long_seq_test_calc_throughput; + break; + default: + test_pr_err("%s: Unknown test-case: %d", __func__, test_case); + WARN_ON(true); + } + + /* Running the test multiple times */ + for (i = 0; i < number; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ====================", __func__); utd->test_info.test_byte_count = 0; ret = test_iosched_start_test(&utd->test_info); - if (ret) - break; - - mtime = ktime_to_ms(utd->test_info.test_duration); - byte_count = utd->test_info.test_byte_count; - - long_seq_test_calc_throughput(mtime, byte_count); + if (ret) { + test_pr_err("%s: Test failed, err=%d.", __func__, ret); + return ret; + } /* Allow FS requests to be dispatched */ msleep(1000); } + test_pr_info("%s: Completed all the ufs test iterations.", __func__); + return count; } -static ssize_t long_sequential_write_test_read(struct file *file, - char __user *buffer, - size_t count, - loff_t *offset) -{ - memset((void *)buffer, 0, count); - - snprintf(buffer, count, - "\nufs_long_sequential_write_test\n" - "=========\n" - "Description:\n" - "This test runs the following scenarios\n" - "- Long Sequential Write Test: this test measures write " - "throughput at the driver level by sequentially writing many " - "large requests\n"); - - if (message_repeat == 1) { - message_repeat = 0; - return strnlen(buffer, count); - } else - return 0; -} - -const struct file_operations long_sequential_write_test_ops = { - .open = test_open, - .write = long_sequential_write_test_write, - .read = long_sequential_write_test_read, -}; +TEST_OPS(write_read_test, WRITE_READ_TEST); +TEST_OPS(long_sequential_read, LONG_SEQUENTIAL_READ); +TEST_OPS(long_sequential_write, LONG_SEQUENTIAL_WRITE); static void ufs_test_debugfs_cleanup(void) { debugfs_remove_recursive(test_iosched_get_debugfs_tests_root()); + kfree(utd->test_list); } static int ufs_test_debugfs_init(void) @@ -575,59 +506,43 @@ static int ufs_test_debugfs_init(void) utils_root = test_iosched_get_debugfs_utils_root(); tests_root = test_iosched_get_debugfs_tests_root(); + utd->test_list = kmalloc(sizeof(struct dentry *) * NUM_TESTS, + GFP_KERNEL); + if (!utd->test_list) { + test_pr_err("%s: failed to allocate tests dentrys", __func__); + return -ENODEV; + } + if (!utils_root || !tests_root) { test_pr_err("%s: Failed to create debugfs root.", __func__); ret = -EINVAL; - goto exit; + goto exit_err; } - utd->debug.random_test_seed = debugfs_create_u32("random_test_seed", + utd->random_test_seed_dentry = debugfs_create_u32("random_test_seed", S_IRUGO | S_IWUGO, utils_root, &utd->random_test_seed); - if (!utd->debug.random_test_seed) { + if (!utd->random_test_seed_dentry) { test_pr_err("%s: Could not create debugfs random_test_seed.", __func__); ret = -ENOMEM; - goto exit; - } - - utd->debug.write_read_test = debugfs_create_file("ufs_write_read_test", - S_IRUGO | S_IWUGO, tests_root, - NULL, &write_read_test_ops); - - if (!utd->debug.write_read_test) { - ret = -ENOMEM; goto exit_err; } - utd->debug.long_sequential_read_test = debugfs_create_file( - "ufs_long_sequential_read_test", - S_IRUGO | S_IWUGO, - tests_root, - NULL, - &long_sequential_read_test_ops); - - if (!utd->debug.long_sequential_read_test) { - ret = -ENOMEM; + ret = add_test(utd, write_read_test, WRITE_READ_TEST); + if (ret) goto exit_err; - } - - utd->debug.long_sequential_write_test = debugfs_create_file( - "ufs_long_sequential_write_test", - S_IRUGO | S_IWUGO, - tests_root, - NULL, - &long_sequential_write_test_ops); - - if (!utd->debug.long_sequential_write_test) { - ret = -ENOMEM; + ret = add_test(utd, long_sequential_read, LONG_SEQUENTIAL_READ); + if (ret) + goto exit_err; + ret = add_test(utd, long_sequential_write, LONG_SEQUENTIAL_WRITE); + if (ret) goto exit_err; - } goto exit; exit_err: - debugfs_remove_recursive(tests_root); + ufs_test_debugfs_cleanup(); exit: return ret; } @@ -665,10 +580,8 @@ static void __exit ufs_test_exit(void) test_iosched_unregister(&utd->bdt); kfree(utd); } -module_init(ufs_test_init) -; -module_exit(ufs_test_exit) -; +module_init(ufs_test_init); +module_exit(ufs_test_exit); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("UFC test");