static ssize_t ufsdbg_tag_stats_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos) { struct ufs_hba *hba = filp->f_mapping->host->i_private; struct ufs_stats *ufs_stats; int val = 0; int ret; unsigned long flags; ret = kstrtoint_from_user(ubuf, cnt, 0, &val); if (ret) { dev_err(hba->dev, "%s: Invalid argument\n", __func__); return ret; } ufs_stats = &hba->ufs_stats; spin_lock_irqsave(hba->host->host_lock, flags); if (!val) { ufs_stats->enabled = false; pr_debug("%s: Disabling UFS tag statistics", __func__); } else { ufs_stats->enabled = true; pr_debug("%s: Enabling & Resetting UFS tag statistics", __func__); memset(ufs_stats->tag_stats, 0, sizeof(*ufs_stats->tag_stats) * hba->nutrs); } spin_unlock_irqrestore(hba->host->host_lock, flags); return cnt; }
static ssize_t syswp_proc_write(struct file *file, const char *buf, size_t count, loff_t *pos) { int ret, value; if ((count <= 0) || (count > 2)) return -EINVAL; ret = kstrtoint_from_user(buf, count, 10, &value); if (ret) return ret; blk_set_ro_secure_debuggable(!!value); return count; }
static ssize_t apb_log_enable_write(struct file *f, const char __user *buf, size_t count, loff_t *ppos) { int enable; ssize_t retval; struct es2_ap_dev *es2 = f->f_inode->i_private; retval = kstrtoint_from_user(buf, count, 10, &enable); if (retval) return retval; if (enable) usb_log_enable(es2); else usb_log_disable(es2); return count; }
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; int number; ret = kstrtoint_from_user(buf, count, 0, &number); if (ret < 0) { pr_err("%s: Error while reading test parameter value %d", __func__, ret); return ret; } if (number <= 0) number = 1; 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 = test_case; utd->test_info.get_rq_disk_fn = ufs_test_get_rq_disk; utd->test_info.check_test_result_fn = ufs_test_check_result; utd->test_stage = DEFAULT; switch (test_case) { case UFS_TEST_WRITE_READ_TEST: utd->test_info.run_test_fn = ufs_test_run_write_read_test; utd->test_info.check_test_completion_fn = ufs_write_read_completion; break; case UFS_TEST_MULTI_QUERY: utd->test_info.run_test_fn = ufs_test_run_multi_query_test; utd->test_info.check_test_result_fn = ufs_test_check_result; 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; utd->test_info.check_test_result_fn = ufs_test_check_result; utd->test_info.check_test_completion_fn = long_seq_test_check_completion; break; case UFS_TEST_LONG_SEQUENTIAL_MIXED: utd->test_info.timeout_msec = LONG_SEQUENTIAL_MIXED_TIMOUT_MS; utd->test_info.run_test_fn = run_mixed_long_seq_test; utd->test_info.post_test_fn = long_seq_test_calc_throughput; utd->test_info.check_test_result_fn = ufs_test_check_result; break; case UFS_TEST_PARALLEL_READ_AND_WRITE: utd->test_info.run_test_fn = ufs_test_run_parallel_read_and_write_test; utd->test_info.check_test_completion_fn = ufs_test_multi_thread_completion; break; case UFS_TEST_LUN_DEPTH: utd->test_info.run_test_fn = ufs_test_run_lun_depth_test; break; default: pr_err("%s: Unknown test-case: %d", __func__, test_case); WARN_ON(true); } /* Running the test multiple times */ for (i = 0; i < number; ++i) { pr_info("%s: Cycle # %d / %d", __func__, i+1, number); pr_info("%s: ====================", __func__); utd->test_info.test_byte_count = 0; ret = test_iosched_start_test(&utd->test_info); if (ret) { pr_err("%s: Test failed, err=%d.", __func__, ret); return ret; } /* Allow FS requests to be dispatched */ msleep(1000); } pr_info("%s: Completed all the ufs test iterations.", __func__); return count; }