/* * This module provides an interface to trigger and test firmware loading. * * It is designed to be used for basic evaluation of the firmware loading * subsystem (for example when validating firmware verification). It lacks * any extra dependencies, and will not normally be loaded by the system * unless explicitly requested by name. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/init.h>#include <linux/module.h>#include <linux/printk.h>#include <linux/completion.h>#include <linux/firmware.h>#include <linux/device.h>#include <linux/fs.h>#include <linux/miscdevice.h>#include <linux/slab.h>#include <linux/uaccess.h> static DEFINE_MUTEX(test_fw_mutex);static const struct firmware *test_firmware; static ssize_t test_fw_misc_read(struct file *f, char __user *buf,				 size_t size, loff_t *offset){	ssize_t rc = 0; 	mutex_lock(&test_fw_mutex);	if (test_firmware)		rc = simple_read_from_buffer(buf, size, offset,					     test_firmware->data,					     test_firmware->size);	mutex_unlock(&test_fw_mutex);	return rc;} static const struct file_operations test_fw_fops = {	.owner          = THIS_MODULE,	.read           = test_fw_misc_read,}; static struct miscdevice test_fw_misc_device = {	.minor          = MISC_DYNAMIC_MINOR,	.name           = "test_firmware",	.fops           = &test_fw_fops,}; static ssize_t trigger_request_store(struct device *dev,				     struct device_attribute *attr,				     const char *buf, size_t count){	int rc;	char *name; 	name = kstrndup(buf, count, GFP_KERNEL);	if (!name)		return -ENOSPC; 	pr_info("loading '%s'\n", name); 	mutex_lock(&test_fw_mutex);	release_firmware(test_firmware);	test_firmware = NULL;	rc = request_firmware(&test_firmware, name, dev);	if (rc) {		pr_info("load of '%s' failed: %d\n", name, rc);		goto out;	}	pr_info("loaded: %zu\n", test_firmware->size);	rc = count; out:	mutex_unlock(&test_fw_mutex); 	kfree(name); 	return rc;}static DEVICE_ATTR_WO(trigger_request); static DECLARE_COMPLETION(async_fw_done); static void trigger_async_request_cb(const struct firmware *fw, void *context){	test_firmware = fw;	complete(&async_fw_done);} static ssize_t trigger_async_request_store(struct device *dev,					   struct device_attribute *attr,					   const char *buf, size_t count){	int rc;	char *name; 	name = kstrndup(buf, count, GFP_KERNEL);	if (!name)		return -ENOSPC; 	pr_info("loading '%s'\n", name); 	mutex_lock(&test_fw_mutex);	release_firmware(test_firmware);	test_firmware = NULL;	rc = request_firmware_nowait(THIS_MODULE, 1, name, dev, GFP_KERNEL,				     NULL, trigger_async_request_cb);	if (rc) {		pr_info("async load of '%s' failed: %d\n", name, rc);		kfree(name);		goto out;	}	/* Free 'name' ASAP, to test for race conditions */	kfree(name); 	wait_for_completion(&async_fw_done); 	if (test_firmware) {		pr_info("loaded: %zu\n", test_firmware->size);		rc = count;	} else {		pr_err("failed to async load firmware\n");		rc = -ENODEV;	} out:	mutex_unlock(&test_fw_mutex); 	return rc;}static DEVICE_ATTR_WO(trigger_async_request); static int __init test_firmware_init(void){	int rc; 	rc = misc_register(&test_fw_misc_device);	if (rc) {		pr_err("could not register misc device: %d\n", rc);		return rc;	}	rc = device_create_file(test_fw_misc_device.this_device,				&dev_attr_trigger_request);	if (rc) {		pr_err("could not create sysfs interface: %d\n", rc);		goto dereg;	} 	rc = device_create_file(test_fw_misc_device.this_device,				&dev_attr_trigger_async_request);	if (rc) {		pr_err("could not create async sysfs interface: %d\n", rc);		goto remove_file;	} 	pr_warn("interface ready\n"); 	return 0; remove_file:	device_remove_file(test_fw_misc_device.this_device,			   &dev_attr_trigger_async_request);dereg:	misc_deregister(&test_fw_misc_device);	return rc;} module_init(test_firmware_init); static void __exit test_firmware_exit(void){	release_firmware(test_firmware);	device_remove_file(test_fw_misc_device.this_device,			   &dev_attr_trigger_async_request);	device_remove_file(test_fw_misc_device.this_device,			   &dev_attr_trigger_request);	misc_deregister(&test_fw_misc_device);	pr_warn("removed interface\n");} module_exit(test_firmware_exit); MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");MODULE_LICENSE("GPL");