LXR linux/drivers/base/test/test_async_driver

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