drivers/base/test/test_async_driver_probe.c

   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");