base/firmware_loader/sysfs.c

0001 // SPDX-License-Identifier: GPL-2.0
0002
0003 #include <linux/highmem.h>
0004 #include <linux/module.h>
0005 #include <linux/security.h>
0006 #include <linux/slab.h>
0007 #include <linux/types.h>
0008
0009 #include "sysfs.h"
0010
0011 /*
0012  * sysfs support for firmware loader
0013  */
0014
0015 void __fw_load_abort(struct fw_priv *fw_priv)
0016 {
0017     /*
0018      * There is a small window in which user can write to 'loading'
0019      * between loading done/aborted and disappearance of 'loading'
0020      */
0021     if (fw_state_is_aborted(fw_priv) || fw_state_is_done(fw_priv))
0022         return;
0023
0024     fw_state_aborted(fw_priv);
0025 }
0026
0027 #ifdef CONFIG_FW_LOADER_USER_HELPER
0028 static ssize_t timeout_show(struct class *class, struct class_attribute *attr,
0029                 char *buf)
0030 {
0031     return sysfs_emit(buf, "%d\n", __firmware_loading_timeout());
0032 }
0033
0034 /**
0035  * timeout_store() - set number of seconds to wait for firmware
0036  * @class: device class pointer
0037  * @attr: device attribute pointer
0038  * @buf: buffer to scan for timeout value
0039  * @count: number of bytes in @buf
0040  *
0041  *  Sets the number of seconds to wait for the firmware.  Once
0042  *  this expires an error will be returned to the driver and no
0043  *  firmware will be provided.
0044  *
0045  *  Note: zero means 'wait forever'.
0046  **/
0047 static ssize_t timeout_store(struct class *class, struct class_attribute *attr,
0048                  const char *buf, size_t count)
0049 {
0050     int tmp_loading_timeout = simple_strtol(buf, NULL, 10);
0051
0052     if (tmp_loading_timeout < 0)
0053         tmp_loading_timeout = 0;
0054
0055     __fw_fallback_set_timeout(tmp_loading_timeout);
0056
0057     return count;
0058 }
0059 static CLASS_ATTR_RW(timeout);
0060
0061 static struct attribute *firmware_class_attrs[] = {
0062     &class_attr_timeout.attr,
0063     NULL,
0064 };
0065 ATTRIBUTE_GROUPS(firmware_class);
0066
0067 static int do_firmware_uevent(struct fw_sysfs *fw_sysfs, struct kobj_uevent_env *env)
0068 {
0069     if (add_uevent_var(env, "FIRMWARE=%s", fw_sysfs->fw_priv->fw_name))
0070         return -ENOMEM;
0071     if (add_uevent_var(env, "TIMEOUT=%i", __firmware_loading_timeout()))
0072         return -ENOMEM;
0073     if (add_uevent_var(env, "ASYNC=%d", fw_sysfs->nowait))
0074         return -ENOMEM;
0075
0076     return 0;
0077 }
0078
0079 static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
0080 {
0081     struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
0082     int err = 0;
0083
0084     mutex_lock(&fw_lock);
0085     if (fw_sysfs->fw_priv)
0086         err = do_firmware_uevent(fw_sysfs, env);
0087     mutex_unlock(&fw_lock);
0088     return err;
0089 }
0090 #endif /* CONFIG_FW_LOADER_USER_HELPER */
0091
0092 static void fw_dev_release(struct device *dev)
0093 {
0094     struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
0095
0096     if (fw_sysfs->fw_upload_priv)
0097         fw_upload_free(fw_sysfs);
0098
0099     kfree(fw_sysfs);
0100 }
0101
0102 static struct class firmware_class = {
0103     .name       = "firmware",
0104 #ifdef CONFIG_FW_LOADER_USER_HELPER
0105     .class_groups   = firmware_class_groups,
0106     .dev_uevent = firmware_uevent,
0107 #endif
0108     .dev_release    = fw_dev_release,
0109 };
0110
0111 int register_sysfs_loader(void)
0112 {
0113     int ret = class_register(&firmware_class);
0114
0115     if (ret != 0)
0116         return ret;
0117     return register_firmware_config_sysctl();
0118 }
0119
0120 void unregister_sysfs_loader(void)
0121 {
0122     unregister_firmware_config_sysctl();
0123     class_unregister(&firmware_class);
0124 }
0125
0126 static ssize_t firmware_loading_show(struct device *dev,
0127                      struct device_attribute *attr, char *buf)
0128 {
0129     struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
0130     int loading = 0;
0131
0132     mutex_lock(&fw_lock);
0133     if (fw_sysfs->fw_priv)
0134         loading = fw_state_is_loading(fw_sysfs->fw_priv);
0135     mutex_unlock(&fw_lock);
0136
0137     return sysfs_emit(buf, "%d\n", loading);
0138 }
0139
0140 /**
0141  * firmware_loading_store() - set value in the 'loading' control file
0142  * @dev: device pointer
0143  * @attr: device attribute pointer
0144  * @buf: buffer to scan for loading control value
0145  * @count: number of bytes in @buf
0146  *
0147  *  The relevant values are:
0148  *
0149  *   1: Start a load, discarding any previous partial load.
0150  *   0: Conclude the load and hand the data to the driver code.
0151  *  -1: Conclude the load with an error and discard any written data.
0152  **/
0153 static ssize_t firmware_loading_store(struct device *dev,
0154                       struct device_attribute *attr,
0155                       const char *buf, size_t count)
0156 {
0157     struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
0158     struct fw_priv *fw_priv;
0159     ssize_t written = count;
0160     int loading = simple_strtol(buf, NULL, 10);
0161
0162     mutex_lock(&fw_lock);
0163     fw_priv = fw_sysfs->fw_priv;
0164     if (fw_state_is_aborted(fw_priv) || fw_state_is_done(fw_priv))
0165         goto out;
0166
0167     switch (loading) {
0168     case 1:
0169         /* discarding any previous partial load */
0170         fw_free_paged_buf(fw_priv);
0171         fw_state_start(fw_priv);
0172         break;
0173     case 0:
0174         if (fw_state_is_loading(fw_priv)) {
0175             int rc;
0176
0177             /*
0178              * Several loading requests may be pending on
0179              * one same firmware buf, so let all requests
0180              * see the mapped 'buf->data' once the loading
0181              * is completed.
0182              */
0183             rc = fw_map_paged_buf(fw_priv);
0184             if (rc)
0185                 dev_err(dev, "%s: map pages failed\n",
0186                     __func__);
0187             else
0188                 rc = security_kernel_post_load_data(fw_priv->data,
0189                                     fw_priv->size,
0190                                     LOADING_FIRMWARE,
0191                                     "blob");
0192
0193             /*
0194              * Same logic as fw_load_abort, only the DONE bit
0195              * is ignored and we set ABORT only on failure.
0196              */
0197             if (rc) {
0198                 fw_state_aborted(fw_priv);
0199                 written = rc;
0200             } else {
0201                 fw_state_done(fw_priv);
0202
0203                 /*
0204                  * If this is a user-initiated firmware upload
0205                  * then start the upload in a worker thread now.
0206                  */
0207                 rc = fw_upload_start(fw_sysfs);
0208                 if (rc)
0209                     written = rc;
0210             }
0211             break;
0212         }
0213         fallthrough;
0214     default:
0215         dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
0216         fallthrough;
0217     case -1:
0218         fw_load_abort(fw_sysfs);
0219         if (fw_sysfs->fw_upload_priv)
0220             fw_state_init(fw_sysfs->fw_priv);
0221
0222         break;
0223     }
0224 out:
0225     mutex_unlock(&fw_lock);
0226     return written;
0227 }
0228
0229 DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
0230
0231 static void firmware_rw_data(struct fw_priv *fw_priv, char *buffer,
0232                  loff_t offset, size_t count, bool read)
0233 {
0234     if (read)
0235         memcpy(buffer, fw_priv->data + offset, count);
0236     else
0237         memcpy(fw_priv->data + offset, buffer, count);
0238 }
0239
0240 static void firmware_rw(struct fw_priv *fw_priv, char *buffer,
0241             loff_t offset, size_t count, bool read)
0242 {
0243     while (count) {
0244         int page_nr = offset >> PAGE_SHIFT;
0245         int page_ofs = offset & (PAGE_SIZE - 1);
0246         int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count);
0247
0248         if (read)
0249             memcpy_from_page(buffer, fw_priv->pages[page_nr],
0250                      page_ofs, page_cnt);
0251         else
0252             memcpy_to_page(fw_priv->pages[page_nr], page_ofs,
0253                        buffer, page_cnt);
0254
0255         buffer += page_cnt;
0256         offset += page_cnt;
0257         count -= page_cnt;
0258     }
0259 }
0260
0261 static ssize_t firmware_data_read(struct file *filp, struct kobject *kobj,
0262                   struct bin_attribute *bin_attr,
0263                   char *buffer, loff_t offset, size_t count)
0264 {
0265     struct device *dev = kobj_to_dev(kobj);
0266     struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
0267     struct fw_priv *fw_priv;
0268     ssize_t ret_count;
0269
0270     mutex_lock(&fw_lock);
0271     fw_priv = fw_sysfs->fw_priv;
0272     if (!fw_priv || fw_state_is_done(fw_priv)) {
0273         ret_count = -ENODEV;
0274         goto out;
0275     }
0276     if (offset > fw_priv->size) {
0277         ret_count = 0;
0278         goto out;
0279     }
0280     if (count > fw_priv->size - offset)
0281         count = fw_priv->size - offset;
0282
0283     ret_count = count;
0284
0285     if (fw_priv->data)
0286         firmware_rw_data(fw_priv, buffer, offset, count, true);
0287     else
0288         firmware_rw(fw_priv, buffer, offset, count, true);
0289
0290 out:
0291     mutex_unlock(&fw_lock);
0292     return ret_count;
0293 }
0294
0295 static int fw_realloc_pages(struct fw_sysfs *fw_sysfs, int min_size)
0296 {
0297     int err;
0298
0299     err = fw_grow_paged_buf(fw_sysfs->fw_priv,
0300                 PAGE_ALIGN(min_size) >> PAGE_SHIFT);
0301     if (err)
0302         fw_load_abort(fw_sysfs);
0303     return err;
0304 }
0305
0306 /**
0307  * firmware_data_write() - write method for firmware
0308  * @filp: open sysfs file
0309  * @kobj: kobject for the device
0310  * @bin_attr: bin_attr structure
0311  * @buffer: buffer being written
0312  * @offset: buffer offset for write in total data store area
0313  * @count: buffer size
0314  *
0315  *  Data written to the 'data' attribute will be later handed to
0316  *  the driver as a firmware image.
0317  **/
0318 static ssize_t firmware_data_write(struct file *filp, struct kobject *kobj,
0319                    struct bin_attribute *bin_attr,
0320                    char *buffer, loff_t offset, size_t count)
0321 {
0322     struct device *dev = kobj_to_dev(kobj);
0323     struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
0324     struct fw_priv *fw_priv;
0325     ssize_t retval;
0326
0327     if (!capable(CAP_SYS_RAWIO))
0328         return -EPERM;
0329
0330     mutex_lock(&fw_lock);
0331     fw_priv = fw_sysfs->fw_priv;
0332     if (!fw_priv || fw_state_is_done(fw_priv)) {
0333         retval = -ENODEV;
0334         goto out;
0335     }
0336
0337     if (fw_priv->data) {
0338         if (offset + count > fw_priv->allocated_size) {
0339             retval = -ENOMEM;
0340             goto out;
0341         }
0342         firmware_rw_data(fw_priv, buffer, offset, count, false);
0343         retval = count;
0344     } else {
0345         retval = fw_realloc_pages(fw_sysfs, offset + count);
0346         if (retval)
0347             goto out;
0348
0349         retval = count;
0350         firmware_rw(fw_priv, buffer, offset, count, false);
0351     }
0352
0353     fw_priv->size = max_t(size_t, offset + count, fw_priv->size);
0354 out:
0355     mutex_unlock(&fw_lock);
0356     return retval;
0357 }
0358
0359 static struct bin_attribute firmware_attr_data = {
0360     .attr = { .name = "data", .mode = 0644 },
0361     .size = 0,
0362     .read = firmware_data_read,
0363     .write = firmware_data_write,
0364 };
0365
0366 static struct attribute *fw_dev_attrs[] = {
0367     &dev_attr_loading.attr,
0368 #ifdef CONFIG_FW_UPLOAD
0369     &dev_attr_cancel.attr,
0370     &dev_attr_status.attr,
0371     &dev_attr_error.attr,
0372     &dev_attr_remaining_size.attr,
0373 #endif
0374     NULL
0375 };
0376
0377 static struct bin_attribute *fw_dev_bin_attrs[] = {
0378     &firmware_attr_data,
0379     NULL
0380 };
0381
0382 static const struct attribute_group fw_dev_attr_group = {
0383     .attrs = fw_dev_attrs,
0384     .bin_attrs = fw_dev_bin_attrs,
0385 #ifdef CONFIG_FW_UPLOAD
0386     .is_visible = fw_upload_is_visible,
0387 #endif
0388 };
0389
0390 static const struct attribute_group *fw_dev_attr_groups[] = {
0391     &fw_dev_attr_group,
0392     NULL
0393 };
0394
0395 struct fw_sysfs *
0396 fw_create_instance(struct firmware *firmware, const char *fw_name,
0397            struct device *device, u32 opt_flags)
0398 {
0399     struct fw_sysfs *fw_sysfs;
0400     struct device *f_dev;
0401
0402     fw_sysfs = kzalloc(sizeof(*fw_sysfs), GFP_KERNEL);
0403     if (!fw_sysfs) {
0404         fw_sysfs = ERR_PTR(-ENOMEM);
0405         goto exit;
0406     }
0407
0408     fw_sysfs->nowait = !!(opt_flags & FW_OPT_NOWAIT);
0409     fw_sysfs->fw = firmware;
0410     f_dev = &fw_sysfs->dev;
0411
0412     device_initialize(f_dev);
0413     dev_set_name(f_dev, "%s", fw_name);
0414     f_dev->parent = device;
0415     f_dev->class = &firmware_class;
0416     f_dev->groups = fw_dev_attr_groups;
0417 exit:
0418     return fw_sysfs;
0419 }