/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and * only version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * */ /* MMC block test */ #include #include #include #include #include #include #include #include #include "queue.h" #include #define MODULE_NAME "mmc_block_test" #define TEST_MAX_SECTOR_RANGE (600*1024*1024) /* 600 MB */ #define TEST_MAX_BIOS_PER_REQ 128 #define CMD23_PACKED_BIT (1 << 30) #define LARGE_PRIME_1 1103515367 #define LARGE_PRIME_2 35757 #define PACKED_HDR_VER_MASK 0x000000FF #define PACKED_HDR_RW_MASK 0x0000FF00 #define PACKED_HDR_NUM_REQS_MASK 0x00FF0000 #define PACKED_HDR_BITS_16_TO_29_SET 0x3FFF0000 #define SECTOR_SIZE 512 #define NUM_OF_SECTORS_PER_BIO ((BIO_U32_SIZE * 4) / SECTOR_SIZE) #define BIO_TO_SECTOR(x) (x * NUM_OF_SECTORS_PER_BIO) /* the desired long test size to be read */ #define LONG_READ_TEST_MAX_NUM_BYTES (50*1024*1024) /* 50MB */ /* the minimum amount of requests that will be created */ #define LONG_WRITE_TEST_MIN_NUM_REQS 200 /* 100MB */ /* request queue limitation is 128 requests, and we leave 10 spare requests */ #define TEST_MAX_REQUESTS 118 #define LONG_READ_TEST_MAX_NUM_REQS (LONG_READ_TEST_MAX_NUM_BYTES / \ (TEST_MAX_BIOS_PER_REQ * sizeof(int) * BIO_U32_SIZE)) /* this doesn't allow the test requests num to be greater than the maximum */ #define LONG_READ_TEST_ACTUAL_NUM_REQS \ ((TEST_MAX_REQUESTS < LONG_READ_TEST_MAX_NUM_REQS) ? \ TEST_MAX_REQUESTS : LONG_READ_TEST_MAX_NUM_REQS) #define MB_MSEC_RATIO_APPROXIMATION ((1024 * 1024) / 1000) /* actual number of bytes in test */ #define LONG_READ_NUM_BYTES (LONG_READ_TEST_ACTUAL_NUM_REQS * \ (TEST_MAX_BIOS_PER_REQ * sizeof(int) * BIO_U32_SIZE)) /* actual number of MiB in test multiplied by 10, for single digit precision*/ #define BYTE_TO_MB_x_10(x) ((x * 10) / (1024 * 1024)) /* extract integer value */ #define LONG_TEST_SIZE_INTEGER(x) (BYTE_TO_MB_x_10(x) / 10) /* and calculate the MiB value fraction */ #define LONG_TEST_SIZE_FRACTION(x) (BYTE_TO_MB_x_10(x) - \ (LONG_TEST_SIZE_INTEGER(x) * 10)) #define LONG_WRITE_TEST_SLEEP_TIME_MS 5 #define test_pr_debug(fmt, args...) pr_debug("%s: "fmt"\n", MODULE_NAME, args) #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 SANITIZE_TEST_TIMEOUT 240000 #define NEW_REQ_TEST_SLEEP_TIME 1 #define NEW_REQ_TEST_NUM_BIOS 64 #define TEST_REQUEST_NUM_OF_BIOS 3 #define CHECK_BKOPS_STATS(stats, exp_bkops, exp_hpi, exp_suspend) \ ((stats.bkops != exp_bkops) || \ (stats.hpi != exp_hpi) || \ (stats.suspend != exp_suspend)) #define BKOPS_TEST_TIMEOUT 60000 enum is_random { NON_RANDOM_TEST, RANDOM_TEST, }; enum mmc_block_test_testcases { /* Start of send write packing test group */ SEND_WRITE_PACKING_MIN_TESTCASE, TEST_STOP_DUE_TO_READ = SEND_WRITE_PACKING_MIN_TESTCASE, TEST_STOP_DUE_TO_READ_AFTER_MAX_REQS, TEST_STOP_DUE_TO_FLUSH, TEST_STOP_DUE_TO_FLUSH_AFTER_MAX_REQS, TEST_STOP_DUE_TO_EMPTY_QUEUE, TEST_STOP_DUE_TO_MAX_REQ_NUM, TEST_STOP_DUE_TO_THRESHOLD, SEND_WRITE_PACKING_MAX_TESTCASE = TEST_STOP_DUE_TO_THRESHOLD, /* Start of err check test group */ ERR_CHECK_MIN_TESTCASE, TEST_RET_ABORT = ERR_CHECK_MIN_TESTCASE, TEST_RET_PARTIAL_FOLLOWED_BY_SUCCESS, TEST_RET_PARTIAL_FOLLOWED_BY_ABORT, TEST_RET_PARTIAL_MULTIPLE_UNTIL_SUCCESS, TEST_RET_PARTIAL_MAX_FAIL_IDX, TEST_RET_RETRY, TEST_RET_CMD_ERR, TEST_RET_DATA_ERR, ERR_CHECK_MAX_TESTCASE = TEST_RET_DATA_ERR, /* Start of send invalid test group */ INVALID_CMD_MIN_TESTCASE, TEST_HDR_INVALID_VERSION = INVALID_CMD_MIN_TESTCASE, TEST_HDR_WRONG_WRITE_CODE, TEST_HDR_INVALID_RW_CODE, TEST_HDR_DIFFERENT_ADDRESSES, TEST_HDR_REQ_NUM_SMALLER_THAN_ACTUAL, TEST_HDR_REQ_NUM_LARGER_THAN_ACTUAL, TEST_HDR_CMD23_PACKED_BIT_SET, TEST_CMD23_MAX_PACKED_WRITES, TEST_CMD23_ZERO_PACKED_WRITES, TEST_CMD23_PACKED_BIT_UNSET, TEST_CMD23_REL_WR_BIT_SET, TEST_CMD23_BITS_16TO29_SET, TEST_CMD23_HDR_BLK_NOT_IN_COUNT, INVALID_CMD_MAX_TESTCASE = TEST_CMD23_HDR_BLK_NOT_IN_COUNT, /* * Start of packing control test group. * in these next testcases the abbreviation FB = followed by */ PACKING_CONTROL_MIN_TESTCASE, TEST_PACKING_EXP_ONE_OVER_TRIGGER_FB_READ = PACKING_CONTROL_MIN_TESTCASE, TEST_PACKING_EXP_N_OVER_TRIGGER, TEST_PACKING_EXP_N_OVER_TRIGGER_FB_READ, TEST_PACKING_EXP_N_OVER_TRIGGER_FLUSH_N, TEST_PACKING_EXP_THRESHOLD_OVER_TRIGGER, TEST_PACKING_NOT_EXP_LESS_THAN_TRIGGER_REQUESTS, TEST_PACKING_NOT_EXP_TRIGGER_REQUESTS, TEST_PACKING_NOT_EXP_TRIGGER_READ_TRIGGER, TEST_PACKING_NOT_EXP_TRIGGER_FLUSH_TRIGGER, TEST_PACK_MIX_PACKED_NO_PACKED_PACKED, TEST_PACK_MIX_NO_PACKED_PACKED_NO_PACKED, PACKING_CONTROL_MAX_TESTCASE = TEST_PACK_MIX_NO_PACKED_PACKED_NO_PACKED, TEST_WRITE_DISCARD_SANITIZE_READ, /* Start of bkops test group */ BKOPS_MIN_TESTCASE, BKOPS_DELAYED_WORK_LEVEL_1 = BKOPS_MIN_TESTCASE, BKOPS_DELAYED_WORK_LEVEL_1_HPI, BKOPS_CANCEL_DELAYED_WORK, BKOPS_URGENT_LEVEL_2, BKOPS_URGENT_LEVEL_2_TWO_REQS, BKOPS_URGENT_LEVEL_3, BKOPS_MAX_TESTCASE = BKOPS_URGENT_LEVEL_3, TEST_LONG_SEQUENTIAL_READ, TEST_LONG_SEQUENTIAL_WRITE, TEST_NEW_REQ_NOTIFICATION, }; enum mmc_block_test_group { TEST_NO_GROUP, TEST_GENERAL_GROUP, TEST_SEND_WRITE_PACKING_GROUP, TEST_ERR_CHECK_GROUP, TEST_SEND_INVALID_GROUP, TEST_PACKING_CONTROL_GROUP, TEST_BKOPS_GROUP, TEST_NEW_NOTIFICATION_GROUP, }; enum bkops_test_stages { BKOPS_STAGE_1, BKOPS_STAGE_2, BKOPS_STAGE_3, BKOPS_STAGE_4, }; struct mmc_block_test_debug { struct dentry *send_write_packing_test; struct dentry *err_check_test; struct dentry *send_invalid_packed_test; struct dentry *random_test_seed; struct dentry *packing_control_test; struct dentry *discard_sanitize_test; struct dentry *bkops_test; struct dentry *long_sequential_read_test; struct dentry *long_sequential_write_test; struct dentry *new_req_notification_test; }; struct mmc_block_test_data { /* The number of write requests that the test will issue */ int num_requests; /* The expected write packing statistics for the current test */ struct mmc_wr_pack_stats exp_packed_stats; /* * A user-defined seed for random choices of number of bios written in * a request, and of number of requests issued in a test * This field is randomly updated after each use */ unsigned int random_test_seed; /* A retry counter used in err_check tests */ int err_check_counter; /* Can be one of the values of enum test_group */ enum mmc_block_test_group test_group; /* * Indicates if the current testcase is running with random values of * num_requests and num_bios (in each request) */ int is_random; /* Data structure for debugfs dentrys */ struct mmc_block_test_debug debug; /* * Data structure containing individual test information, including * self-defined specific data */ struct test_info test_info; /* mmc block device test */ struct blk_dev_test_type bdt; /* Current BKOPs test stage */ enum bkops_test_stages bkops_stage; /* A wait queue for BKOPs tests */ wait_queue_head_t bkops_wait_q; /* A counter for the number of test requests completed */ unsigned int completed_req_count; }; static struct mmc_block_test_data *mbtd; void print_mmc_packing_stats(struct mmc_card *card) { int i; int max_num_of_packed_reqs = 0; if ((!card) || (!card->wr_pack_stats.packing_events)) return; max_num_of_packed_reqs = card->ext_csd.max_packed_writes; spin_lock(&card->wr_pack_stats.lock); pr_info("%s: write packing statistics:\n", mmc_hostname(card->host)); for (i = 1 ; i <= max_num_of_packed_reqs ; ++i) { if (card->wr_pack_stats.packing_events[i] != 0) pr_info("%s: Packed %d reqs - %d times\n", mmc_hostname(card->host), i, card->wr_pack_stats.packing_events[i]); } pr_info("%s: stopped packing due to the following reasons:\n", mmc_hostname(card->host)); if (card->wr_pack_stats.pack_stop_reason[EXCEEDS_SEGMENTS]) pr_info("%s: %d times: exceedmax num of segments\n", mmc_hostname(card->host), card->wr_pack_stats.pack_stop_reason[EXCEEDS_SEGMENTS]); if (card->wr_pack_stats.pack_stop_reason[EXCEEDS_SECTORS]) pr_info("%s: %d times: exceeding the max num of sectors\n", mmc_hostname(card->host), card->wr_pack_stats.pack_stop_reason[EXCEEDS_SECTORS]); if (card->wr_pack_stats.pack_stop_reason[WRONG_DATA_DIR]) pr_info("%s: %d times: wrong data direction\n", mmc_hostname(card->host), card->wr_pack_stats.pack_stop_reason[WRONG_DATA_DIR]); if (card->wr_pack_stats.pack_stop_reason[FLUSH_OR_DISCARD]) pr_info("%s: %d times: flush or discard\n", mmc_hostname(card->host), card->wr_pack_stats.pack_stop_reason[FLUSH_OR_DISCARD]); if (card->wr_pack_stats.pack_stop_reason[EMPTY_QUEUE]) pr_info("%s: %d times: empty queue\n", mmc_hostname(card->host), card->wr_pack_stats.pack_stop_reason[EMPTY_QUEUE]); if (card->wr_pack_stats.pack_stop_reason[REL_WRITE]) pr_info("%s: %d times: rel write\n", mmc_hostname(card->host), card->wr_pack_stats.pack_stop_reason[REL_WRITE]); if (card->wr_pack_stats.pack_stop_reason[THRESHOLD]) pr_info("%s: %d times: Threshold\n", mmc_hostname(card->host), card->wr_pack_stats.pack_stop_reason[THRESHOLD]); spin_unlock(&card->wr_pack_stats.lock); } /* * A callback assigned to the packed_test_fn field. * Called from block layer in mmc_blk_packed_hdr_wrq_prep. * Here we alter the packed header or CMD23 in order to send an invalid * packed command to the card. */ static void test_invalid_packed_cmd(struct request_queue *q, struct mmc_queue_req *mqrq) { struct mmc_queue *mq = q->queuedata; u32 *packed_cmd_hdr = mqrq->packed_cmd_hdr; struct request *req = mqrq->req; struct request *second_rq; struct test_request *test_rq; struct mmc_blk_request *brq = &mqrq->brq; int num_requests; int max_packed_reqs; if (!mq) { test_pr_err("%s: NULL mq", __func__); return; } test_rq = (struct test_request *)req->elv.priv[0]; if (!test_rq) { test_pr_err("%s: NULL test_rq", __func__); return; } max_packed_reqs = mq->card->ext_csd.max_packed_writes; switch (mbtd->test_info.testcase) { case TEST_HDR_INVALID_VERSION: test_pr_info("%s: set invalid header version", __func__); /* Put 0 in header version field (1 byte, offset 0 in header) */ packed_cmd_hdr[0] = packed_cmd_hdr[0] & ~PACKED_HDR_VER_MASK; break; case TEST_HDR_WRONG_WRITE_CODE: test_pr_info("%s: wrong write code", __func__); /* Set R/W field with R value (1 byte, offset 1 in header) */ packed_cmd_hdr[0] = packed_cmd_hdr[0] & ~PACKED_HDR_RW_MASK; packed_cmd_hdr[0] = packed_cmd_hdr[0] | 0x00000100; break; case TEST_HDR_INVALID_RW_CODE: test_pr_info("%s: invalid r/w code", __func__); /* Set R/W field with invalid value */ packed_cmd_hdr[0] = packed_cmd_hdr[0] & ~PACKED_HDR_RW_MASK; packed_cmd_hdr[0] = packed_cmd_hdr[0] | 0x00000400; break; case TEST_HDR_DIFFERENT_ADDRESSES: test_pr_info("%s: different addresses", __func__); second_rq = list_entry(req->queuelist.next, struct request, queuelist); test_pr_info("%s: test_rq->sector=%ld, second_rq->sector=%ld", __func__, (long)req->__sector, (long)second_rq->__sector); /* * Put start sector of second write request in the first write * request's cmd25 argument in the packed header */ packed_cmd_hdr[3] = second_rq->__sector; break; case TEST_HDR_REQ_NUM_SMALLER_THAN_ACTUAL: test_pr_info("%s: request num smaller than actual" , __func__); num_requests = (packed_cmd_hdr[0] & PACKED_HDR_NUM_REQS_MASK) >> 16; /* num of entries is decremented by 1 */ num_requests = (num_requests - 1) << 16; /* * Set number of requests field in packed write header to be * smaller than the actual number (1 byte, offset 2 in header) */ packed_cmd_hdr[0] = (packed_cmd_hdr[0] & ~PACKED_HDR_NUM_REQS_MASK) + num_requests; break; case TEST_HDR_REQ_NUM_LARGER_THAN_ACTUAL: test_pr_info("%s: request num larger than actual" , __func__); num_requests = (packed_cmd_hdr[0] & PACKED_HDR_NUM_REQS_MASK) >> 16; /* num of entries is incremented by 1 */ num_requests = (num_requests + 1) << 16; /* * Set number of requests field in packed write header to be * larger than the actual number (1 byte, offset 2 in header). */ packed_cmd_hdr[0] = (packed_cmd_hdr[0] & ~PACKED_HDR_NUM_REQS_MASK) + num_requests; break; case TEST_HDR_CMD23_PACKED_BIT_SET: test_pr_info("%s: header CMD23 packed bit set" , __func__); /* * Set packed bit (bit 30) in cmd23 argument of first and second * write requests in packed write header. * These are located at bytes 2 and 4 in packed write header */ packed_cmd_hdr[2] = packed_cmd_hdr[2] | CMD23_PACKED_BIT; packed_cmd_hdr[4] = packed_cmd_hdr[4] | CMD23_PACKED_BIT; break; case TEST_CMD23_MAX_PACKED_WRITES: test_pr_info("%s: CMD23 request num > max_packed_reqs", __func__); /* * Set the individual packed cmd23 request num to * max_packed_reqs + 1 */ brq->sbc.arg = MMC_CMD23_ARG_PACKED | (max_packed_reqs + 1); break; case TEST_CMD23_ZERO_PACKED_WRITES: test_pr_info("%s: CMD23 request num = 0", __func__); /* Set the individual packed cmd23 request num to zero */ brq->sbc.arg = MMC_CMD23_ARG_PACKED; break; case TEST_CMD23_PACKED_BIT_UNSET: test_pr_info("%s: CMD23 packed bit unset", __func__); /* * Set the individual packed cmd23 packed bit to 0, * although there is a packed write request */ brq->sbc.arg &= ~CMD23_PACKED_BIT; break; case TEST_CMD23_REL_WR_BIT_SET: test_pr_info("%s: CMD23 REL WR bit set", __func__); /* Set the individual packed cmd23 reliable write bit */ brq->sbc.arg = MMC_CMD23_ARG_PACKED | MMC_CMD23_ARG_REL_WR; break; case TEST_CMD23_BITS_16TO29_SET: test_pr_info("%s: CMD23 bits [16-29] set", __func__); brq->sbc.arg = MMC_CMD23_ARG_PACKED | PACKED_HDR_BITS_16_TO_29_SET; break; case TEST_CMD23_HDR_BLK_NOT_IN_COUNT: test_pr_info("%s: CMD23 hdr not in block count", __func__); brq->sbc.arg = MMC_CMD23_ARG_PACKED | ((rq_data_dir(req) == READ) ? 0 : mqrq->packed_blocks); break; default: test_pr_err("%s: unexpected testcase %d", __func__, mbtd->test_info.testcase); break; } } /* * A callback assigned to the err_check_fn field of the mmc_request by the * MMC/card/block layer. * Called upon request completion by the MMC/core layer. * Here we emulate an error return value from the card. */ static int test_err_check(struct mmc_card *card, struct mmc_async_req *areq) { struct mmc_queue_req *mq_rq = container_of(areq, struct mmc_queue_req, mmc_active); struct request_queue *req_q = test_iosched_get_req_queue(); struct mmc_queue *mq; int max_packed_reqs; int ret = 0; struct mmc_blk_request *brq; if (req_q) mq = req_q->queuedata; else { test_pr_err("%s: NULL request_queue", __func__); return 0; } if (!mq) { test_pr_err("%s: %s: NULL mq", __func__, mmc_hostname(card->host)); return 0; } max_packed_reqs = mq->card->ext_csd.max_packed_writes; if (!mq_rq) { test_pr_err("%s: %s: NULL mq_rq", __func__, mmc_hostname(card->host)); return 0; } brq = &mq_rq->brq; switch (mbtd->test_info.testcase) { case TEST_RET_ABORT: test_pr_info("%s: return abort", __func__); ret = MMC_BLK_ABORT; break; case TEST_RET_PARTIAL_FOLLOWED_BY_SUCCESS: test_pr_info("%s: return partial followed by success", __func__); /* * Since in this testcase num_requests is always >= 2, * we can be sure that packed_fail_idx is always >= 1 */ mq_rq->packed_fail_idx = (mbtd->num_requests / 2); test_pr_info("%s: packed_fail_idx = %d" , __func__, mq_rq->packed_fail_idx); mq->err_check_fn = NULL; ret = MMC_BLK_PARTIAL; break; case TEST_RET_PARTIAL_FOLLOWED_BY_ABORT: if (!mbtd->err_check_counter) { test_pr_info("%s: return partial followed by abort", __func__); mbtd->err_check_counter++; /* * Since in this testcase num_requests is always >= 3, * we have that packed_fail_idx is always >= 1 */ mq_rq->packed_fail_idx = (mbtd->num_requests / 2); test_pr_info("%s: packed_fail_idx = %d" , __func__, mq_rq->packed_fail_idx); ret = MMC_BLK_PARTIAL; break; } mbtd->err_check_counter = 0; mq->err_check_fn = NULL; ret = MMC_BLK_ABORT; break; case TEST_RET_PARTIAL_MULTIPLE_UNTIL_SUCCESS: test_pr_info("%s: return partial multiple until success", __func__); if (++mbtd->err_check_counter >= (mbtd->num_requests)) { mq->err_check_fn = NULL; mbtd->err_check_counter = 0; ret = MMC_BLK_PARTIAL; break; } mq_rq->packed_fail_idx = 1; ret = MMC_BLK_PARTIAL; break; case TEST_RET_PARTIAL_MAX_FAIL_IDX: test_pr_info("%s: return partial max fail_idx", __func__); mq_rq->packed_fail_idx = max_packed_reqs - 1; mq->err_check_fn = NULL; ret = MMC_BLK_PARTIAL; break; case TEST_RET_RETRY: test_pr_info("%s: return retry", __func__); ret = MMC_BLK_RETRY; break; case TEST_RET_CMD_ERR: test_pr_info("%s: return cmd err", __func__); ret = MMC_BLK_CMD_ERR; break; case TEST_RET_DATA_ERR: test_pr_info("%s: return data err", __func__); ret = MMC_BLK_DATA_ERR; break; case BKOPS_URGENT_LEVEL_2: case BKOPS_URGENT_LEVEL_3: case BKOPS_URGENT_LEVEL_2_TWO_REQS: if (mbtd->err_check_counter++ == 0) { test_pr_info("%s: simulate an exception from the card", __func__); brq->cmd.resp[0] |= R1_EXCEPTION_EVENT; } mq->err_check_fn = NULL; break; default: test_pr_err("%s: unexpected testcase %d", __func__, mbtd->test_info.testcase); } return ret; } /* * This is a specific implementation for the get_test_case_str_fn function * pointer in the test_info data structure. Given a valid test_data instance, * the function returns a string resembling the test name, based on the testcase */ static char *get_test_case_str(struct test_data *td) { if (!td) { test_pr_err("%s: NULL td", __func__); return NULL; } switch (td->test_info.testcase) { case TEST_STOP_DUE_TO_FLUSH: return "\"stop due to flush\""; case TEST_STOP_DUE_TO_FLUSH_AFTER_MAX_REQS: return "\"stop due to flush after max-1 reqs\""; case TEST_STOP_DUE_TO_READ: return "\"stop due to read\""; case TEST_STOP_DUE_TO_READ_AFTER_MAX_REQS: return "\"stop due to read after max-1 reqs\""; case TEST_STOP_DUE_TO_EMPTY_QUEUE: return "\"stop due to empty queue\""; case TEST_STOP_DUE_TO_MAX_REQ_NUM: return "\"stop due to max req num\""; case TEST_STOP_DUE_TO_THRESHOLD: return "\"stop due to exceeding threshold\""; case TEST_RET_ABORT: return "\"err_check return abort\""; case TEST_RET_PARTIAL_FOLLOWED_BY_SUCCESS: return "\"err_check return partial followed by success\""; case TEST_RET_PARTIAL_FOLLOWED_BY_ABORT: return "\"err_check return partial followed by abort\""; case TEST_RET_PARTIAL_MULTIPLE_UNTIL_SUCCESS: return "\"err_check return partial multiple until success\""; case TEST_RET_PARTIAL_MAX_FAIL_IDX: return "\"err_check return partial max fail index\""; case TEST_RET_RETRY: return "\"err_check return retry\""; case TEST_RET_CMD_ERR: return "\"err_check return cmd error\""; case TEST_RET_DATA_ERR: return "\"err_check return data error\""; case TEST_HDR_INVALID_VERSION: return "\"invalid - wrong header version\""; case TEST_HDR_WRONG_WRITE_CODE: return "\"invalid - wrong write code\""; case TEST_HDR_INVALID_RW_CODE: return "\"invalid - wrong R/W code\""; case TEST_HDR_DIFFERENT_ADDRESSES: return "\"invalid - header different addresses\""; case TEST_HDR_REQ_NUM_SMALLER_THAN_ACTUAL: return "\"invalid - header req num smaller than actual\""; case TEST_HDR_REQ_NUM_LARGER_THAN_ACTUAL: return "\"invalid - header req num larger than actual\""; case TEST_HDR_CMD23_PACKED_BIT_SET: return "\"invalid - header cmd23 packed bit set\""; case TEST_CMD23_MAX_PACKED_WRITES: return "\"invalid - cmd23 max packed writes\""; case TEST_CMD23_ZERO_PACKED_WRITES: return "\"invalid - cmd23 zero packed writes\""; case TEST_CMD23_PACKED_BIT_UNSET: return "\"invalid - cmd23 packed bit unset\""; case TEST_CMD23_REL_WR_BIT_SET: return "\"invalid - cmd23 rel wr bit set\""; case TEST_CMD23_BITS_16TO29_SET: return "\"invalid - cmd23 bits [16-29] set\""; case TEST_CMD23_HDR_BLK_NOT_IN_COUNT: return "\"invalid - cmd23 header block not in count\""; case TEST_PACKING_EXP_N_OVER_TRIGGER: return "\"packing control - pack n\""; case TEST_PACKING_EXP_N_OVER_TRIGGER_FB_READ: return "\"packing control - pack n followed by read\""; case TEST_PACKING_EXP_N_OVER_TRIGGER_FLUSH_N: return "\"packing control - pack n followed by flush\""; case TEST_PACKING_EXP_ONE_OVER_TRIGGER_FB_READ: return "\"packing control - pack one followed by read\""; case TEST_PACKING_EXP_THRESHOLD_OVER_TRIGGER: return "\"packing control - pack threshold\""; case TEST_PACKING_NOT_EXP_LESS_THAN_TRIGGER_REQUESTS: return "\"packing control - no packing\""; case TEST_PACKING_NOT_EXP_TRIGGER_REQUESTS: return "\"packing control - no packing, trigger requests\""; case TEST_PACKING_NOT_EXP_TRIGGER_READ_TRIGGER: return "\"packing control - no pack, trigger-read-trigger\""; case TEST_PACKING_NOT_EXP_TRIGGER_FLUSH_TRIGGER: return "\"packing control- no pack, trigger-flush-trigger\""; case TEST_PACK_MIX_PACKED_NO_PACKED_PACKED: return "\"packing control - mix: pack -> no pack -> pack\""; case TEST_PACK_MIX_NO_PACKED_PACKED_NO_PACKED: return "\"packing control - mix: no pack->pack->no pack\""; case TEST_WRITE_DISCARD_SANITIZE_READ: return "\"write, discard, sanitize\""; case BKOPS_DELAYED_WORK_LEVEL_1: return "\"delayed work BKOPS level 1\""; case BKOPS_DELAYED_WORK_LEVEL_1_HPI: return "\"delayed work BKOPS level 1 with HPI\""; case BKOPS_CANCEL_DELAYED_WORK: return "\"cancel delayed BKOPS work\""; case BKOPS_URGENT_LEVEL_2: return "\"urgent BKOPS level 2\""; case BKOPS_URGENT_LEVEL_2_TWO_REQS: return "\"urgent BKOPS level 2, followed by a request\""; case BKOPS_URGENT_LEVEL_3: return "\"urgent BKOPS level 3\""; case TEST_LONG_SEQUENTIAL_READ: return "\"long sequential read\""; case TEST_LONG_SEQUENTIAL_WRITE: return "\"long sequential write\""; case TEST_NEW_REQ_NOTIFICATION: return "\"new request notification test\""; default: return " Unknown testcase"; } return NULL; } /* * Compare individual testcase's statistics to the expected statistics: * Compare stop reason and number of packing events */ static int check_wr_packing_statistics(struct test_data *td) { struct mmc_wr_pack_stats *mmc_packed_stats; struct mmc_queue *mq = td->req_q->queuedata; int max_packed_reqs = mq->card->ext_csd.max_packed_writes; int i; struct mmc_card *card = mq->card; struct mmc_wr_pack_stats expected_stats; int *stop_reason; int ret = 0; if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } expected_stats = mbtd->exp_packed_stats; mmc_packed_stats = mmc_blk_get_packed_statistics(card); if (!mmc_packed_stats) { test_pr_err("%s: NULL mmc_packed_stats", __func__); return -EINVAL; } if (!mmc_packed_stats->packing_events) { test_pr_err("%s: NULL packing_events", __func__); return -EINVAL; } spin_lock(&mmc_packed_stats->lock); if (!mmc_packed_stats->enabled) { test_pr_err("%s write packing statistics are not enabled", __func__); ret = -EINVAL; goto exit_err; } stop_reason = mmc_packed_stats->pack_stop_reason; for (i = 1; i <= max_packed_reqs; ++i) { if (mmc_packed_stats->packing_events[i] != expected_stats.packing_events[i]) { test_pr_err( "%s: Wrong pack stats in index %d, got %d, expected %d", __func__, i, mmc_packed_stats->packing_events[i], expected_stats.packing_events[i]); if (td->fs_wr_reqs_during_test) goto cancel_round; ret = -EINVAL; goto exit_err; } } if (mmc_packed_stats->pack_stop_reason[EXCEEDS_SEGMENTS] != expected_stats.pack_stop_reason[EXCEEDS_SEGMENTS]) { test_pr_err( "%s: Wrong pack stop reason EXCEEDS_SEGMENTS %d, expected %d", __func__, stop_reason[EXCEEDS_SEGMENTS], expected_stats.pack_stop_reason[EXCEEDS_SEGMENTS]); if (td->fs_wr_reqs_during_test) goto cancel_round; ret = -EINVAL; goto exit_err; } if (mmc_packed_stats->pack_stop_reason[EXCEEDS_SECTORS] != expected_stats.pack_stop_reason[EXCEEDS_SECTORS]) { test_pr_err( "%s: Wrong pack stop reason EXCEEDS_SECTORS %d, expected %d", __func__, stop_reason[EXCEEDS_SECTORS], expected_stats.pack_stop_reason[EXCEEDS_SECTORS]); if (td->fs_wr_reqs_during_test) goto cancel_round; ret = -EINVAL; goto exit_err; } if (mmc_packed_stats->pack_stop_reason[WRONG_DATA_DIR] != expected_stats.pack_stop_reason[WRONG_DATA_DIR]) { test_pr_err( "%s: Wrong pack stop reason WRONG_DATA_DIR %d, expected %d", __func__, stop_reason[WRONG_DATA_DIR], expected_stats.pack_stop_reason[WRONG_DATA_DIR]); if (td->fs_wr_reqs_during_test) goto cancel_round; ret = -EINVAL; goto exit_err; } if (mmc_packed_stats->pack_stop_reason[FLUSH_OR_DISCARD] != expected_stats.pack_stop_reason[FLUSH_OR_DISCARD]) { test_pr_err( "%s: Wrong pack stop reason FLUSH_OR_DISCARD %d, expected %d", __func__, stop_reason[FLUSH_OR_DISCARD], expected_stats.pack_stop_reason[FLUSH_OR_DISCARD]); if (td->fs_wr_reqs_during_test) goto cancel_round; ret = -EINVAL; goto exit_err; } if (mmc_packed_stats->pack_stop_reason[EMPTY_QUEUE] != expected_stats.pack_stop_reason[EMPTY_QUEUE]) { test_pr_err( "%s: Wrong pack stop reason EMPTY_QUEUE %d, expected %d", __func__, stop_reason[EMPTY_QUEUE], expected_stats.pack_stop_reason[EMPTY_QUEUE]); if (td->fs_wr_reqs_during_test) goto cancel_round; ret = -EINVAL; goto exit_err; } if (mmc_packed_stats->pack_stop_reason[REL_WRITE] != expected_stats.pack_stop_reason[REL_WRITE]) { test_pr_err( "%s: Wrong pack stop reason REL_WRITE %d, expected %d", __func__, stop_reason[REL_WRITE], expected_stats.pack_stop_reason[REL_WRITE]); if (td->fs_wr_reqs_during_test) goto cancel_round; ret = -EINVAL; goto exit_err; } exit_err: spin_unlock(&mmc_packed_stats->lock); if (ret && mmc_packed_stats->enabled) print_mmc_packing_stats(card); return ret; cancel_round: spin_unlock(&mmc_packed_stats->lock); test_iosched_set_ignore_round(true); return 0; } /* * Pseudo-randomly choose a seed based on the last seed, and update it in * seed_number. then return seed_number (mod max_val), or min_val. */ static unsigned int pseudo_random_seed(unsigned int *seed_number, unsigned int min_val, unsigned int max_val) { int ret = 0; if (!seed_number) return 0; *seed_number = ((unsigned int)(((unsigned long)*seed_number * (unsigned long)LARGE_PRIME_1) + LARGE_PRIME_2)); ret = (unsigned int)((*seed_number) % max_val); return (ret > min_val ? ret : min_val); } /* * Given a pseudo-random seed, find a pseudo-random num_of_bios. * Make sure that num_of_bios is not larger than TEST_MAX_SECTOR_RANGE */ static void pseudo_rnd_num_of_bios(unsigned int *num_bios_seed, unsigned int *num_of_bios) { do { *num_of_bios = pseudo_random_seed(num_bios_seed, 1, TEST_MAX_BIOS_PER_REQ); if (!(*num_of_bios)) *num_of_bios = 1; } while ((*num_of_bios) * BIO_U32_SIZE * 4 > TEST_MAX_SECTOR_RANGE); } /* Add a single read request to the given td's request queue */ static int prepare_request_add_read(struct test_data *td) { int ret; int start_sec; if (td) start_sec = td->start_sector; else { test_pr_err("%s: NULL td", __func__); return 0; } test_pr_info("%s: Adding a read request, first req_id=%d", __func__, td->wr_rd_next_req_id); ret = test_iosched_add_wr_rd_test_req(0, READ, start_sec, 2, TEST_PATTERN_5A, NULL); if (ret) { test_pr_err("%s: failed to add a read request", __func__); return ret; } return 0; } /* Add a single flush request to the given td's request queue */ static int prepare_request_add_flush(struct test_data *td) { int ret; if (!td) { test_pr_err("%s: NULL td", __func__); return 0; } test_pr_info("%s: Adding a flush request, first req_id=%d", __func__, td->unique_next_req_id); ret = test_iosched_add_unique_test_req(0, REQ_UNIQUE_FLUSH, 0, 0, NULL); if (ret) { test_pr_err("%s: failed to add a flush request", __func__); return ret; } return ret; } /* * Add num_requets amount of write requests to the given td's request queue. * If random test mode is chosen we pseudo-randomly choose the number of bios * for each write request, otherwise add between 1 to 5 bio per request. */ static int prepare_request_add_write_reqs(struct test_data *td, int num_requests, int is_err_expected, int is_random) { int i; unsigned int start_sec; int num_bios; int ret = 0; unsigned int *bio_seed = &mbtd->random_test_seed; if (td) start_sec = td->start_sector; else { test_pr_err("%s: NULL td", __func__); return ret; } test_pr_info("%s: Adding %d write requests, first req_id=%d", __func__, num_requests, td->wr_rd_next_req_id); for (i = 1 ; i <= num_requests ; i++) { start_sec = td->start_sector + sizeof(int) * BIO_U32_SIZE * td->num_of_write_bios; if (is_random) pseudo_rnd_num_of_bios(bio_seed, &num_bios); else /* * For the non-random case, give num_bios a value * between 1 and 5, to keep a small number of BIOs */ num_bios = (i%5)+1; ret = test_iosched_add_wr_rd_test_req(is_err_expected, WRITE, start_sec, num_bios, TEST_PATTERN_5A, NULL); if (ret) { test_pr_err("%s: failed to add a write request", __func__); return ret; } } return 0; } /* * Prepare the write, read and flush requests for a generic packed commands * testcase */ static int prepare_packed_requests(struct test_data *td, int is_err_expected, int num_requests, int is_random) { int ret = 0; struct mmc_queue *mq; int max_packed_reqs; struct request_queue *req_q; if (!td) { pr_err("%s: NULL td", __func__); return -EINVAL; } req_q = td->req_q; if (!req_q) { pr_err("%s: NULL request queue", __func__); return -EINVAL; } mq = req_q->queuedata; if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } max_packed_reqs = mq->card->ext_csd.max_packed_writes; if (mbtd->random_test_seed <= 0) { mbtd->random_test_seed = (unsigned int)(get_jiffies_64() & 0xFFFF); test_pr_info("%s: got seed from jiffies %d", __func__, mbtd->random_test_seed); } ret = prepare_request_add_write_reqs(td, num_requests, is_err_expected, is_random); if (ret) return ret; /* Avoid memory corruption in upcoming stats set */ if (td->test_info.testcase == TEST_STOP_DUE_TO_THRESHOLD) num_requests--; memset((void *)mbtd->exp_packed_stats.pack_stop_reason, 0, sizeof(mbtd->exp_packed_stats.pack_stop_reason)); memset(mbtd->exp_packed_stats.packing_events, 0, (max_packed_reqs + 1) * sizeof(u32)); if (num_requests <= max_packed_reqs) mbtd->exp_packed_stats.packing_events[num_requests] = 1; switch (td->test_info.testcase) { case TEST_STOP_DUE_TO_FLUSH: case TEST_STOP_DUE_TO_FLUSH_AFTER_MAX_REQS: ret = prepare_request_add_flush(td); if (ret) return ret; mbtd->exp_packed_stats.pack_stop_reason[FLUSH_OR_DISCARD] = 1; break; case TEST_STOP_DUE_TO_READ: case TEST_STOP_DUE_TO_READ_AFTER_MAX_REQS: ret = prepare_request_add_read(td); if (ret) return ret; mbtd->exp_packed_stats.pack_stop_reason[WRONG_DATA_DIR] = 1; break; case TEST_STOP_DUE_TO_THRESHOLD: mbtd->exp_packed_stats.packing_events[num_requests] = 1; mbtd->exp_packed_stats.packing_events[1] = 1; mbtd->exp_packed_stats.pack_stop_reason[THRESHOLD] = 1; mbtd->exp_packed_stats.pack_stop_reason[EMPTY_QUEUE] = 1; break; case TEST_STOP_DUE_TO_MAX_REQ_NUM: case TEST_RET_PARTIAL_MAX_FAIL_IDX: mbtd->exp_packed_stats.pack_stop_reason[THRESHOLD] = 1; break; default: mbtd->exp_packed_stats.pack_stop_reason[EMPTY_QUEUE] = 1; } mbtd->num_requests = num_requests; return 0; } /* * Prepare the write, read and flush requests for the packing control * testcases */ static int prepare_packed_control_tests_requests(struct test_data *td, int is_err_expected, int num_requests, int is_random) { int ret = 0; struct mmc_queue *mq; int max_packed_reqs; int temp_num_req = num_requests; struct request_queue *req_q; int test_packed_trigger; int num_packed_reqs; if (!td) { test_pr_err("%s: NULL td\n", __func__); return -EINVAL; } req_q = td->req_q; if (!req_q) { test_pr_err("%s: NULL request queue\n", __func__); return -EINVAL; } mq = req_q->queuedata; if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } max_packed_reqs = mq->card->ext_csd.max_packed_writes; test_packed_trigger = mq->num_wr_reqs_to_start_packing; num_packed_reqs = num_requests - test_packed_trigger; if (mbtd->random_test_seed == 0) { mbtd->random_test_seed = (unsigned int)(get_jiffies_64() & 0xFFFF); test_pr_info("%s: got seed from jiffies %d", __func__, mbtd->random_test_seed); } if (td->test_info.testcase == TEST_PACK_MIX_NO_PACKED_PACKED_NO_PACKED) { temp_num_req = num_requests; num_requests = test_packed_trigger - 1; } /* Verify that the packing is disabled before starting the test */ mq->wr_packing_enabled = false; mq->num_of_potential_packed_wr_reqs = 0; if (td->test_info.testcase == TEST_PACK_MIX_PACKED_NO_PACKED_PACKED) { mq->num_of_potential_packed_wr_reqs = test_packed_trigger + 1; mq->wr_packing_enabled = true; num_requests = test_packed_trigger + 2; } ret = prepare_request_add_write_reqs(td, num_requests, is_err_expected, is_random); if (ret) goto exit; if (td->test_info.testcase == TEST_PACK_MIX_NO_PACKED_PACKED_NO_PACKED) num_requests = temp_num_req; memset((void *)mbtd->exp_packed_stats.pack_stop_reason, 0, sizeof(mbtd->exp_packed_stats.pack_stop_reason)); memset(mbtd->exp_packed_stats.packing_events, 0, (max_packed_reqs + 1) * sizeof(u32)); switch (td->test_info.testcase) { case TEST_PACKING_EXP_N_OVER_TRIGGER_FB_READ: case TEST_PACKING_EXP_ONE_OVER_TRIGGER_FB_READ: ret = prepare_request_add_read(td); if (ret) goto exit; mbtd->exp_packed_stats.pack_stop_reason[WRONG_DATA_DIR] = 1; mbtd->exp_packed_stats.packing_events[num_packed_reqs] = 1; break; case TEST_PACKING_EXP_N_OVER_TRIGGER_FLUSH_N: ret = prepare_request_add_flush(td); if (ret) goto exit; ret = prepare_request_add_write_reqs(td, num_packed_reqs, is_err_expected, is_random); if (ret) goto exit; mbtd->exp_packed_stats.pack_stop_reason[EMPTY_QUEUE] = 1; mbtd->exp_packed_stats.pack_stop_reason[FLUSH_OR_DISCARD] = 1; mbtd->exp_packed_stats.packing_events[num_packed_reqs] = 2; break; case TEST_PACKING_NOT_EXP_TRIGGER_READ_TRIGGER: ret = prepare_request_add_read(td); if (ret) goto exit; ret = prepare_request_add_write_reqs(td, test_packed_trigger, is_err_expected, is_random); if (ret) goto exit; mbtd->exp_packed_stats.packing_events[num_packed_reqs] = 1; break; case TEST_PACKING_NOT_EXP_TRIGGER_FLUSH_TRIGGER: ret = prepare_request_add_flush(td); if (ret) goto exit; ret = prepare_request_add_write_reqs(td, test_packed_trigger, is_err_expected, is_random); if (ret) goto exit; mbtd->exp_packed_stats.packing_events[num_packed_reqs] = 1; break; case TEST_PACK_MIX_PACKED_NO_PACKED_PACKED: ret = prepare_request_add_read(td); if (ret) goto exit; ret = prepare_request_add_write_reqs(td, test_packed_trigger-1, is_err_expected, is_random); if (ret) goto exit; ret = prepare_request_add_write_reqs(td, num_requests, is_err_expected, is_random); if (ret) goto exit; mbtd->exp_packed_stats.packing_events[num_requests] = 1; mbtd->exp_packed_stats.packing_events[num_requests-1] = 1; mbtd->exp_packed_stats.pack_stop_reason[WRONG_DATA_DIR] = 1; mbtd->exp_packed_stats.pack_stop_reason[EMPTY_QUEUE] = 1; break; case TEST_PACK_MIX_NO_PACKED_PACKED_NO_PACKED: ret = prepare_request_add_read(td); if (ret) goto exit; ret = prepare_request_add_write_reqs(td, num_requests, is_err_expected, is_random); if (ret) goto exit; ret = prepare_request_add_read(td); if (ret) goto exit; ret = prepare_request_add_write_reqs(td, test_packed_trigger-1, is_err_expected, is_random); if (ret) goto exit; mbtd->exp_packed_stats.pack_stop_reason[WRONG_DATA_DIR] = 1; mbtd->exp_packed_stats.packing_events[num_packed_reqs] = 1; break; case TEST_PACKING_NOT_EXP_LESS_THAN_TRIGGER_REQUESTS: case TEST_PACKING_NOT_EXP_TRIGGER_REQUESTS: break; default: BUG_ON(num_packed_reqs < 0); mbtd->exp_packed_stats.pack_stop_reason[EMPTY_QUEUE] = 1; mbtd->exp_packed_stats.packing_events[num_packed_reqs] = 1; } mbtd->num_requests = num_requests; exit: return ret; } /* * Prepare requests for the TEST_RET_PARTIAL_FOLLOWED_BY_ABORT testcase. * In this testcase we have mixed error expectations from different * write requests, hence the special prepare function. */ static int prepare_partial_followed_by_abort(struct test_data *td, int num_requests) { int i, start_address; int is_err_expected = 0; int ret = 0; struct mmc_queue *mq = test_iosched_get_req_queue()->queuedata; int max_packed_reqs; if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } max_packed_reqs = mq->card->ext_csd.max_packed_writes; for (i = 1; i <= num_requests; i++) { if (i > (num_requests / 2)) is_err_expected = 1; start_address = td->start_sector + sizeof(int) * BIO_U32_SIZE * td->num_of_write_bios; ret = test_iosched_add_wr_rd_test_req(is_err_expected, WRITE, start_address, (i % 5) + 1, TEST_PATTERN_5A, NULL); if (ret) { test_pr_err("%s: failed to add a write request", __func__); return ret; } } memset((void *)&mbtd->exp_packed_stats.pack_stop_reason, 0, sizeof(mbtd->exp_packed_stats.pack_stop_reason)); memset(mbtd->exp_packed_stats.packing_events, 0, (max_packed_reqs + 1) * sizeof(u32)); mbtd->exp_packed_stats.packing_events[num_requests] = 1; mbtd->exp_packed_stats.pack_stop_reason[EMPTY_QUEUE] = 1; mbtd->num_requests = num_requests; return ret; } /* * Get number of write requests for current testcase. If random test mode was * chosen, pseudo-randomly choose the number of requests, otherwise set to * two less than the packing threshold. */ static int get_num_requests(struct test_data *td) { int *seed = &mbtd->random_test_seed; struct request_queue *req_q; struct mmc_queue *mq; int max_num_requests; int num_requests; int min_num_requests = 2; int is_random = mbtd->is_random; int max_for_double; int test_packed_trigger; req_q = test_iosched_get_req_queue(); if (req_q) mq = req_q->queuedata; else { test_pr_err("%s: NULL request queue", __func__); return 0; } if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } max_num_requests = mq->card->ext_csd.max_packed_writes; num_requests = max_num_requests - 2; test_packed_trigger = mq->num_wr_reqs_to_start_packing; /* * Here max_for_double is intended for packed control testcases * in which we issue many write requests. It's purpose is to prevent * exceeding max number of req_queue requests. */ max_for_double = max_num_requests - 10; if (td->test_info.testcase == TEST_PACKING_NOT_EXP_LESS_THAN_TRIGGER_REQUESTS) /* Don't expect packing, so issue up to trigger-1 reqs */ num_requests = test_packed_trigger - 1; if (is_random) { if (td->test_info.testcase == TEST_RET_PARTIAL_FOLLOWED_BY_ABORT) /* * Here we don't want num_requests to be less than 1 * as a consequence of division by 2. */ min_num_requests = 3; if (td->test_info.testcase == TEST_PACKING_NOT_EXP_LESS_THAN_TRIGGER_REQUESTS) /* Don't expect packing, so issue up to trigger reqs */ max_num_requests = test_packed_trigger; num_requests = pseudo_random_seed(seed, min_num_requests, max_num_requests - 1); } if (td->test_info.testcase == TEST_PACKING_NOT_EXP_LESS_THAN_TRIGGER_REQUESTS) num_requests -= test_packed_trigger; if (td->test_info.testcase == TEST_PACKING_EXP_N_OVER_TRIGGER_FLUSH_N) num_requests = num_requests > max_for_double ? max_for_double : num_requests; if (mbtd->test_group == TEST_PACKING_CONTROL_GROUP) num_requests += test_packed_trigger; if (td->test_info.testcase == TEST_PACKING_NOT_EXP_TRIGGER_REQUESTS) num_requests = test_packed_trigger; return num_requests; } static int prepare_long_read_test_requests(struct test_data *td) { int ret; int start_sec; int j; if (td) start_sec = td->start_sector; else { test_pr_err("%s: NULL td\n", __func__); return -EINVAL; } test_pr_info("%s: Adding %d read requests, first req_id=%d", __func__, LONG_READ_TEST_ACTUAL_NUM_REQS, td->wr_rd_next_req_id); for (j = 0; j < LONG_READ_TEST_ACTUAL_NUM_REQS; j++) { ret = test_iosched_add_wr_rd_test_req(0, READ, start_sec, TEST_MAX_BIOS_PER_REQ, TEST_NO_PATTERN, NULL); if (ret) { test_pr_err("%s: failed to add a read request, err = %d" , __func__, ret); return ret; } start_sec += (TEST_MAX_BIOS_PER_REQ * sizeof(int) * BIO_U32_SIZE); } return 0; } /* * An implementation for the prepare_test_fn pointer in the test_info * data structure. According to the testcase we add the right number of requests * and decide if an error is expected or not. */ static int prepare_test(struct test_data *td) { struct mmc_queue *mq = test_iosched_get_req_queue()->queuedata; int max_num_requests; int num_requests = 0; int ret = 0; int is_random = mbtd->is_random; int test_packed_trigger = mq->num_wr_reqs_to_start_packing; if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } max_num_requests = mq->card->ext_csd.max_packed_writes; if (is_random && mbtd->random_test_seed == 0) { mbtd->random_test_seed = (unsigned int)(get_jiffies_64() & 0xFFFF); test_pr_info("%s: got seed from jiffies %d", __func__, mbtd->random_test_seed); } num_requests = get_num_requests(td); if (mbtd->test_group == TEST_SEND_INVALID_GROUP) mq->packed_test_fn = test_invalid_packed_cmd; if (mbtd->test_group == TEST_ERR_CHECK_GROUP) mq->err_check_fn = test_err_check; switch (td->test_info.testcase) { case TEST_STOP_DUE_TO_FLUSH: case TEST_STOP_DUE_TO_READ: case TEST_RET_PARTIAL_FOLLOWED_BY_SUCCESS: case TEST_RET_PARTIAL_MULTIPLE_UNTIL_SUCCESS: case TEST_STOP_DUE_TO_EMPTY_QUEUE: case TEST_CMD23_PACKED_BIT_UNSET: ret = prepare_packed_requests(td, 0, num_requests, is_random); break; case TEST_STOP_DUE_TO_FLUSH_AFTER_MAX_REQS: case TEST_STOP_DUE_TO_READ_AFTER_MAX_REQS: ret = prepare_packed_requests(td, 0, max_num_requests - 1, is_random); break; case TEST_RET_PARTIAL_FOLLOWED_BY_ABORT: ret = prepare_partial_followed_by_abort(td, num_requests); break; case TEST_STOP_DUE_TO_MAX_REQ_NUM: case TEST_RET_PARTIAL_MAX_FAIL_IDX: ret = prepare_packed_requests(td, 0, max_num_requests, is_random); break; case TEST_STOP_DUE_TO_THRESHOLD: ret = prepare_packed_requests(td, 0, max_num_requests + 1, is_random); break; case TEST_RET_ABORT: case TEST_RET_RETRY: case TEST_RET_CMD_ERR: case TEST_RET_DATA_ERR: case TEST_HDR_INVALID_VERSION: case TEST_HDR_WRONG_WRITE_CODE: case TEST_HDR_INVALID_RW_CODE: case TEST_HDR_DIFFERENT_ADDRESSES: case TEST_HDR_REQ_NUM_SMALLER_THAN_ACTUAL: case TEST_HDR_REQ_NUM_LARGER_THAN_ACTUAL: case TEST_CMD23_MAX_PACKED_WRITES: case TEST_CMD23_ZERO_PACKED_WRITES: case TEST_CMD23_REL_WR_BIT_SET: case TEST_CMD23_BITS_16TO29_SET: case TEST_CMD23_HDR_BLK_NOT_IN_COUNT: case TEST_HDR_CMD23_PACKED_BIT_SET: ret = prepare_packed_requests(td, 1, num_requests, is_random); break; case TEST_PACKING_EXP_N_OVER_TRIGGER: case TEST_PACKING_EXP_N_OVER_TRIGGER_FB_READ: case TEST_PACKING_NOT_EXP_TRIGGER_REQUESTS: case TEST_PACKING_NOT_EXP_LESS_THAN_TRIGGER_REQUESTS: case TEST_PACK_MIX_PACKED_NO_PACKED_PACKED: case TEST_PACK_MIX_NO_PACKED_PACKED_NO_PACKED: ret = prepare_packed_control_tests_requests(td, 0, num_requests, is_random); break; case TEST_PACKING_EXP_THRESHOLD_OVER_TRIGGER: ret = prepare_packed_control_tests_requests(td, 0, max_num_requests, is_random); break; case TEST_PACKING_EXP_ONE_OVER_TRIGGER_FB_READ: ret = prepare_packed_control_tests_requests(td, 0, test_packed_trigger + 1, is_random); break; case TEST_PACKING_EXP_N_OVER_TRIGGER_FLUSH_N: ret = prepare_packed_control_tests_requests(td, 0, num_requests, is_random); break; case TEST_PACKING_NOT_EXP_TRIGGER_READ_TRIGGER: case TEST_PACKING_NOT_EXP_TRIGGER_FLUSH_TRIGGER: ret = prepare_packed_control_tests_requests(td, 0, test_packed_trigger, is_random); break; case TEST_LONG_SEQUENTIAL_WRITE: case TEST_LONG_SEQUENTIAL_READ: ret = prepare_long_read_test_requests(td); break; default: test_pr_info("%s: Invalid test case...", __func__); ret = -EINVAL; } return ret; } static int run_packed_test(struct test_data *td) { struct mmc_queue *mq; struct request_queue *req_q; if (!td) { pr_err("%s: NULL td", __func__); return -EINVAL; } req_q = td->req_q; if (!req_q) { pr_err("%s: NULL request queue", __func__); return -EINVAL; } mq = req_q->queuedata; if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } mmc_blk_init_packed_statistics(mq->card); if (td->test_info.testcase != TEST_PACK_MIX_PACKED_NO_PACKED_PACKED) { /* * Verify that the packing is disabled before starting the * test */ mq->wr_packing_enabled = false; mq->num_of_potential_packed_wr_reqs = 0; } __blk_run_queue(td->req_q); return 0; } /* * An implementation for the post_test_fn in the test_info data structure. * In our case we just reset the function pointers in the mmc_queue in order for * the FS to be able to dispatch it's requests correctly after the test is * finished. */ static int post_test(struct test_data *td) { struct mmc_queue *mq; if (!td) return -EINVAL; mq = td->req_q->queuedata; if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } mq->packed_test_fn = NULL; mq->err_check_fn = NULL; return 0; } /* * This function checks, based on the current test's test_group, that the * packed commands capability and control are set right. In addition, we check * if the card supports the packed command feature. */ static int validate_packed_commands_settings(void) { struct request_queue *req_q; struct mmc_queue *mq; int max_num_requests; struct mmc_host *host; req_q = test_iosched_get_req_queue(); if (!req_q) { test_pr_err("%s: test_iosched_get_req_queue failed", __func__); test_iosched_set_test_result(TEST_FAILED); return -EINVAL; } mq = req_q->queuedata; if (!mq) { test_pr_err("%s: NULL mq", __func__); return -EINVAL; } max_num_requests = mq->card->ext_csd.max_packed_writes; host = mq->card->host; if (!(host->caps2 && MMC_CAP2_PACKED_WR)) { test_pr_err("%s: Packed Write capability disabled, exit test", __func__); test_iosched_set_test_result(TEST_NOT_SUPPORTED); return -EINVAL; } if (max_num_requests == 0) { test_pr_err( "%s: no write packing support, ext_csd.max_packed_writes=%d", __func__, mq->card->ext_csd.max_packed_writes); test_iosched_set_test_result(TEST_NOT_SUPPORTED); return -EINVAL; } test_pr_info("%s: max number of packed requests supported is %d ", __func__, max_num_requests); switch (mbtd->test_group) { case TEST_SEND_WRITE_PACKING_GROUP: case TEST_ERR_CHECK_GROUP: case TEST_SEND_INVALID_GROUP: /* disable the packing control */ host->caps2 &= ~MMC_CAP2_PACKED_WR_CONTROL; break; case TEST_PACKING_CONTROL_GROUP: host->caps2 |= MMC_CAP2_PACKED_WR_CONTROL; break; default: break; } return 0; } static void pseudo_rnd_sector_and_size(unsigned int *seed, unsigned int min_start_sector, unsigned int *start_sector, unsigned int *num_of_bios) { unsigned int max_sec = min_start_sector + TEST_MAX_SECTOR_RANGE; do { *start_sector = pseudo_random_seed(seed, 1, max_sec); *num_of_bios = pseudo_random_seed(seed, 1, TEST_MAX_BIOS_PER_REQ); if (!(*num_of_bios)) *num_of_bios = 1; } while ((*start_sector < min_start_sector) || (*start_sector + (*num_of_bios * BIO_U32_SIZE * 4)) > max_sec); } /* sanitize test functions */ static int prepare_write_discard_sanitize_read(struct test_data *td) { unsigned int start_sector; unsigned int num_of_bios = 0; static unsigned int total_bios; unsigned int *num_bios_seed; int i = 0; if (mbtd->random_test_seed == 0) { mbtd->random_test_seed = (unsigned int)(get_jiffies_64() & 0xFFFF); test_pr_info("%s: got seed from jiffies %d", __func__, mbtd->random_test_seed); } num_bios_seed = &mbtd->random_test_seed; do { pseudo_rnd_sector_and_size(num_bios_seed, td->start_sector, &start_sector, &num_of_bios); /* DISCARD */ total_bios += num_of_bios; test_pr_info("%s: discard req: id=%d, startSec=%d, NumBios=%d", __func__, td->unique_next_req_id, start_sector, num_of_bios); test_iosched_add_unique_test_req(0, REQ_UNIQUE_DISCARD, start_sector, BIO_TO_SECTOR(num_of_bios), NULL); } while (++i < (BLKDEV_MAX_RQ-10)); test_pr_info("%s: total discard bios = %d", __func__, total_bios); test_pr_info("%s: add sanitize req", __func__); test_iosched_add_unique_test_req(0, REQ_UNIQUE_SANITIZE, 0, 0, NULL); return 0; } /* * Post test operations for BKOPs test * Disable the BKOPs statistics and clear the feature flags */ static int bkops_post_test(struct test_data *td) { struct request_queue *q = td->req_q; struct mmc_queue *mq = (struct mmc_queue *)q->queuedata; struct mmc_card *card = mq->card; mmc_card_clr_doing_bkops(mq->card); card->ext_csd.raw_bkops_status = 0; spin_lock(&card->bkops_info.bkops_stats.lock); card->bkops_info.bkops_stats.enabled = false; spin_unlock(&card->bkops_info.bkops_stats.lock); return 0; } /* * Verify the BKOPs statsistics */ static int check_bkops_result(struct test_data *td) { struct request_queue *q = td->req_q; struct mmc_queue *mq = (struct mmc_queue *)q->queuedata; struct mmc_card *card = mq->card; struct mmc_bkops_stats *bkops_stat; if (!card) goto fail; bkops_stat = &card->bkops_info.bkops_stats; test_pr_info("%s: Test results: bkops:(%d,%d,%d) hpi:%d, suspend:%d", __func__, bkops_stat->bkops_level[BKOPS_SEVERITY_1_INDEX], bkops_stat->bkops_level[BKOPS_SEVERITY_2_INDEX], bkops_stat->bkops_level[BKOPS_SEVERITY_3_INDEX], bkops_stat->hpi, bkops_stat->suspend); switch (mbtd->test_info.testcase) { case BKOPS_DELAYED_WORK_LEVEL_1: if ((bkops_stat->bkops_level[BKOPS_SEVERITY_1_INDEX] == 1) && (bkops_stat->suspend == 1) && (bkops_stat->hpi == 0)) goto exit; else goto fail; break; case BKOPS_DELAYED_WORK_LEVEL_1_HPI: if ((bkops_stat->bkops_level[BKOPS_SEVERITY_1_INDEX] == 1) && (bkops_stat->suspend == 0) && (bkops_stat->hpi == 1)) goto exit; /* this might happen due to timing issues */ else if ((bkops_stat->bkops_level[BKOPS_SEVERITY_1_INDEX] == 0) && (bkops_stat->suspend == 0) && (bkops_stat->hpi == 0)) goto ignore; else goto fail; break; case BKOPS_CANCEL_DELAYED_WORK: if ((bkops_stat->bkops_level[BKOPS_SEVERITY_1_INDEX] == 0) && (bkops_stat->bkops_level[BKOPS_SEVERITY_2_INDEX] == 0) && (bkops_stat->bkops_level[BKOPS_SEVERITY_3_INDEX] == 0) && (bkops_stat->suspend == 0) && (bkops_stat->hpi == 0)) goto exit; else goto fail; case BKOPS_URGENT_LEVEL_2: case BKOPS_URGENT_LEVEL_2_TWO_REQS: if ((bkops_stat->bkops_level[BKOPS_SEVERITY_2_INDEX] == 1) && (bkops_stat->suspend == 0) && (bkops_stat->hpi == 0)) goto exit; else goto fail; case BKOPS_URGENT_LEVEL_3: if ((bkops_stat->bkops_level[BKOPS_SEVERITY_3_INDEX] == 1) && (bkops_stat->suspend == 0) && (bkops_stat->hpi == 0)) goto exit; else goto fail; default: return -EINVAL; } exit: return 0; ignore: test_iosched_set_ignore_round(true); return 0; fail: if (td->fs_wr_reqs_during_test) { test_pr_info("%s: wr reqs during test, cancel the round", __func__); test_iosched_set_ignore_round(true); return 0; } test_pr_info("%s: BKOPs statistics are not as expected, test failed", __func__); return -EINVAL; } static void bkops_end_io_final_fn(struct request *rq, int err) { struct test_request *test_rq = (struct test_request *)rq->elv.priv[0]; BUG_ON(!test_rq); 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); mbtd->bkops_stage = BKOPS_STAGE_4; wake_up(&mbtd->bkops_wait_q); } static void bkops_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_rq->req_completed = 1; test_rq->req_result = err; test_pr_info("%s: request %d completed, err=%d", __func__, test_rq->req_id, err); mbtd->bkops_stage = BKOPS_STAGE_2; wake_up(&mbtd->bkops_wait_q); } static int prepare_bkops(struct test_data *td) { int ret = 0; struct request_queue *q = td->req_q; struct mmc_queue *mq = (struct mmc_queue *)q->queuedata; struct mmc_card *card = mq->card; struct mmc_bkops_stats *bkops_stat; if (!card) return -EINVAL; bkops_stat = &card->bkops_info.bkops_stats; if (!card->ext_csd.bkops_en) { test_pr_err("%s: BKOPS is not enabled by card or host)", __func__); return -ENOTSUPP; } if (mmc_card_doing_bkops(card)) { test_pr_err("%s: BKOPS in progress, try later", __func__); return -EAGAIN; } mmc_blk_init_bkops_statistics(card); if ((mbtd->test_info.testcase == BKOPS_URGENT_LEVEL_2) || (mbtd->test_info.testcase == BKOPS_URGENT_LEVEL_2_TWO_REQS) || (mbtd->test_info.testcase == BKOPS_URGENT_LEVEL_3)) mq->err_check_fn = test_err_check; mbtd->err_check_counter = 0; return ret; } static int run_bkops(struct test_data *td) { int ret = 0; struct request_queue *q = td->req_q; struct mmc_queue *mq = (struct mmc_queue *)q->queuedata; struct mmc_card *card = mq->card; struct mmc_bkops_stats *bkops_stat; if (!card) return -EINVAL; bkops_stat = &card->bkops_info.bkops_stats; switch (mbtd->test_info.testcase) { case BKOPS_DELAYED_WORK_LEVEL_1: bkops_stat->ignore_card_bkops_status = true; card->ext_csd.raw_bkops_status = 1; card->bkops_info.sectors_changed = card->bkops_info.min_sectors_to_queue_delayed_work + 1; mbtd->bkops_stage = BKOPS_STAGE_1; __blk_run_queue(q); /* this long sleep makes sure the host starts bkops and also, gets into suspend */ msleep(10000); bkops_stat->ignore_card_bkops_status = false; card->ext_csd.raw_bkops_status = 0; test_iosched_mark_test_completion(); break; case BKOPS_DELAYED_WORK_LEVEL_1_HPI: bkops_stat->ignore_card_bkops_status = true; card->ext_csd.raw_bkops_status = 1; card->bkops_info.sectors_changed = card->bkops_info.min_sectors_to_queue_delayed_work + 1; mbtd->bkops_stage = BKOPS_STAGE_1; __blk_run_queue(q); msleep(card->bkops_info.delay_ms); ret = test_iosched_add_wr_rd_test_req(0, WRITE, td->start_sector, TEST_REQUEST_NUM_OF_BIOS, TEST_PATTERN_5A, bkops_end_io_final_fn); if (ret) { test_pr_err("%s: failed to add a write request", __func__); ret = -EINVAL; break; } __blk_run_queue(q); wait_event(mbtd->bkops_wait_q, mbtd->bkops_stage == BKOPS_STAGE_4); bkops_stat->ignore_card_bkops_status = false; test_iosched_mark_test_completion(); break; case BKOPS_CANCEL_DELAYED_WORK: bkops_stat->ignore_card_bkops_status = true; card->ext_csd.raw_bkops_status = 1; card->bkops_info.sectors_changed = card->bkops_info.min_sectors_to_queue_delayed_work + 1; mbtd->bkops_stage = BKOPS_STAGE_1; __blk_run_queue(q); ret = test_iosched_add_wr_rd_test_req(0, WRITE, td->start_sector, TEST_REQUEST_NUM_OF_BIOS, TEST_PATTERN_5A, bkops_end_io_final_fn); if (ret) { test_pr_err("%s: failed to add a write request", __func__); ret = -EINVAL; break; } __blk_run_queue(q); wait_event(mbtd->bkops_wait_q, mbtd->bkops_stage == BKOPS_STAGE_4); bkops_stat->ignore_card_bkops_status = false; test_iosched_mark_test_completion(); break; case BKOPS_URGENT_LEVEL_2: case BKOPS_URGENT_LEVEL_3: bkops_stat->ignore_card_bkops_status = true; if (mbtd->test_info.testcase == BKOPS_URGENT_LEVEL_2) card->ext_csd.raw_bkops_status = 2; else card->ext_csd.raw_bkops_status = 3; mbtd->bkops_stage = BKOPS_STAGE_1; ret = test_iosched_add_wr_rd_test_req(0, WRITE, td->start_sector, TEST_REQUEST_NUM_OF_BIOS, TEST_PATTERN_5A, bkops_end_io_fn); if (ret) { test_pr_err("%s: failed to add a write request", __func__); ret = -EINVAL; break; } __blk_run_queue(q); wait_event(mbtd->bkops_wait_q, mbtd->bkops_stage == BKOPS_STAGE_2); card->ext_csd.raw_bkops_status = 0; ret = test_iosched_add_wr_rd_test_req(0, WRITE, td->start_sector, TEST_REQUEST_NUM_OF_BIOS, TEST_PATTERN_5A, bkops_end_io_final_fn); if (ret) { test_pr_err("%s: failed to add a write request", __func__); ret = -EINVAL; break; } __blk_run_queue(q); wait_event(mbtd->bkops_wait_q, mbtd->bkops_stage == BKOPS_STAGE_4); bkops_stat->ignore_card_bkops_status = false; test_iosched_mark_test_completion(); break; case BKOPS_URGENT_LEVEL_2_TWO_REQS: mq->wr_packing_enabled = false; bkops_stat->ignore_card_bkops_status = true; card->ext_csd.raw_bkops_status = 2; mbtd->bkops_stage = BKOPS_STAGE_1; ret = test_iosched_add_wr_rd_test_req(0, WRITE, td->start_sector, TEST_REQUEST_NUM_OF_BIOS, TEST_PATTERN_5A, NULL); if (ret) { test_pr_err("%s: failed to add a write request", __func__); ret = -EINVAL; break; } ret = test_iosched_add_wr_rd_test_req(0, WRITE, td->start_sector, TEST_REQUEST_NUM_OF_BIOS, TEST_PATTERN_5A, bkops_end_io_fn); if (ret) { test_pr_err("%s: failed to add a write request", __func__); ret = -EINVAL; break; } __blk_run_queue(q); wait_event(mbtd->bkops_wait_q, mbtd->bkops_stage == BKOPS_STAGE_2); card->ext_csd.raw_bkops_status = 0; ret = test_iosched_add_wr_rd_test_req(0, WRITE, td->start_sector, TEST_REQUEST_NUM_OF_BIOS, TEST_PATTERN_5A, bkops_end_io_final_fn); if (ret) { test_pr_err("%s: failed to add a write request", __func__); ret = -EINVAL; break; } __blk_run_queue(q); wait_event(mbtd->bkops_wait_q, mbtd->bkops_stage == BKOPS_STAGE_4); bkops_stat->ignore_card_bkops_status = false; test_iosched_mark_test_completion(); break; default: test_pr_err("%s: wrong testcase: %d", __func__, mbtd->test_info.testcase); ret = -EINVAL; } return ret; } /* * new_req_post_test() - Do post test operations for * new_req_notification test: disable the statistics and clear * the feature flags. * @td The test_data for the new_req test that has * ended. */ static int new_req_post_test(struct test_data *td) { struct mmc_queue *mq; if (!td || !td->req_q) goto exit; mq = (struct mmc_queue *)td->req_q->queuedata; if (!mq || !mq->card) goto exit; test_pr_info("Completed %d requests", mbtd->completed_req_count); exit: return 0; } /* * check_new_req_result() - Print out the number of completed * requests. Assigned to the check_test_result_fn pointer, * therefore the name. * @td The test_data for the new_req test that has * ended. */ static int check_new_req_result(struct test_data *td) { test_pr_info("%s: Test results: Completed %d requests", __func__, mbtd->completed_req_count); return 0; } /* * new_req_free_end_io_fn() - Remove request from queuelist and * free request's allocated memory. Used as a call-back * assigned to end_io member in request struct. * @rq The request to be freed * @err Unused */ static void new_req_free_end_io_fn(struct request *rq, int err) { struct test_request *test_rq = (struct test_request *)rq->elv.priv[0]; struct test_data *ptd = test_get_test_data(); BUG_ON(!test_rq); spin_lock_irq(&ptd->lock); list_del_init(&test_rq->queuelist); ptd->dispatched_count--; spin_unlock_irq(&ptd->lock); __blk_put_request(ptd->req_q, test_rq->rq); kfree(test_rq->bios_buffer); kfree(test_rq); mbtd->completed_req_count++; } static int prepare_new_req(struct test_data *td) { struct request_queue *q = td->req_q; struct mmc_queue *mq = (struct mmc_queue *)q->queuedata; mmc_blk_init_packed_statistics(mq->card); mbtd->completed_req_count = 0; return 0; } static int run_new_req(struct test_data *ptd) { int ret = 0; int i; unsigned int requests_count = 2; unsigned int bio_num; struct test_request *test_rq = NULL; while (1) { for (i = 0; i < requests_count; i++) { bio_num = TEST_MAX_BIOS_PER_REQ; test_rq = test_iosched_create_test_req(0, READ, ptd->start_sector, bio_num, TEST_PATTERN_5A, new_req_free_end_io_fn); if (test_rq) { spin_lock_irq(ptd->req_q->queue_lock); list_add_tail(&test_rq->queuelist, &ptd->test_queue); ptd->test_count++; spin_unlock_irq(ptd->req_q->queue_lock); } else { test_pr_err("%s: failed to create read request", __func__); ret = -ENODEV; break; } } __blk_run_queue(ptd->req_q); /* wait while a mmc layer will send all requests in test_queue*/ while (!list_empty(&ptd->test_queue)) msleep(NEW_REQ_TEST_SLEEP_TIME); /* test finish criteria */ if (mbtd->completed_req_count > 1000) { if (ptd->dispatched_count) continue; else break; } for (i = 0; i < requests_count; i++) { bio_num = NEW_REQ_TEST_NUM_BIOS; test_rq = test_iosched_create_test_req(0, READ, ptd->start_sector, bio_num, TEST_PATTERN_5A, new_req_free_end_io_fn); if (test_rq) { spin_lock_irq(ptd->req_q->queue_lock); list_add_tail(&test_rq->queuelist, &ptd->test_queue); ptd->test_count++; spin_unlock_irq(ptd->req_q->queue_lock); } else { test_pr_err("%s: failed to create read request", __func__); ret = -ENODEV; break; } } __blk_run_queue(ptd->req_q); } test_iosched_mark_test_completion(); test_pr_info("%s: EXIT: %d code", __func__, ret); return ret; } 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; } /* send_packing TEST */ static ssize_t send_write_packing_test_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { int ret = 0; int i = 0; int number = -1; int j = 0; test_pr_info("%s: -- send_write_packing TEST --", __func__); sscanf(buf, "%d", &number); if (number <= 0) number = 1; mbtd->test_group = TEST_SEND_WRITE_PACKING_GROUP; if (validate_packed_commands_settings()) return count; if (mbtd->random_test_seed > 0) test_pr_info("%s: Test seed: %d", __func__, mbtd->random_test_seed); memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_info.data = mbtd; mbtd->test_info.prepare_test_fn = prepare_test; mbtd->test_info.run_test_fn = run_packed_test; mbtd->test_info.check_test_result_fn = check_wr_packing_statistics; mbtd->test_info.get_test_case_str_fn = get_test_case_str; mbtd->test_info.post_test_fn = post_test; for (i = 0; i < number; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ====================", __func__); for (j = SEND_WRITE_PACKING_MIN_TESTCASE; j <= SEND_WRITE_PACKING_MAX_TESTCASE; j++) { mbtd->test_info.testcase = j; mbtd->is_random = RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) break; /* Allow FS requests to be dispatched */ msleep(1000); mbtd->test_info.testcase = j; mbtd->is_random = NON_RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) break; /* Allow FS requests to be dispatched */ msleep(1000); } } test_pr_info("%s: Completed all the test cases.", __func__); return count; } static ssize_t send_write_packing_test_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) { memset((void *)buffer, 0, count); snprintf(buffer, count, "\nsend_write_packing_test\n" "=========\n" "Description:\n" "This test checks the following scenarios\n" "- Pack due to FLUSH message\n" "- Pack due to FLUSH after threshold writes\n" "- Pack due to READ message\n" "- Pack due to READ after threshold writes\n" "- Pack due to empty queue\n" "- Pack due to threshold writes\n" "- Pack due to one over threshold writes\n"); if (message_repeat == 1) { message_repeat = 0; return strnlen(buffer, count); } else { return 0; } } const struct file_operations send_write_packing_test_ops = { .open = test_open, .write = send_write_packing_test_write, .read = send_write_packing_test_read, }; /* err_check TEST */ static ssize_t err_check_test_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { int ret = 0; int i = 0; int number = -1; int j = 0; test_pr_info("%s: -- err_check TEST --", __func__); sscanf(buf, "%d", &number); if (number <= 0) number = 1; mbtd->test_group = TEST_ERR_CHECK_GROUP; if (validate_packed_commands_settings()) return count; if (mbtd->random_test_seed > 0) test_pr_info("%s: Test seed: %d", __func__, mbtd->random_test_seed); memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_info.data = mbtd; mbtd->test_info.prepare_test_fn = prepare_test; mbtd->test_info.run_test_fn = run_packed_test; mbtd->test_info.check_test_result_fn = check_wr_packing_statistics; mbtd->test_info.get_test_case_str_fn = get_test_case_str; mbtd->test_info.post_test_fn = post_test; for (i = 0; i < number; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ====================", __func__); for (j = ERR_CHECK_MIN_TESTCASE; j <= ERR_CHECK_MAX_TESTCASE ; j++) { mbtd->test_info.testcase = j; mbtd->is_random = RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) break; /* Allow FS requests to be dispatched */ msleep(1000); mbtd->test_info.testcase = j; mbtd->is_random = NON_RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) break; /* Allow FS requests to be dispatched */ msleep(1000); } } test_pr_info("%s: Completed all the test cases.", __func__); return count; } static ssize_t err_check_test_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) { memset((void *)buffer, 0, count); snprintf(buffer, count, "\nerr_check_TEST\n" "=========\n" "Description:\n" "This test checks the following scenarios\n" "- Return ABORT\n" "- Return PARTIAL followed by success\n" "- Return PARTIAL followed by abort\n" "- Return PARTIAL multiple times until success\n" "- Return PARTIAL with fail index = threshold\n" "- Return RETRY\n" "- Return CMD_ERR\n" "- Return DATA_ERR\n"); if (message_repeat == 1) { message_repeat = 0; return strnlen(buffer, count); } else { return 0; } } const struct file_operations err_check_test_ops = { .open = test_open, .write = err_check_test_write, .read = err_check_test_read, }; /* send_invalid_packed TEST */ static ssize_t send_invalid_packed_test_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { int ret = 0; int i = 0; int number = -1; int j = 0; int num_of_failures = 0; test_pr_info("%s: -- send_invalid_packed TEST --", __func__); sscanf(buf, "%d", &number); if (number <= 0) number = 1; mbtd->test_group = TEST_SEND_INVALID_GROUP; if (validate_packed_commands_settings()) return count; if (mbtd->random_test_seed > 0) test_pr_info("%s: Test seed: %d", __func__, mbtd->random_test_seed); memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_info.data = mbtd; mbtd->test_info.prepare_test_fn = prepare_test; mbtd->test_info.run_test_fn = run_packed_test; mbtd->test_info.check_test_result_fn = check_wr_packing_statistics; mbtd->test_info.get_test_case_str_fn = get_test_case_str; mbtd->test_info.post_test_fn = post_test; for (i = 0; i < number; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ====================", __func__); for (j = INVALID_CMD_MIN_TESTCASE; j <= INVALID_CMD_MAX_TESTCASE ; j++) { mbtd->test_info.testcase = j; mbtd->is_random = RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) num_of_failures++; /* Allow FS requests to be dispatched */ msleep(1000); mbtd->test_info.testcase = j; mbtd->is_random = NON_RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) num_of_failures++; /* Allow FS requests to be dispatched */ msleep(1000); } } test_pr_info("%s: Completed all the test cases.", __func__); if (num_of_failures > 0) { test_iosched_set_test_result(TEST_FAILED); test_pr_err( "There were %d failures during the test, TEST FAILED", num_of_failures); } return count; } static ssize_t send_invalid_packed_test_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) { memset((void *)buffer, 0, count); snprintf(buffer, count, "\nsend_invalid_packed_TEST\n" "=========\n" "Description:\n" "This test checks the following scenarios\n" "- Send an invalid header version\n" "- Send the wrong write code\n" "- Send an invalid R/W code\n" "- Send wrong start address in header\n" "- Send header with block_count smaller than actual\n" "- Send header with block_count larger than actual\n" "- Send header CMD23 packed bit set\n" "- Send CMD23 with block count over threshold\n" "- Send CMD23 with block_count equals zero\n" "- Send CMD23 packed bit unset\n" "- Send CMD23 reliable write bit set\n" "- Send CMD23 bits [16-29] set\n" "- Send CMD23 header block not in block_count\n"); if (message_repeat == 1) { message_repeat = 0; return strnlen(buffer, count); } else { return 0; } } const struct file_operations send_invalid_packed_test_ops = { .open = test_open, .write = send_invalid_packed_test_write, .read = send_invalid_packed_test_read, }; /* packing_control TEST */ static ssize_t write_packing_control_test_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { int ret = 0; int i = 0; int number = -1; int j = 0; struct mmc_queue *mq = test_iosched_get_req_queue()->queuedata; int max_num_requests = mq->card->ext_csd.max_packed_writes; int test_successful = 1; test_pr_info("%s: -- write_packing_control TEST --", __func__); sscanf(buf, "%d", &number); if (number <= 0) number = 1; test_pr_info("%s: max_num_requests = %d ", __func__, max_num_requests); memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_group = TEST_PACKING_CONTROL_GROUP; if (validate_packed_commands_settings()) return count; mbtd->test_info.data = mbtd; mbtd->test_info.prepare_test_fn = prepare_test; mbtd->test_info.run_test_fn = run_packed_test; mbtd->test_info.check_test_result_fn = check_wr_packing_statistics; mbtd->test_info.get_test_case_str_fn = get_test_case_str; for (i = 0; i < number; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ====================", __func__); for (j = PACKING_CONTROL_MIN_TESTCASE; j <= PACKING_CONTROL_MAX_TESTCASE; j++) { test_successful = 1; mbtd->test_info.testcase = j; mbtd->is_random = RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) { test_successful = 0; break; } /* Allow FS requests to be dispatched */ msleep(1000); mbtd->test_info.testcase = j; mbtd->is_random = NON_RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) { test_successful = 0; break; } /* Allow FS requests to be dispatched */ msleep(1000); } if (!test_successful) break; } test_pr_info("%s: Completed all the test cases.", __func__); return count; } static ssize_t write_packing_control_test_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) { memset((void *)buffer, 0, count); snprintf(buffer, count, "\nwrite_packing_control_test\n" "=========\n" "Description:\n" "This test checks the following scenarios\n" "- Packing expected - one over trigger\n" "- Packing expected - N over trigger\n" "- Packing expected - N over trigger followed by read\n" "- Packing expected - N over trigger followed by flush\n" "- Packing expected - threshold over trigger FB by flush\n" "- Packing not expected - less than trigger\n" "- Packing not expected - trigger requests\n" "- Packing not expected - trigger, read, trigger\n" "- Mixed state - packing -> no packing -> packing\n" "- Mixed state - no packing -> packing -> no packing\n"); if (message_repeat == 1) { message_repeat = 0; return strnlen(buffer, count); } else { return 0; } } const struct file_operations write_packing_control_test_ops = { .open = test_open, .write = write_packing_control_test_write, .read = write_packing_control_test_read, }; static ssize_t write_discard_sanitize_test_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { int ret = 0; int i = 0; int number = -1; sscanf(buf, "%d", &number); if (number <= 0) number = 1; test_pr_info("%s: -- write_discard_sanitize TEST --\n", __func__); memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_group = TEST_GENERAL_GROUP; mbtd->test_info.data = mbtd; mbtd->test_info.prepare_test_fn = prepare_write_discard_sanitize_read; mbtd->test_info.get_test_case_str_fn = get_test_case_str; mbtd->test_info.timeout_msec = SANITIZE_TEST_TIMEOUT; for (i = 0 ; i < number ; ++i) { test_pr_info("%s: Cycle # %d / %d\n", __func__, i+1, number); test_pr_info("%s: ===================", __func__); mbtd->test_info.testcase = TEST_WRITE_DISCARD_SANITIZE_READ; ret = test_iosched_start_test(&mbtd->test_info); if (ret) break; } return count; } const struct file_operations write_discard_sanitize_test_ops = { .open = test_open, .write = write_discard_sanitize_test_write, }; static ssize_t bkops_test_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { int ret = 0; int i = 0, j; int number = -1; test_pr_info("%s: -- bkops_test TEST --", __func__); sscanf(buf, "%d", &number); if (number <= 0) number = 1; mbtd->test_group = TEST_BKOPS_GROUP; memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_info.data = mbtd; mbtd->test_info.prepare_test_fn = prepare_bkops; mbtd->test_info.check_test_result_fn = check_bkops_result; mbtd->test_info.get_test_case_str_fn = get_test_case_str; mbtd->test_info.run_test_fn = run_bkops; mbtd->test_info.timeout_msec = BKOPS_TEST_TIMEOUT; mbtd->test_info.post_test_fn = bkops_post_test; for (i = 0 ; i < number ; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ===================", __func__); for (j = BKOPS_MIN_TESTCASE ; j <= BKOPS_MAX_TESTCASE ; j++) { mbtd->test_info.testcase = j; ret = test_iosched_start_test(&mbtd->test_info); if (ret) break; } } test_pr_info("%s: Completed all the test cases.", __func__); return count; } static ssize_t bkops_test_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) { memset((void *)buffer, 0, count); snprintf(buffer, count, "\nbkops_test\n========================\n" "Description:\n" "This test simulates BKOPS status from card\n" "and verifies that:\n" " - Starting BKOPS delayed work, level 1\n" " - Starting BKOPS delayed work, level 1, with HPI\n" " - Cancel starting BKOPS delayed work, " " when a request is received\n" " - Starting BKOPS urgent, level 2,3\n" " - Starting BKOPS urgent with 2 requests\n"); return strnlen(buffer, count); } const struct file_operations bkops_test_ops = { .open = test_open, .write = bkops_test_write, .read = bkops_test_read, }; 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, integer, fraction; test_pr_info("%s: -- Long Sequential Read TEST --", __func__); sscanf(buf, "%d", &number); if (number <= 0) number = 1; memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_group = TEST_GENERAL_GROUP; mbtd->test_info.data = mbtd; mbtd->test_info.prepare_test_fn = prepare_test; mbtd->test_info.get_test_case_str_fn = get_test_case_str; for (i = 0 ; i < number ; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ====================", __func__); mbtd->test_info.testcase = TEST_LONG_SEQUENTIAL_READ; mbtd->is_random = NON_RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) break; mtime = jiffies_to_msecs(mbtd->test_info.test_duration); test_pr_info("%s: time is %lu msec, size is %u.%u MiB", __func__, mtime, LONG_TEST_SIZE_INTEGER(LONG_READ_NUM_BYTES), LONG_TEST_SIZE_FRACTION(LONG_READ_NUM_BYTES)); /* we first multiply in order not to lose precision */ mtime *= MB_MSEC_RATIO_APPROXIMATION; /* divide values to get a MiB/sec integer value with one digit of precision. Multiply by 10 for one digit precision */ fraction = integer = (LONG_READ_NUM_BYTES * 10) / mtime; integer /= 10; /* and calculate the MiB value fraction */ fraction -= integer * 10; test_pr_info("%s: Throughput: %lu.%lu MiB/sec\n" , __func__, integer, fraction); /* 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, "\nlong_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; } 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 void long_seq_write_free_end_io_fn(struct request *rq, int err) { struct test_request *test_rq = (struct test_request *)rq->elv.priv[0]; struct test_data *ptd = test_get_test_data(); BUG_ON(!test_rq); spin_lock_irq(&ptd->lock); list_del_init(&test_rq->queuelist); ptd->dispatched_count--; __blk_put_request(ptd->req_q, test_rq->rq); spin_unlock_irq(&ptd->lock); kfree(test_rq->bios_buffer); kfree(test_rq); mbtd->completed_req_count++; check_test_completion(); } static int run_long_seq_write(struct test_data *td) { int ret = 0; int i; td->test_count = 0; mbtd->completed_req_count = 0; test_pr_info("%s: Adding at least %d write requests, first req_id=%d", __func__, LONG_WRITE_TEST_MIN_NUM_REQS, td->wr_rd_next_req_id); do { for (i = 0; i < TEST_MAX_REQUESTS; i++) { /* * since our requests come from a pool containing 128 * requests, we don't want to exhaust this quantity, * therefore we add up to TEST_MAX_REQUESTS (which * includes a safety margin) and then call the mmc layer * to fetch them */ if (td->test_count > TEST_MAX_REQUESTS) break; ret = test_iosched_add_wr_rd_test_req(0, WRITE, td->start_sector, TEST_MAX_BIOS_PER_REQ, TEST_PATTERN_5A, long_seq_write_free_end_io_fn); if (ret) { test_pr_err("%s: failed to create write request" , __func__); break; } } __blk_run_queue(td->req_q); } while (mbtd->completed_req_count < LONG_WRITE_TEST_MIN_NUM_REQS); test_pr_info("%s: completed %d requests", __func__, mbtd->completed_req_count); return ret; } static ssize_t long_sequential_write_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, integer, fraction, byte_count; test_pr_info("%s: -- Long Sequential Write TEST --", __func__); sscanf(buf, "%d", &number); if (number <= 0) number = 1; memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_group = TEST_GENERAL_GROUP; mbtd->test_info.data = mbtd; mbtd->test_info.get_test_case_str_fn = get_test_case_str; mbtd->test_info.run_test_fn = run_long_seq_write; for (i = 0 ; i < number ; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ====================", __func__); integer = 0; fraction = 0; mbtd->test_info.test_byte_count = 0; mbtd->test_info.testcase = TEST_LONG_SEQUENTIAL_WRITE; mbtd->is_random = NON_RANDOM_TEST; ret = test_iosched_start_test(&mbtd->test_info); if (ret) break; mtime = jiffies_to_msecs(mbtd->test_info.test_duration); byte_count = mbtd->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), LONG_TEST_SIZE_FRACTION(byte_count)); /* we first multiply in order not to lose precision */ mtime *= MB_MSEC_RATIO_APPROXIMATION; /* divide values to get a MiB/sec integer value with one digit of precision */ fraction = integer = (byte_count * 10) / mtime; integer /= 10; /* and calculate the MiB value fraction */ fraction -= integer * 10; test_pr_info("%s: Throughput: %lu.%lu MiB/sec\n", __func__, integer, fraction); /* Allow FS requests to be dispatched */ msleep(1000); } 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, "\nlong_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, }; static ssize_t new_req_notification_test_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { int ret = 0; int i = 0; int number = -1; test_pr_info("%s: -- new_req_notification TEST --", __func__); sscanf(buf, "%d", &number); if (number <= 0) number = 1; mbtd->test_group = TEST_NEW_NOTIFICATION_GROUP; memset(&mbtd->test_info, 0, sizeof(struct test_info)); mbtd->test_info.data = mbtd; mbtd->test_info.prepare_test_fn = prepare_new_req; mbtd->test_info.check_test_result_fn = check_new_req_result; mbtd->test_info.get_test_case_str_fn = get_test_case_str; mbtd->test_info.run_test_fn = run_new_req; mbtd->test_info.timeout_msec = 10 * 60 * 1000; /* 1 min */ mbtd->test_info.post_test_fn = new_req_post_test; for (i = 0 ; i < number ; ++i) { test_pr_info("%s: Cycle # %d / %d", __func__, i+1, number); test_pr_info("%s: ===================", __func__); test_pr_info("%s: start test case TEST_NEW_REQ_NOTIFICATION", __func__); mbtd->test_info.testcase = TEST_NEW_REQ_NOTIFICATION; ret = test_iosched_start_test(&mbtd->test_info); if (ret) { test_pr_info("%s: break from new_req tests loop", __func__); break; } } return count; } static ssize_t new_req_notification_test_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) { memset((void *)buffer, 0, count); snprintf(buffer, count, "\nnew_req_notification_test\n========================\n" "Description:\n" "This test checks following scenarious\n" "- new request arrives after a NULL request was sent to the " "mmc_queue,\n" "which is waiting for completion of a former request\n"); return strnlen(buffer, count); } const struct file_operations new_req_notification_test_ops = { .open = test_open, .write = new_req_notification_test_write, .read = new_req_notification_test_read, }; static void mmc_block_test_debugfs_cleanup(void) { debugfs_remove(mbtd->debug.random_test_seed); debugfs_remove(mbtd->debug.send_write_packing_test); debugfs_remove(mbtd->debug.err_check_test); debugfs_remove(mbtd->debug.send_invalid_packed_test); debugfs_remove(mbtd->debug.packing_control_test); debugfs_remove(mbtd->debug.discard_sanitize_test); debugfs_remove(mbtd->debug.bkops_test); debugfs_remove(mbtd->debug.long_sequential_read_test); debugfs_remove(mbtd->debug.long_sequential_write_test); debugfs_remove(mbtd->debug.new_req_notification_test); } static int mmc_block_test_debugfs_init(void) { struct dentry *utils_root, *tests_root; utils_root = test_iosched_get_debugfs_utils_root(); tests_root = test_iosched_get_debugfs_tests_root(); if (!utils_root || !tests_root) return -EINVAL; mbtd->debug.random_test_seed = debugfs_create_u32( "random_test_seed", S_IRUGO | S_IWUGO, utils_root, &mbtd->random_test_seed); if (!mbtd->debug.random_test_seed) goto err_nomem; mbtd->debug.send_write_packing_test = debugfs_create_file("send_write_packing_test", S_IRUGO | S_IWUGO, tests_root, NULL, &send_write_packing_test_ops); if (!mbtd->debug.send_write_packing_test) goto err_nomem; mbtd->debug.err_check_test = debugfs_create_file("err_check_test", S_IRUGO | S_IWUGO, tests_root, NULL, &err_check_test_ops); if (!mbtd->debug.err_check_test) goto err_nomem; mbtd->debug.send_invalid_packed_test = debugfs_create_file("send_invalid_packed_test", S_IRUGO | S_IWUGO, tests_root, NULL, &send_invalid_packed_test_ops); if (!mbtd->debug.send_invalid_packed_test) goto err_nomem; mbtd->debug.packing_control_test = debugfs_create_file( "packing_control_test", S_IRUGO | S_IWUGO, tests_root, NULL, &write_packing_control_test_ops); if (!mbtd->debug.packing_control_test) goto err_nomem; mbtd->debug.discard_sanitize_test = debugfs_create_file("write_discard_sanitize_test", S_IRUGO | S_IWUGO, tests_root, NULL, &write_discard_sanitize_test_ops); if (!mbtd->debug.discard_sanitize_test) { mmc_block_test_debugfs_cleanup(); return -ENOMEM; } mbtd->debug.bkops_test = debugfs_create_file("bkops_test", S_IRUGO | S_IWUGO, tests_root, NULL, &bkops_test_ops); mbtd->debug.new_req_notification_test = debugfs_create_file("new_req_notification_test", S_IRUGO | S_IWUGO, tests_root, NULL, &new_req_notification_test_ops); if (!mbtd->debug.new_req_notification_test) goto err_nomem; if (!mbtd->debug.bkops_test) goto err_nomem; mbtd->debug.long_sequential_read_test = debugfs_create_file( "long_sequential_read_test", S_IRUGO | S_IWUGO, tests_root, NULL, &long_sequential_read_test_ops); if (!mbtd->debug.long_sequential_read_test) goto err_nomem; mbtd->debug.long_sequential_write_test = debugfs_create_file( "long_sequential_write_test", S_IRUGO | S_IWUGO, tests_root, NULL, &long_sequential_write_test_ops); if (!mbtd->debug.long_sequential_write_test) goto err_nomem; return 0; err_nomem: mmc_block_test_debugfs_cleanup(); return -ENOMEM; } static void mmc_block_test_probe(void) { struct request_queue *q = test_iosched_get_req_queue(); struct mmc_queue *mq; int max_packed_reqs; if (!q) { test_pr_err("%s: NULL request queue", __func__); return; } mq = q->queuedata; if (!mq) { test_pr_err("%s: NULL mq", __func__); return; } max_packed_reqs = mq->card->ext_csd.max_packed_writes; mbtd->exp_packed_stats.packing_events = kzalloc((max_packed_reqs + 1) * sizeof(*mbtd->exp_packed_stats.packing_events), GFP_KERNEL); mmc_block_test_debugfs_init(); } static void mmc_block_test_remove(void) { mmc_block_test_debugfs_cleanup(); } static int __init mmc_block_test_init(void) { mbtd = kzalloc(sizeof(struct mmc_block_test_data), GFP_KERNEL); if (!mbtd) { test_pr_err("%s: failed to allocate mmc_block_test_data", __func__); return -ENODEV; } init_waitqueue_head(&mbtd->bkops_wait_q); mbtd->bdt.init_fn = mmc_block_test_probe; mbtd->bdt.exit_fn = mmc_block_test_remove; INIT_LIST_HEAD(&mbtd->bdt.list); test_iosched_register(&mbtd->bdt); return 0; } static void __exit mmc_block_test_exit(void) { test_iosched_unregister(&mbtd->bdt); kfree(mbtd); } module_init(mmc_block_test_init); module_exit(mmc_block_test_exit); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("MMC block test");