[mirror_ubuntu-artful-kernel.git] / kernel / time / test_udelay.c

/*
 * udelay() test kernel module
 *
 * Test is executed by writing and reading to /sys/kernel/debug/udelay_test
 * Tests are configured by writing: USECS ITERATIONS
 * Tests are executed by reading from the same file.
 * Specifying usecs of 0 or negative values will run multiples tests.
 *
 * Copyright (C) 2014 Google, Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * 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.
 */

#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/ktime.h>
#include <linux/module.h>
#include <linux/uaccess.h>

#define DEFAULT_ITERATIONS 100

#define DEBUGFS_FILENAME "udelay_test"

static DEFINE_MUTEX(udelay_test_lock);
static struct dentry *udelay_test_debugfs_file;
static int udelay_test_usecs;
static int udelay_test_iterations = DEFAULT_ITERATIONS;

static int udelay_test_single(struct seq_file *s, int usecs, uint32_t iters)
{
	int min = 0, max = 0, fail_count = 0;
	uint64_t sum = 0;
	uint64_t avg;
	int i;
	/* Allow udelay to be up to 0.5% fast */
	int allowed_error_ns = usecs * 5;

	for (i = 0; i < iters; ++i) {
		s64 kt1, kt2;
		int time_passed;

		kt1 = ktime_get_ns();
		udelay(usecs);
		kt2 = ktime_get_ns();
		time_passed = kt2 - kt1;

		if (i == 0 || time_passed < min)
			min = time_passed;
		if (i == 0 || time_passed > max)
			max = time_passed;
		if ((time_passed + allowed_error_ns) / 1000 < usecs)
			++fail_count;
		WARN_ON(time_passed < 0);
		sum += time_passed;
	}

	avg = sum;
	do_div(avg, iters);
	seq_printf(s, "%d usecs x %d: exp=%d allowed=%d min=%d avg=%lld max=%d",
			usecs, iters, usecs * 1000,
			(usecs * 1000) - allowed_error_ns, min, avg, max);
	if (fail_count)
		seq_printf(s, " FAIL=%d", fail_count);
	seq_puts(s, "\n");

	return 0;
}

static int udelay_test_show(struct seq_file *s, void *v)
{
	int usecs;
	int iters;
	int ret = 0;

	mutex_lock(&udelay_test_lock);
	usecs = udelay_test_usecs;
	iters = udelay_test_iterations;
	mutex_unlock(&udelay_test_lock);

	if (usecs > 0 && iters > 0) {
		return udelay_test_single(s, usecs, iters);
	} else if (usecs == 0) {
		struct timespec64 ts;

		ktime_get_ts64(&ts);
		seq_printf(s, "udelay() test (lpj=%ld kt=%lld.%09ld)\n",
				loops_per_jiffy, (s64)ts.tv_sec, ts.tv_nsec);
		seq_puts(s, "usage:\n");
		seq_puts(s, "echo USECS [ITERS] > " DEBUGFS_FILENAME "\n");
		seq_puts(s, "cat " DEBUGFS_FILENAME "\n");
	}

	return ret;
}

static int udelay_test_open(struct inode *inode, struct file *file)
{
	return single_open(file, udelay_test_show, inode->i_private);
}

static ssize_t udelay_test_write(struct file *file, const char __user *buf,
		size_t count, loff_t *pos)
{
	char lbuf[32];
	int ret;
	int usecs;
	int iters;

	if (count >= sizeof(lbuf))
		return -EINVAL;

	if (copy_from_user(lbuf, buf, count))
		return -EFAULT;
	lbuf[count] = '\0';

	ret = sscanf(lbuf, "%d %d", &usecs, &iters);
	if (ret < 1)
		return -EINVAL;
	else if (ret < 2)
		iters = DEFAULT_ITERATIONS;

	mutex_lock(&udelay_test_lock);
	udelay_test_usecs = usecs;
	udelay_test_iterations = iters;
	mutex_unlock(&udelay_test_lock);

	return count;
}

static const struct file_operations udelay_test_debugfs_ops = {
	.owner = THIS_MODULE,
	.open = udelay_test_open,
	.read = seq_read,
	.write = udelay_test_write,
	.llseek = seq_lseek,
	.release = single_release,
};

static int __init udelay_test_init(void)
{
	mutex_lock(&udelay_test_lock);
	udelay_test_debugfs_file = debugfs_create_file(DEBUGFS_FILENAME,
			S_IRUSR, NULL, NULL, &udelay_test_debugfs_ops);
	mutex_unlock(&udelay_test_lock);

	return 0;
}

module_init(udelay_test_init);

static void __exit udelay_test_exit(void)
{
	mutex_lock(&udelay_test_lock);
	debugfs_remove(udelay_test_debugfs_file);
	mutex_unlock(&udelay_test_lock);
}

module_exit(udelay_test_exit);

