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 (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 60 static 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 68 static 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 76 static struct platform_device *async_dev[NR_CPUS * 2]; 77 static struct platform_device *sync_dev[2]; 78 79 static struct platform_device * 80 test_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 102 static 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 256 err_unregister_sync_driver: 257 platform_driver_unregister(&sync_driver); 258 err_unregister_sync_devs: 259 while (sync_id--) 260 platform_device_unregister(sync_dev[sync_id]); 261 err_unregister_async_driver: 262 platform_driver_unregister(&async_driver); 263 err_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 } 283 module_init(test_async_probe_init); 284 285 static 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 } 299 module_exit(test_async_probe_exit); 300 301 MODULE_DESCRIPTION("Test module for asynchronous driver probing"); 302 MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>"); 303 MODULE_LICENSE("GPL"); 304