drivers/base/test/test_async_driver_probe.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Copyright (C) 2014 Google, Inc.
  */

 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/hrtimer.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/time.h>
 #include <linux/numa.h>
 #include <linux/nodemask.h>
 #include <linux/topology.h>

 #define TEST_PROBE_DELAY	(5 * 1000)	/* 5 sec */
 #define TEST_PROBE_THRESHOLD	(TEST_PROBE_DELAY / 2)

 static atomic_t warnings, errors, timeout, async_completed;

 static int test_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;

 	/*
 	 * Determine if we have hit the "timeout" limit for the test if we
 	 * have then report it as an error, otherwise we wil sleep for the
 	 * required amount of time and then report completion.
 	 */
 	if (atomic_read(&timeout)) {
 		dev_err(dev, "async probe took too long\n");
 		atomic_inc(&errors);
 	} else {
 		dev_dbg(&pdev->dev, "sleeping for %d msecs in probe\n",
 			 TEST_PROBE_DELAY);
 		msleep(TEST_PROBE_DELAY);
 		dev_dbg(&pdev->dev, "done sleeping\n");
 	}

 	/*
 	 * Report NUMA mismatch if device node is set and we are not
 	 * performing an async init on that node.
 	 */
 	if (dev->driver->probe_type == PROBE_PREFER_ASYNCHRONOUS) {
 		if (IS_ENABLED(CONFIG_NUMA) &&
 		    dev_to_node(dev) != numa_node_id()) {
 			dev_warn(dev, "NUMA node mismatch %d != %d\n",
 				 dev_to_node(dev), numa_node_id());
 			atomic_inc(&warnings);
 		}

 		atomic_inc(&async_completed);
 	}

 	return 0;
 }

 static struct platform_driver async_driver = {
 	.driver = {
 		.name = "test_async_driver",
 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
 	},
 	.probe = test_probe,
 };

 static struct platform_driver sync_driver = {
 	.driver = {
 		.name = "test_sync_driver",
 		.probe_type = PROBE_FORCE_SYNCHRONOUS,
 	},
 	.probe = test_probe,
 };

 static struct platform_device *async_dev[NR_CPUS * 2];
 static struct platform_device *sync_dev[2];

 static struct platform_device *
 test_platform_device_register_node(char *name, int id, int nid)
 {
 	struct platform_device *pdev;
 	int ret;

 	pdev = platform_device_alloc(name, id);
 	if (!pdev)
 		return ERR_PTR(-ENOMEM);

 	if (nid != NUMA_NO_NODE)
 		set_dev_node(&pdev->dev, nid);

 	ret = platform_device_add(pdev);
 	if (ret) {
 		platform_device_put(pdev);
 		return ERR_PTR(ret);
 	}

 	return pdev;

 }

 static int __init test_async_probe_init(void)
 {
 	struct platform_device **pdev = NULL;
 	int async_id = 0, sync_id = 0;
 	unsigned long long duration;
 	ktime_t calltime;
 	int err, nid, cpu;

 	pr_info("registering first set of asynchronous devices...\n");

 	for_each_online_cpu(cpu) {
 		nid = cpu_to_node(cpu);
 		pdev = &async_dev[async_id];
 		*pdev =	test_platform_device_register_node("test_async_driver",
 							   async_id,
 							   nid);
 		if (IS_ERR(*pdev)) {
 			err = PTR_ERR(*pdev);
 			*pdev = NULL;
 			pr_err("failed to create async_dev: %d\n", err);
 			goto err_unregister_async_devs;
 		}

 		async_id++;
 	}

 	pr_info("registering asynchronous driver...\n");
 	calltime = ktime_get();
 	err = platform_driver_register(&async_driver);
 	if (err) {
 		pr_err("Failed to register async_driver: %d\n", err);
 		goto err_unregister_async_devs;
 	}

 	duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
 	pr_info("registration took %lld msecs\n", duration);
 	if (duration > TEST_PROBE_THRESHOLD) {
 		pr_err("test failed: probe took too long\n");
 		err = -ETIMEDOUT;
 		goto err_unregister_async_driver;
 	}

 	pr_info("registering second set of asynchronous devices...\n");
 	calltime = ktime_get();
 	for_each_online_cpu(cpu) {
 		nid = cpu_to_node(cpu);
 		pdev = &async_dev[async_id];

 		*pdev = test_platform_device_register_node("test_async_driver",
 							   async_id,
 							   nid);
 		if (IS_ERR(*pdev)) {
 			err = PTR_ERR(*pdev);
 			*pdev = NULL;
 			pr_err("failed to create async_dev: %d\n", err);
 			goto err_unregister_async_driver;
 		}

 		async_id++;
 	}

 	duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
 	dev_info(&(*pdev)->dev,
 		 "registration took %lld msecs\n", duration);
 	if (duration > TEST_PROBE_THRESHOLD) {
 		dev_err(&(*pdev)->dev,
 			"test failed: probe took too long\n");
 		err = -ETIMEDOUT;
 		goto err_unregister_async_driver;
 	}


 	pr_info("registering first synchronous device...\n");
 	nid = cpu_to_node(cpu);
 	pdev = &sync_dev[sync_id];

 	*pdev = test_platform_device_register_node("test_sync_driver",
 						   sync_id,
 						   NUMA_NO_NODE);
 	if (IS_ERR(*pdev)) {
 		err = PTR_ERR(*pdev);
 		*pdev = NULL;
 		pr_err("failed to create sync_dev: %d\n", err);
 		goto err_unregister_async_driver;
 	}

 	sync_id++;

 	pr_info("registering synchronous driver...\n");
 	calltime = ktime_get();
 	err = platform_driver_register(&sync_driver);
 	if (err) {
 		pr_err("Failed to register async_driver: %d\n", err);
 		goto err_unregister_sync_devs;
 	}

 	duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
 	pr_info("registration took %lld msecs\n", duration);
 	if (duration < TEST_PROBE_THRESHOLD) {
 		dev_err(&(*pdev)->dev,
 			"test failed: probe was too quick\n");
 		err = -ETIMEDOUT;
 		goto err_unregister_sync_driver;
 	}

 	pr_info("registering second synchronous device...\n");
 	pdev = &sync_dev[sync_id];
 	calltime = ktime_get();

 	*pdev = test_platform_device_register_node("test_sync_driver",
 						   sync_id,
 						   NUMA_NO_NODE);
 	if (IS_ERR(*pdev)) {
 		err = PTR_ERR(*pdev);
 		*pdev = NULL;
 		pr_err("failed to create sync_dev: %d\n", err);
 		goto err_unregister_sync_driver;
 	}

 	sync_id++;

 	duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
 	dev_info(&(*pdev)->dev,
 		 "registration took %lld msecs\n", duration);
 	if (duration < TEST_PROBE_THRESHOLD) {
 		dev_err(&(*pdev)->dev,
 			"test failed: probe was too quick\n");
 		err = -ETIMEDOUT;
 		goto err_unregister_sync_driver;
 	}

 	/*
 	 * The async events should have completed while we were taking care
 	 * of the synchronous events. We will now terminate any outstanding
 	 * asynchronous probe calls remaining by forcing timeout and remove
 	 * the driver before we return which should force the flush of the
 	 * pending asynchronous probe calls.
 	 *
 	 * Otherwise if they completed without errors or warnings then
 	 * report successful completion.
 	 */
 	if (atomic_read(&async_completed) != async_id) {
 		pr_err("async events still pending, forcing timeout\n");
 		atomic_inc(&timeout);
 		err = -ETIMEDOUT;
 	} else if (!atomic_read(&errors) && !atomic_read(&warnings)) {
 		pr_info("completed successfully\n");
 		return 0;
 	}

 err_unregister_sync_driver:
 	platform_driver_unregister(&sync_driver);
 err_unregister_sync_devs:
 	while (sync_id--)
 		platform_device_unregister(sync_dev[sync_id]);
 err_unregister_async_driver:
 	platform_driver_unregister(&async_driver);
 err_unregister_async_devs:
 	while (async_id--)
 		platform_device_unregister(async_dev[async_id]);

 	/*
 	 * If err is already set then count that as an additional error for
 	 * the test. Otherwise we will report an invalid argument error and
 	 * not count that as we should have reached here as a result of
 	 * errors or warnings being reported by the probe routine.
 	 */
 	if (err)
 		atomic_inc(&errors);
 	else
 		err = -EINVAL;

 	pr_err("Test failed with %d errors and %d warnings\n",
 	       atomic_read(&errors), atomic_read(&warnings));

 	return err;
 }
 module_init(test_async_probe_init);

 static void __exit test_async_probe_exit(void)
 {
 	int id = 2;

 	platform_driver_unregister(&async_driver);
 	platform_driver_unregister(&sync_driver);

 	while (id--)
 		platform_device_unregister(sync_dev[id]);

 	id = NR_CPUS * 2;
 	while (id--)
 		platform_device_unregister(async_dev[id]);
 }
 module_exit(test_async_probe_exit);

 MODULE_DESCRIPTION("Test module for asynchronous driver probing");
 MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
 MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Copyright (C) 2014 Google, Inc.
	*/

	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

	#include <linux/delay.h>
	#include <linux/init.h>
	#include <linux/hrtimer.h>
	#include <linux/module.h>
	#include <linux/platform_device.h>
	#include <linux/time.h>
	#include <linux/numa.h>
	#include <linux/nodemask.h>
	#include <linux/topology.h>

	#define TEST_PROBE_DELAY (5 * 1000) /* 5 sec */
	#define TEST_PROBE_THRESHOLD (TEST_PROBE_DELAY / 2)

	static atomic_t warnings, errors, timeout, async_completed;

	static int test_probe(struct platform_device *pdev)
	{
	struct device *dev = &pdev->dev;

	/*
	* Determine if we have hit the "timeout" limit for the test if we
	* have then report it as an error, otherwise we wil sleep for the
	* required amount of time and then report completion.
	*/
	if (atomic_read(&timeout)) {
	dev_err(dev, "async probe took too long\n");
	atomic_inc(&errors);
	} else {
	dev_dbg(&pdev->dev, "sleeping for %d msecs in probe\n",
	TEST_PROBE_DELAY);
	msleep(TEST_PROBE_DELAY);
	dev_dbg(&pdev->dev, "done sleeping\n");
	}

	/*
	* Report NUMA mismatch if device node is set and we are not
	* performing an async init on that node.
	*/
	if (dev->driver->probe_type == PROBE_PREFER_ASYNCHRONOUS) {
	if (IS_ENABLED(CONFIG_NUMA) &&
	dev_to_node(dev) != numa_node_id()) {
	dev_warn(dev, "NUMA node mismatch %d != %d\n",
	dev_to_node(dev), numa_node_id());
	atomic_inc(&warnings);
	}

	atomic_inc(&async_completed);
	}

	return 0;
	}

	static struct platform_driver async_driver = {
	.driver = {
	.name = "test_async_driver",
	.probe_type = PROBE_PREFER_ASYNCHRONOUS,
	},
	.probe = test_probe,
	};

	static struct platform_driver sync_driver = {
	.driver = {
	.name = "test_sync_driver",
	.probe_type = PROBE_FORCE_SYNCHRONOUS,
	},
	.probe = test_probe,
	};

	static struct platform_device async_dev[NR_CPUS 2];
	static struct platform_device *sync_dev[2];

	static struct platform_device *
	test_platform_device_register_node(char *name, int id, int nid)
	{
	struct platform_device *pdev;
	int ret;

	pdev = platform_device_alloc(name, id);
	if (!pdev)
	return ERR_PTR(-ENOMEM);

	if (nid != NUMA_NO_NODE)
	set_dev_node(&pdev->dev, nid);

	ret = platform_device_add(pdev);
	if (ret) {
	platform_device_put(pdev);
	return ERR_PTR(ret);
	}

	return pdev;

	}

	static int __init test_async_probe_init(void)
	{
	struct platform_device **pdev = NULL;
	int async_id = 0, sync_id = 0;
	unsigned long long duration;
	ktime_t calltime;
	int err, nid, cpu;

	pr_info("registering first set of asynchronous devices...\n");

	for_each_online_cpu(cpu) {
	nid = cpu_to_node(cpu);
	pdev = &async_dev[async_id];
	*pdev = test_platform_device_register_node("test_async_driver",
	async_id,
	nid);
	if (IS_ERR(*pdev)) {
	err = PTR_ERR(*pdev);
	*pdev = NULL;
	pr_err("failed to create async_dev: %d\n", err);
	goto err_unregister_async_devs;
	}

	async_id++;
	}

	pr_info("registering asynchronous driver...\n");
	calltime = ktime_get();
	err = platform_driver_register(&async_driver);
	if (err) {
	pr_err("Failed to register async_driver: %d\n", err);
	goto err_unregister_async_devs;
	}

	duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
	pr_info("registration took %lld msecs\n", duration);
	if (duration > TEST_PROBE_THRESHOLD) {
	pr_err("test failed: probe took too long\n");
	err = -ETIMEDOUT;
	goto err_unregister_async_driver;
	}

	pr_info("registering second set of asynchronous devices...\n");
	calltime = ktime_get();
	for_each_online_cpu(cpu) {
	nid = cpu_to_node(cpu);
	pdev = &async_dev[async_id];

	*pdev = test_platform_device_register_node("test_async_driver",
	async_id,
	nid);
	if (IS_ERR(*pdev)) {
	err = PTR_ERR(*pdev);
	*pdev = NULL;
	pr_err("failed to create async_dev: %d\n", err);
	goto err_unregister_async_driver;
	}

	async_id++;
	}

	duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
	dev_info(&(*pdev)->dev,
	"registration took %lld msecs\n", duration);
	if (duration > TEST_PROBE_THRESHOLD) {
	dev_err(&(*pdev)->dev,
	"test failed: probe took too long\n");
	err = -ETIMEDOUT;
	goto err_unregister_async_driver;
	}


	pr_info("registering first synchronous device...\n");
	nid = cpu_to_node(cpu);
	pdev = &sync_dev[sync_id];

	*pdev = test_platform_device_register_node("test_sync_driver",
	sync_id,
	NUMA_NO_NODE);
	if (IS_ERR(*pdev)) {
	err = PTR_ERR(*pdev);
	*pdev = NULL;
	pr_err("failed to create sync_dev: %d\n", err);
	goto err_unregister_async_driver;
	}

	sync_id++;

	pr_info("registering synchronous driver...\n");
	calltime = ktime_get();
	err = platform_driver_register(&sync_driver);
	if (err) {
	pr_err("Failed to register async_driver: %d\n", err);
	goto err_unregister_sync_devs;
	}

	duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
	pr_info("registration took %lld msecs\n", duration);
	if (duration < TEST_PROBE_THRESHOLD) {
	dev_err(&(*pdev)->dev,
	"test failed: probe was too quick\n");
	err = -ETIMEDOUT;
	goto err_unregister_sync_driver;
	}

	pr_info("registering second synchronous device...\n");
	pdev = &sync_dev[sync_id];
	calltime = ktime_get();

	*pdev = test_platform_device_register_node("test_sync_driver",
	sync_id,
	NUMA_NO_NODE);
	if (IS_ERR(*pdev)) {
	err = PTR_ERR(*pdev);
	*pdev = NULL;
	pr_err("failed to create sync_dev: %d\n", err);
	goto err_unregister_sync_driver;
	}

	sync_id++;

	duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
	dev_info(&(*pdev)->dev,
	"registration took %lld msecs\n", duration);
	if (duration < TEST_PROBE_THRESHOLD) {
	dev_err(&(*pdev)->dev,
	"test failed: probe was too quick\n");
	err = -ETIMEDOUT;
	goto err_unregister_sync_driver;
	}

	/*
	* The async events should have completed while we were taking care
	* of the synchronous events. We will now terminate any outstanding
	* asynchronous probe calls remaining by forcing timeout and remove
	* the driver before we return which should force the flush of the
	* pending asynchronous probe calls.
	*
	* Otherwise if they completed without errors or warnings then
	* report successful completion.
	*/
	if (atomic_read(&async_completed) != async_id) {
	pr_err("async events still pending, forcing timeout\n");
	atomic_inc(&timeout);
	err = -ETIMEDOUT;
	} else if (!atomic_read(&errors) && !atomic_read(&warnings)) {
	pr_info("completed successfully\n");
	return 0;
	}

	err_unregister_sync_driver:
	platform_driver_unregister(&sync_driver);
	err_unregister_sync_devs:
	while (sync_id--)
	platform_device_unregister(sync_dev[sync_id]);
	err_unregister_async_driver:
	platform_driver_unregister(&async_driver);
	err_unregister_async_devs:
	while (async_id--)
	platform_device_unregister(async_dev[async_id]);

	/*
	* If err is already set then count that as an additional error for
	* the test. Otherwise we will report an invalid argument error and
	* not count that as we should have reached here as a result of
	* errors or warnings being reported by the probe routine.
	*/
	if (err)
	atomic_inc(&errors);
	else
	err = -EINVAL;

	pr_err("Test failed with %d errors and %d warnings\n",
	atomic_read(&errors), atomic_read(&warnings));

	return err;
	}
	module_init(test_async_probe_init);

	static void __exit test_async_probe_exit(void)
	{
	int id = 2;

	platform_driver_unregister(&async_driver);
	platform_driver_unregister(&sync_driver);

	while (id--)
	platform_device_unregister(sync_dev[id]);

	id = NR_CPUS * 2;
	while (id--)
	platform_device_unregister(async_dev[id]);
	}
	module_exit(test_async_probe_exit);

	MODULE_DESCRIPTION("Test module for asynchronous driver probing");
	MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
	MODULE_LICENSE("GPL");