MODULE_AUTHOR("David Riley <davidriley@chromium.org>");
MODULE_LICENSE("GPL");
Commit	Line	Data
e704f93a DR	1	/*
	2	* udelay() test kernel module
	3	*
	4	* Test is executed by writing and reading to /sys/kernel/debug/udelay_test
	5	* Tests are configured by writing: USECS ITERATIONS
	6	* Tests are executed by reading from the same file.
	7	* Specifying usecs of 0 or negative values will run multiples tests.
	8	*
	9	* Copyright (C) 2014 Google, Inc.
	10	*
	11	* This software is licensed under the terms of the GNU General Public
	12	* License version 2, as published by the Free Software Foundation, and
	13	* may be copied, distributed, and modified under those terms.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*/
	20
	21	#include <linux/debugfs.h>
	22	#include <linux/delay.h>
	23	#include <linux/ktime.h>
	24	#include <linux/module.h>
	25	#include <linux/uaccess.h>
	26
	27	#define DEFAULT_ITERATIONS 100
	28
	29	#define DEBUGFS_FILENAME "udelay_test"
	30
	31	static DEFINE_MUTEX(udelay_test_lock);
	32	static struct dentry *udelay_test_debugfs_file;
	33	static int udelay_test_usecs;
	34	static int udelay_test_iterations = DEFAULT_ITERATIONS;
	35
	36	static int udelay_test_single(struct seq_file *s, int usecs, uint32_t iters)
	37	{
	38	int min = 0, max = 0, fail_count = 0;
	39	uint64_t sum = 0;
	40	uint64_t avg;
	41	int i;
	42	/* Allow udelay to be up to 0.5% fast */
	43	int allowed_error_ns = usecs * 5;
	44
	45	for (i = 0; i < iters; ++i) {
4a19bd3d	46	s64 kt1, kt2;
e704f93a DR	47	int time_passed;
e704f93a DR	48
4a19bd3d	49	kt1 = ktime_get_ns();
e704f93a	50	udelay(usecs);
4a19bd3d AB	51	kt2 = ktime_get_ns();
4a19bd3d AB	52	time_passed = kt2 - kt1;
e704f93a DR	53
	54	if (i == 0 \|\| time_passed < min)
	55	min = time_passed;
	56	if (i == 0 \|\| time_passed > max)
	57	max = time_passed;
	58	if ((time_passed + allowed_error_ns) / 1000 < usecs)
	59	++fail_count;
	60	WARN_ON(time_passed < 0);
	61	sum += time_passed;
	62	}
	63
	64	avg = sum;
	65	do_div(avg, iters);
	66	seq_printf(s, "%d usecs x %d: exp=%d allowed=%d min=%d avg=%lld max=%d",
	67	usecs, iters, usecs * 1000,
	68	(usecs * 1000) - allowed_error_ns, min, avg, max);
	69	if (fail_count)
	70	seq_printf(s, " FAIL=%d", fail_count);
	71	seq_puts(s, "\n");
	72
	73	return 0;
	74	}
	75
	76	static int udelay_test_show(struct seq_file s, void v)
	77	{
	78	int usecs;
	79	int iters;
	80	int ret = 0;
	81
	82	mutex_lock(&udelay_test_lock);
	83	usecs = udelay_test_usecs;
	84	iters = udelay_test_iterations;
	85	mutex_unlock(&udelay_test_lock);
	86
	87	if (usecs > 0 && iters > 0) {
	88	return udelay_test_single(s, usecs, iters);
	89	} else if (usecs == 0) {
4a19bd3d	90	struct timespec64 ts;
e704f93a	91
4a19bd3d AB	92	ktime_get_ts64(&ts);
	93	seq_printf(s, "udelay() test (lpj=%ld kt=%lld.%09ld)\n",
	94	loops_per_jiffy, (s64)ts.tv_sec, ts.tv_nsec);
e704f93a DR	95	seq_puts(s, "usage:\n");
	96	seq_puts(s, "echo USECS [ITERS] > " DEBUGFS_FILENAME "\n");
	97	seq_puts(s, "cat " DEBUGFS_FILENAME "\n");
	98	}
	99
	100	return ret;
	101	}
	102
	103	static int udelay_test_open(struct inode inode, struct file file)
	104	{
	105	return single_open(file, udelay_test_show, inode->i_private);
	106	}
	107
	108	static ssize_t udelay_test_write(struct file file, const char __user buf,
	109	size_t count, loff_t *pos)
	110	{
	111	char lbuf[32];
	112	int ret;
	113	int usecs;
	114	int iters;
	115
	116	if (count >= sizeof(lbuf))
	117	return -EINVAL;
	118
	119	if (copy_from_user(lbuf, buf, count))
	120	return -EFAULT;
	121	lbuf[count] = '\0';
	122
	123	ret = sscanf(lbuf, "%d %d", &usecs, &iters);
	124	if (ret < 1)
	125	return -EINVAL;
	126	else if (ret < 2)
	127	iters = DEFAULT_ITERATIONS;
	128
	129	mutex_lock(&udelay_test_lock);
	130	udelay_test_usecs = usecs;
	131	udelay_test_iterations = iters;
	132	mutex_unlock(&udelay_test_lock);
	133
	134	return count;
	135	}
	136
	137	static const struct file_operations udelay_test_debugfs_ops = {
	138	.owner = THIS_MODULE,
	139	.open = udelay_test_open,
	140	.read = seq_read,
	141	.write = udelay_test_write,
	142	.llseek = seq_lseek,
	143	.release = single_release,
	144	};
	145
	146	static int __init udelay_test_init(void)
	147	{
	148	mutex_lock(&udelay_test_lock);
	149	udelay_test_debugfs_file = debugfs_create_file(DEBUGFS_FILENAME,
	150	S_IRUSR, NULL, NULL, &udelay_test_debugfs_ops);
	151	mutex_unlock(&udelay_test_lock);
	152
	153	return 0;
	154	}
	155
	156	module_init(udelay_test_init);
	157
	158	static void __exit udelay_test_exit(void)
159	{
160	mutex_lock(&udelay_test_lock);
161	debugfs_remove(udelay_test_debugfs_file);
162	mutex_unlock(&udelay_test_lock);
163	}
164
165	module_exit(udelay_test_exit);
166
167	MODULE_AUTHOR("David Riley <davidriley@chromium.org>");
168	MODULE_LICENSE("GPL");