Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2014 Google, Inc.
4 */
5
6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
8#include <linux/delay.h>
9#include <linux/init.h>
10#include <linux/hrtimer.h>
11#include <linux/module.h>
12#include <linux/platform_device.h>
13#include <linux/time.h>
14#include <linux/numa.h>
15#include <linux/nodemask.h>
16#include <linux/topology.h>
17
18#define TEST_PROBE_DELAY (5 * 1000) /* 5 sec */
19#define TEST_PROBE_THRESHOLD (TEST_PROBE_DELAY / 2)
20
21static atomic_t warnings, errors, timeout, async_completed;
22
23static int test_probe(struct platform_device *pdev)
24{
25 struct device *dev = &pdev->dev;
26
27 /*
28 * Determine if we have hit the "timeout" limit for the test if we
29 * have then report it as an error, otherwise we wil sleep for the
30 * required amount of time and then report completion.
31 */
32 if (atomic_read(&timeout)) {
33 dev_err(dev, "async probe took too long\n");
34 atomic_inc(&errors);
35 } else {
36 dev_dbg(&pdev->dev, "sleeping for %d msecs in probe\n",
37 TEST_PROBE_DELAY);
38 msleep(TEST_PROBE_DELAY);
39 dev_dbg(&pdev->dev, "done sleeping\n");
40 }
41
42 /*
43 * Report NUMA mismatch if device node is set and we are not
44 * performing an async init on that node.
45 */
46 if (dev->driver->probe_type == PROBE_PREFER_ASYNCHRONOUS) {
47 if (IS_ENABLED(CONFIG_NUMA) &&
48 dev_to_node(dev) != numa_node_id()) {
49 dev_warn(dev, "NUMA node mismatch %d != %d\n",
50 dev_to_node(dev), numa_node_id());
51 atomic_inc(&warnings);
52 }
53
54 atomic_inc(&async_completed);
55 }
56
57 return 0;
58}
59
60static struct platform_driver async_driver = {
61 .driver = {
62 .name = "test_async_driver",
63 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
64 },
65 .probe = test_probe,
66};
67
68static struct platform_driver sync_driver = {
69 .driver = {
70 .name = "test_sync_driver",
71 .probe_type = PROBE_FORCE_SYNCHRONOUS,
72 },
73 .probe = test_probe,
74};
75
76static struct platform_device *async_dev[NR_CPUS * 2];
77static struct platform_device *sync_dev[2];
78
79static struct platform_device *
80test_platform_device_register_node(char *name, int id, int nid)
81{
82 struct platform_device *pdev;
83 int ret;
84
85 pdev = platform_device_alloc(name, id);
86 if (!pdev)
87 return NULL;
88
89 if (nid != NUMA_NO_NODE)
90 set_dev_node(&pdev->dev, nid);
91
92 ret = platform_device_add(pdev);
93 if (ret) {
94 platform_device_put(pdev);
95 return ERR_PTR(ret);
96 }
97
98 return pdev;
99
100}
101
102static int __init test_async_probe_init(void)
103{
104 struct platform_device **pdev = NULL;
105 int async_id = 0, sync_id = 0;
106 unsigned long long duration;
107 ktime_t calltime, delta;
108 int err, nid, cpu;
109
110 pr_info("registering first set of asynchronous devices...\n");
111
112 for_each_online_cpu(cpu) {
113 nid = cpu_to_node(cpu);
114 pdev = &async_dev[async_id];
115 *pdev = test_platform_device_register_node("test_async_driver",
116 async_id,
117 nid);
118 if (IS_ERR(*pdev)) {
119 err = PTR_ERR(*pdev);
120 *pdev = NULL;
121 pr_err("failed to create async_dev: %d\n", err);
122 goto err_unregister_async_devs;
123 }
124
125 async_id++;
126 }
127
128 pr_info("registering asynchronous driver...\n");
129 calltime = ktime_get();
130 err = platform_driver_register(&async_driver);
131 if (err) {
132 pr_err("Failed to register async_driver: %d\n", err);
133 goto err_unregister_async_devs;
134 }
135
136 delta = ktime_sub(ktime_get(), calltime);
137 duration = (unsigned long long) ktime_to_ms(delta);
138 pr_info("registration took %lld msecs\n", duration);
139 if (duration > TEST_PROBE_THRESHOLD) {
140 pr_err("test failed: probe took too long\n");
141 err = -ETIMEDOUT;
142 goto err_unregister_async_driver;
143 }
144
145 pr_info("registering second set of asynchronous devices...\n");
146 calltime = ktime_get();
147 for_each_online_cpu(cpu) {
148 nid = cpu_to_node(cpu);
149 pdev = &sync_dev[sync_id];
150
151 *pdev = test_platform_device_register_node("test_async_driver",
152 async_id,
153 nid);
154 if (IS_ERR(*pdev)) {
155 err = PTR_ERR(*pdev);
156 *pdev = NULL;
157 pr_err("failed to create async_dev: %d\n", err);
158 goto err_unregister_async_driver;
159 }
160
161 async_id++;
162 }
163
164 delta = ktime_sub(ktime_get(), calltime);
165 duration = (unsigned long long) ktime_to_ms(delta);
166 dev_info(&(*pdev)->dev,
167 "registration took %lld msecs\n", duration);
168 if (duration > TEST_PROBE_THRESHOLD) {
169 dev_err(&(*pdev)->dev,
170 "test failed: probe took too long\n");
171 err = -ETIMEDOUT;
172 goto err_unregister_async_driver;
173 }
174
175
176 pr_info("registering first synchronous device...\n");
177 nid = cpu_to_node(cpu);
178 pdev = &sync_dev[sync_id];
179
180 *pdev = test_platform_device_register_node("test_sync_driver",
181 sync_id,
182 NUMA_NO_NODE);
183 if (IS_ERR(*pdev)) {
184 err = PTR_ERR(*pdev);
185 *pdev = NULL;
186 pr_err("failed to create sync_dev: %d\n", err);
187 goto err_unregister_async_driver;
188 }
189
190 sync_id++;
191
192 pr_info("registering synchronous driver...\n");
193 calltime = ktime_get();
194 err = platform_driver_register(&sync_driver);
195 if (err) {
196 pr_err("Failed to register async_driver: %d\n", err);
197 goto err_unregister_sync_devs;
198 }
199
200 delta = ktime_sub(ktime_get(), calltime);
201 duration = (unsigned long long) ktime_to_ms(delta);
202 pr_info("registration took %lld msecs\n", duration);
203 if (duration < TEST_PROBE_THRESHOLD) {
204 dev_err(&(*pdev)->dev,
205 "test failed: probe was too quick\n");
206 err = -ETIMEDOUT;
207 goto err_unregister_sync_driver;
208 }
209
210 pr_info("registering second synchronous device...\n");
211 pdev = &sync_dev[sync_id];
212 calltime = ktime_get();
213
214 *pdev = test_platform_device_register_node("test_sync_driver",
215 sync_id,
216 NUMA_NO_NODE);
217 if (IS_ERR(*pdev)) {
218 err = PTR_ERR(*pdev);
219 *pdev = NULL;
220 pr_err("failed to create sync_dev: %d\n", err);
221 goto err_unregister_sync_driver;
222 }
223
224 sync_id++;
225
226 delta = ktime_sub(ktime_get(), calltime);
227 duration = (unsigned long long) ktime_to_ms(delta);
228 dev_info(&(*pdev)->dev,
229 "registration took %lld msecs\n", duration);
230 if (duration < TEST_PROBE_THRESHOLD) {
231 dev_err(&(*pdev)->dev,
232 "test failed: probe was too quick\n");
233 err = -ETIMEDOUT;
234 goto err_unregister_sync_driver;
235 }
236
237 /*
238 * The async events should have completed while we were taking care
239 * of the synchronous events. We will now terminate any outstanding
240 * asynchronous probe calls remaining by forcing timeout and remove
241 * the driver before we return which should force the flush of the
242 * pending asynchronous probe calls.
243 *
244 * Otherwise if they completed without errors or warnings then
245 * report successful completion.
246 */
247 if (atomic_read(&async_completed) != async_id) {
248 pr_err("async events still pending, forcing timeout\n");
249 atomic_inc(&timeout);
250 err = -ETIMEDOUT;
251 } else if (!atomic_read(&errors) && !atomic_read(&warnings)) {
252 pr_info("completed successfully\n");
253 return 0;
254 }
255
256err_unregister_sync_driver:
257 platform_driver_unregister(&sync_driver);
258err_unregister_sync_devs:
259 while (sync_id--)
260 platform_device_unregister(sync_dev[sync_id]);
261err_unregister_async_driver:
262 platform_driver_unregister(&async_driver);
263err_unregister_async_devs:
264 while (async_id--)
265 platform_device_unregister(async_dev[async_id]);
266
267 /*
268 * If err is already set then count that as an additional error for
269 * the test. Otherwise we will report an invalid argument error and
270 * not count that as we should have reached here as a result of
271 * errors or warnings being reported by the probe routine.
272 */
273 if (err)
274 atomic_inc(&errors);
275 else
276 err = -EINVAL;
277
278 pr_err("Test failed with %d errors and %d warnings\n",
279 atomic_read(&errors), atomic_read(&warnings));
280
281 return err;
282}
283module_init(test_async_probe_init);
284
285static void __exit test_async_probe_exit(void)
286{
287 int id = 2;
288
289 platform_driver_unregister(&async_driver);
290 platform_driver_unregister(&sync_driver);
291
292 while (id--)
293 platform_device_unregister(sync_dev[id]);
294
295 id = NR_CPUS * 2;
296 while (id--)
297 platform_device_unregister(async_dev[id]);
298}
299module_exit(test_async_probe_exit);
300
301MODULE_DESCRIPTION("Test module for asynchronous driver probing");
302MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
303MODULE_LICENSE("GPL");
1/*
2 * Copyright (C) 2014 Google, Inc.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
13
14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16#include <linux/delay.h>
17#include <linux/init.h>
18#include <linux/hrtimer.h>
19#include <linux/module.h>
20#include <linux/platform_device.h>
21#include <linux/time.h>
22
23#define TEST_PROBE_DELAY (5 * 1000) /* 5 sec */
24#define TEST_PROBE_THRESHOLD (TEST_PROBE_DELAY / 2)
25
26static int test_probe(struct platform_device *pdev)
27{
28 dev_info(&pdev->dev, "sleeping for %d msecs in probe\n",
29 TEST_PROBE_DELAY);
30 msleep(TEST_PROBE_DELAY);
31 dev_info(&pdev->dev, "done sleeping\n");
32
33 return 0;
34}
35
36static struct platform_driver async_driver = {
37 .driver = {
38 .name = "test_async_driver",
39 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
40 },
41 .probe = test_probe,
42};
43
44static struct platform_driver sync_driver = {
45 .driver = {
46 .name = "test_sync_driver",
47 .probe_type = PROBE_FORCE_SYNCHRONOUS,
48 },
49 .probe = test_probe,
50};
51
52static struct platform_device *async_dev_1, *async_dev_2;
53static struct platform_device *sync_dev_1;
54
55static int __init test_async_probe_init(void)
56{
57 ktime_t calltime, delta;
58 unsigned long long duration;
59 int error;
60
61 pr_info("registering first asynchronous device...\n");
62
63 async_dev_1 = platform_device_register_simple("test_async_driver", 1,
64 NULL, 0);
65 if (IS_ERR(async_dev_1)) {
66 error = PTR_ERR(async_dev_1);
67 pr_err("failed to create async_dev_1: %d", error);
68 return error;
69 }
70
71 pr_info("registering asynchronous driver...\n");
72 calltime = ktime_get();
73 error = platform_driver_register(&async_driver);
74 if (error) {
75 pr_err("Failed to register async_driver: %d\n", error);
76 goto err_unregister_async_dev_1;
77 }
78
79 delta = ktime_sub(ktime_get(), calltime);
80 duration = (unsigned long long) ktime_to_ms(delta);
81 pr_info("registration took %lld msecs\n", duration);
82 if (duration > TEST_PROBE_THRESHOLD) {
83 pr_err("test failed: probe took too long\n");
84 error = -ETIMEDOUT;
85 goto err_unregister_async_driver;
86 }
87
88 pr_info("registering second asynchronous device...\n");
89 calltime = ktime_get();
90 async_dev_2 = platform_device_register_simple("test_async_driver", 2,
91 NULL, 0);
92 if (IS_ERR(async_dev_2)) {
93 error = PTR_ERR(async_dev_2);
94 pr_err("failed to create async_dev_2: %d", error);
95 goto err_unregister_async_driver;
96 }
97
98 delta = ktime_sub(ktime_get(), calltime);
99 duration = (unsigned long long) ktime_to_ms(delta);
100 pr_info("registration took %lld msecs\n", duration);
101 if (duration > TEST_PROBE_THRESHOLD) {
102 pr_err("test failed: probe took too long\n");
103 error = -ETIMEDOUT;
104 goto err_unregister_async_dev_2;
105 }
106
107 pr_info("registering synchronous driver...\n");
108
109 error = platform_driver_register(&sync_driver);
110 if (error) {
111 pr_err("Failed to register async_driver: %d\n", error);
112 goto err_unregister_async_dev_2;
113 }
114
115 pr_info("registering synchronous device...\n");
116 calltime = ktime_get();
117 sync_dev_1 = platform_device_register_simple("test_sync_driver", 1,
118 NULL, 0);
119 if (IS_ERR(sync_dev_1)) {
120 error = PTR_ERR(sync_dev_1);
121 pr_err("failed to create sync_dev_1: %d", error);
122 goto err_unregister_sync_driver;
123 }
124
125 delta = ktime_sub(ktime_get(), calltime);
126 duration = (unsigned long long) ktime_to_ms(delta);
127 pr_info("registration took %lld msecs\n", duration);
128 if (duration < TEST_PROBE_THRESHOLD) {
129 pr_err("test failed: probe was too quick\n");
130 error = -ETIMEDOUT;
131 goto err_unregister_sync_dev_1;
132 }
133
134 pr_info("completed successfully");
135
136 return 0;
137
138err_unregister_sync_dev_1:
139 platform_device_unregister(sync_dev_1);
140
141err_unregister_sync_driver:
142 platform_driver_unregister(&sync_driver);
143
144err_unregister_async_dev_2:
145 platform_device_unregister(async_dev_2);
146
147err_unregister_async_driver:
148 platform_driver_unregister(&async_driver);
149
150err_unregister_async_dev_1:
151 platform_device_unregister(async_dev_1);
152
153 return error;
154}
155module_init(test_async_probe_init);
156
157static void __exit test_async_probe_exit(void)
158{
159 platform_driver_unregister(&async_driver);
160 platform_driver_unregister(&sync_driver);
161 platform_device_unregister(async_dev_1);
162 platform_device_unregister(async_dev_2);
163 platform_device_unregister(sync_dev_1);
164}
165module_exit(test_async_probe_exit);
166
167MODULE_DESCRIPTION("Test module for asynchronous driver probing");
168MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
169MODULE_LICENSE("GPL");