mm/page_alloc: prevent merging between isolated and other pageblocks
[linux-2.6-block.git] / kernel / time / test_udelay.c
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) {
46                 struct timespec ts1, ts2;
47                 int time_passed;
48
49                 ktime_get_ts(&ts1);
50                 udelay(usecs);
51                 ktime_get_ts(&ts2);
52                 time_passed = timespec_to_ns(&ts2) - timespec_to_ns(&ts1);
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) {
90                 struct timespec ts;
91
92                 ktime_get_ts(&ts);
93                 seq_printf(s, "udelay() test (lpj=%ld kt=%ld.%09ld)\n",
94                                 loops_per_jiffy, ts.tv_sec, ts.tv_nsec);
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");