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 
21 static atomic_t warnings, errors, timeout, async_completed;
22 
23 static 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 (dev_to_node(dev) != numa_node_id()) {
48 			dev_warn(dev, "NUMA node mismatch %d != %d\n",
49 				 dev_to_node(dev), numa_node_id());
50 			atomic_inc(&warnings);
51 		}
52 
53 		atomic_inc(&async_completed);
54 	}
55 
56 	return 0;
57 }
58 
59 static struct platform_driver async_driver = {
60 	.driver = {
61 		.name = "test_async_driver",
62 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
63 	},
64 	.probe = test_probe,
65 };
66 
67 static struct platform_driver sync_driver = {
68 	.driver = {
69 		.name = "test_sync_driver",
70 		.probe_type = PROBE_FORCE_SYNCHRONOUS,
71 	},
72 	.probe = test_probe,
73 };
74 
75 static struct platform_device *async_dev[NR_CPUS * 2];
76 static struct platform_device *sync_dev[2];
77 
78 static struct platform_device *
79 test_platform_device_register_node(char *name, int id, int nid)
80 {
81 	struct platform_device *pdev;
82 	int ret;
83 
84 	pdev = platform_device_alloc(name, id);
85 	if (!pdev)
86 		return NULL;
87 
88 	if (nid != NUMA_NO_NODE)
89 		set_dev_node(&pdev->dev, nid);
90 
91 	ret = platform_device_add(pdev);
92 	if (ret) {
93 		platform_device_put(pdev);
94 		return ERR_PTR(ret);
95 	}
96 
97 	return pdev;
98 
99 }
100 
101 static int __init test_async_probe_init(void)
102 {
103 	struct platform_device **pdev = NULL;
104 	int async_id = 0, sync_id = 0;
105 	unsigned long long duration;
106 	ktime_t calltime, delta;
107 	int err, nid, cpu;
108 
109 	pr_info("registering first set of asynchronous devices...\n");
110 
111 	for_each_online_cpu(cpu) {
112 		nid = cpu_to_node(cpu);
113 		pdev = &async_dev[async_id];
114 		*pdev =	test_platform_device_register_node("test_async_driver",
115 							   async_id,
116 							   nid);
117 		if (IS_ERR(*pdev)) {
118 			err = PTR_ERR(*pdev);
119 			*pdev = NULL;
120 			pr_err("failed to create async_dev: %d\n", err);
121 			goto err_unregister_async_devs;
122 		}
123 
124 		async_id++;
125 	}
126 
127 	pr_info("registering asynchronous driver...\n");
128 	calltime = ktime_get();
129 	err = platform_driver_register(&async_driver);
130 	if (err) {
131 		pr_err("Failed to register async_driver: %d\n", err);
132 		goto err_unregister_async_devs;
133 	}
134 
135 	delta = ktime_sub(ktime_get(), calltime);
136 	duration = (unsigned long long) ktime_to_ms(delta);
137 	pr_info("registration took %lld msecs\n", duration);
138 	if (duration > TEST_PROBE_THRESHOLD) {
139 		pr_err("test failed: probe took too long\n");
140 		err = -ETIMEDOUT;
141 		goto err_unregister_async_driver;
142 	}
143 
144 	pr_info("registering second set of asynchronous devices...\n");
145 	calltime = ktime_get();
146 	for_each_online_cpu(cpu) {
147 		nid = cpu_to_node(cpu);
148 		pdev = &sync_dev[sync_id];
149 
150 		*pdev = test_platform_device_register_node("test_async_driver",
151 							   async_id,
152 							   nid);
153 		if (IS_ERR(*pdev)) {
154 			err = PTR_ERR(*pdev);
155 			*pdev = NULL;
156 			pr_err("failed to create async_dev: %d\n", err);
157 			goto err_unregister_async_driver;
158 		}
159 
160 		async_id++;
161 	}
162 
163 	delta = ktime_sub(ktime_get(), calltime);
164 	duration = (unsigned long long) ktime_to_ms(delta);
165 	dev_info(&(*pdev)->dev,
166 		 "registration took %lld msecs\n", duration);
167 	if (duration > TEST_PROBE_THRESHOLD) {
168 		dev_err(&(*pdev)->dev,
169 			"test failed: probe took too long\n");
170 		err = -ETIMEDOUT;
171 		goto err_unregister_async_driver;
172 	}
173 
174 
175 	pr_info("registering first synchronous device...\n");
176 	nid = cpu_to_node(cpu);
177 	pdev = &sync_dev[sync_id];
178 
179 	*pdev = test_platform_device_register_node("test_sync_driver",
180 						   sync_id,
181 						   NUMA_NO_NODE);
182 	if (IS_ERR(*pdev)) {
183 		err = PTR_ERR(*pdev);
184 		*pdev = NULL;
185 		pr_err("failed to create sync_dev: %d\n", err);
186 		goto err_unregister_async_driver;
187 	}
188 
189 	sync_id++;
190 
191 	pr_info("registering synchronous driver...\n");
192 	calltime = ktime_get();
193 	err = platform_driver_register(&sync_driver);
194 	if (err) {
195 		pr_err("Failed to register async_driver: %d\n", err);
196 		goto err_unregister_sync_devs;
197 	}
198 
199 	delta = ktime_sub(ktime_get(), calltime);
200 	duration = (unsigned long long) ktime_to_ms(delta);
201 	pr_info("registration took %lld msecs\n", duration);
202 	if (duration < TEST_PROBE_THRESHOLD) {
203 		dev_err(&(*pdev)->dev,
204 			"test failed: probe was too quick\n");
205 		err = -ETIMEDOUT;
206 		goto err_unregister_sync_driver;
207 	}
208 
209 	pr_info("registering second synchronous device...\n");
210 	pdev = &sync_dev[sync_id];
211 	calltime = ktime_get();
212 
213 	*pdev = test_platform_device_register_node("test_sync_driver",
214 						   sync_id,
215 						   NUMA_NO_NODE);
216 	if (IS_ERR(*pdev)) {
217 		err = PTR_ERR(*pdev);
218 		*pdev = NULL;
219 		pr_err("failed to create sync_dev: %d\n", err);
220 		goto err_unregister_sync_driver;
221 	}
222 
223 	sync_id++;
224 
225 	delta = ktime_sub(ktime_get(), calltime);
226 	duration = (unsigned long long) ktime_to_ms(delta);
227 	dev_info(&(*pdev)->dev,
228 		 "registration took %lld msecs\n", duration);
229 	if (duration < TEST_PROBE_THRESHOLD) {
230 		dev_err(&(*pdev)->dev,
231 			"test failed: probe was too quick\n");
232 		err = -ETIMEDOUT;
233 		goto err_unregister_sync_driver;
234 	}
235 
236 	/*
237 	 * The async events should have completed while we were taking care
238 	 * of the synchronous events. We will now terminate any outstanding
239 	 * asynchronous probe calls remaining by forcing timeout and remove
240 	 * the driver before we return which should force the flush of the
241 	 * pending asynchronous probe calls.
242 	 *
243 	 * Otherwise if they completed without errors or warnings then
244 	 * report successful completion.
245 	 */
246 	if (atomic_read(&async_completed) != async_id) {
247 		pr_err("async events still pending, forcing timeout\n");
248 		atomic_inc(&timeout);
249 		err = -ETIMEDOUT;
250 	} else if (!atomic_read(&errors) && !atomic_read(&warnings)) {
251 		pr_info("completed successfully\n");
252 		return 0;
253 	}
254 
255 err_unregister_sync_driver:
256 	platform_driver_unregister(&sync_driver);
257 err_unregister_sync_devs:
258 	while (sync_id--)
259 		platform_device_unregister(sync_dev[sync_id]);
260 err_unregister_async_driver:
261 	platform_driver_unregister(&async_driver);
262 err_unregister_async_devs:
263 	while (async_id--)
264 		platform_device_unregister(async_dev[async_id]);
265 
266 	/*
267 	 * If err is already set then count that as an additional error for
268 	 * the test. Otherwise we will report an invalid argument error and
269 	 * not count that as we should have reached here as a result of
270 	 * errors or warnings being reported by the probe routine.
271 	 */
272 	if (err)
273 		atomic_inc(&errors);
274 	else
275 		err = -EINVAL;
276 
277 	pr_err("Test failed with %d errors and %d warnings\n",
278 	       atomic_read(&errors), atomic_read(&warnings));
279 
280 	return err;
281 }
282 module_init(test_async_probe_init);
283 
284 static void __exit test_async_probe_exit(void)
285 {
286 	int id = 2;
287 
288 	platform_driver_unregister(&async_driver);
289 	platform_driver_unregister(&sync_driver);
290 
291 	while (id--)
292 		platform_device_unregister(sync_dev[id]);
293 
294 	id = NR_CPUS * 2;
295 	while (id--)
296 		platform_device_unregister(async_dev[id]);
297 }
298 module_exit(test_async_probe_exit);
299 
300 MODULE_DESCRIPTION("Test module for asynchronous driver probing");
301 MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
302 MODULE_LICENSE("GPL");
303