lib/test_firmware.c

   1 /*
   2  * This module provides an interface to trigger and test firmware loading.
   3  *
   4  * It is designed to be used for basic evaluation of the firmware loading
   5  * subsystem (for example when validating firmware verification). It lacks
   6  * any extra dependencies, and will not normally be loaded by the system
   7  * unless explicitly requested by name.
   8  */
   9
  10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/printk.h>
  15 #include <linux/completion.h>
  16 #include <linux/firmware.h>
  17 #include <linux/device.h>
  18 #include <linux/fs.h>
  19 #include <linux/miscdevice.h>
  20 #include <linux/slab.h>
  21 #include <linux/uaccess.h>
  22
  23 static DEFINE_MUTEX(test_fw_mutex);
  24 static const struct firmware *test_firmware;
  25
  26 static ssize_t test_fw_misc_read(struct file *f, char __user *buf,
  27                                  size_t size, loff_t *offset)
  28 {
  29         ssize_t rc = 0;
  30
  31         mutex_lock(&test_fw_mutex);
  32         if (test_firmware)
  33                 rc = simple_read_from_buffer(buf, size, offset,
  34                                              test_firmware->data,
  35                                              test_firmware->size);
  36         mutex_unlock(&test_fw_mutex);
  37         return rc;
  38 }
  39
  40 static const struct file_operations test_fw_fops = {
  41         .owner          = THIS_MODULE,
  42         .read           = test_fw_misc_read,
  43 };
  44
  45 static ssize_t trigger_request_store(struct device *dev,
  46                                      struct device_attribute *attr,
  47                                      const char *buf, size_t count)
  48 {
  49         int rc;
  50         char *name;
  51
  52         name = kstrndup(buf, count, GFP_KERNEL);
  53         if (!name)
  54                 return -ENOSPC;
  55
  56         pr_info("loading '%s'\n", name);
  57
  58         mutex_lock(&test_fw_mutex);
  59         release_firmware(test_firmware);
  60         test_firmware = NULL;
  61         rc = request_firmware(&test_firmware, name, dev);
  62         if (rc) {
  63                 pr_info("load of '%s' failed: %d\n", name, rc);
  64                 goto out;
  65         }
  66         pr_info("loaded: %zu\n", test_firmware->size);
  67         rc = count;
  68
  69 out:
  70         mutex_unlock(&test_fw_mutex);
  71
  72         kfree(name);
  73
  74         return rc;
  75 }
  76 static DEVICE_ATTR_WO(trigger_request);
  77
  78 static DECLARE_COMPLETION(async_fw_done);
  79
  80 static void trigger_async_request_cb(const struct firmware *fw, void *context)
  81 {
  82         test_firmware = fw;
  83         complete(&async_fw_done);
  84 }
  85
  86 static ssize_t trigger_async_request_store(struct device *dev,
  87                                            struct device_attribute *attr,
  88                                            const char *buf, size_t count)
  89 {
  90         int rc;
  91         char *name;
  92
  93         name = kstrndup(buf, count, GFP_KERNEL);
  94         if (!name)
  95                 return -ENOSPC;
  96
  97         pr_info("loading '%s'\n", name);
  98
  99         mutex_lock(&test_fw_mutex);
 100         release_firmware(test_firmware);
 101         test_firmware = NULL;
 102         rc = request_firmware_nowait(THIS_MODULE, 1, name, dev, GFP_KERNEL,
 103                                      NULL, trigger_async_request_cb);
 104         if (rc) {
 105                 pr_info("async load of '%s' failed: %d\n", name, rc);
 106                 kfree(name);
 107                 goto out;
 108         }
 109         /* Free 'name' ASAP, to test for race conditions */
 110         kfree(name);
 111
 112         wait_for_completion(&async_fw_done);
 113
 114         if (test_firmware) {
 115                 pr_info("loaded: %zu\n", test_firmware->size);
 116                 rc = count;
 117         } else {
 118                 pr_err("failed to async load firmware\n");
 119                 rc = -ENODEV;
 120         }
 121
 122 out:
 123         mutex_unlock(&test_fw_mutex);
 124
 125         return rc;
 126 }
 127 static DEVICE_ATTR_WO(trigger_async_request);
 128
 129 #define TEST_FW_DEV_ATTR(name)          &dev_attr_##name.attr
 130
 131 static struct attribute *test_dev_attrs[] = {
 132         TEST_FW_DEV_ATTR(trigger_request),
 133         TEST_FW_DEV_ATTR(trigger_async_request),
 134         NULL,
 135 };
 136
 137 ATTRIBUTE_GROUPS(test_dev);
 138
 139 static struct miscdevice test_fw_misc_device = {
 140         .minor          = MISC_DYNAMIC_MINOR,
 141         .name           = "test_firmware",
 142         .fops           = &test_fw_fops,
 143         .groups         = test_dev_groups,
 144 };
 145
 146 static int __init test_firmware_init(void)
 147 {
 148         int rc;
 149
 150         rc = misc_register(&test_fw_misc_device);
 151         if (rc) {
 152                 pr_err("could not register misc device: %d\n", rc);
 153                 return rc;
 154         }
 155
 156         pr_warn("interface ready\n");
 157
 158         return 0;
 159 }
 160
 161 module_init(test_firmware_init);
 162
 163 static void __exit test_firmware_exit(void)
 164 {
 165         release_firmware(test_firmware);
 166         misc_deregister(&test_fw_misc_device);
 167         pr_warn("removed interface\n");
 168 }
 169
 170 module_exit(test_firmware_exit);
 171
 172 MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
 173 MODULE_LICENSE("GPL");