lib/test_firmware.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This module provides an interface to trigger and test firmware loading.
   4  *
   5  * It is designed to be used for basic evaluation of the firmware loading
   6  * subsystem (for example when validating firmware verification). It lacks
   7  * any extra dependencies, and will not normally be loaded by the system
   8  * unless explicitly requested by name.
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/printk.h>
  16 #include <linux/completion.h>
  17 #include <linux/firmware.h>
  18 #include <linux/device.h>
  19 #include <linux/fs.h>
  20 #include <linux/miscdevice.h>
  21 #include <linux/sizes.h>
  22 #include <linux/slab.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/delay.h>
  25 #include <linux/kthread.h>
  26 #include <linux/vmalloc.h>
  27 #include <linux/efi_embedded_fw.h>
  28
  29 #define TEST_FIRMWARE_NAME      "test-firmware.bin"
  30 #define TEST_FIRMWARE_NUM_REQS  4
  31 #define TEST_FIRMWARE_BUF_SIZE  SZ_1K
  32
  33 static DEFINE_MUTEX(test_fw_mutex);
  34 static const struct firmware *test_firmware;
  35
  36 struct test_batched_req {
  37         u8 idx;
  38         int rc;
  39         bool sent;
  40         const struct firmware *fw;
  41         const char *name;
  42         struct completion completion;
  43         struct task_struct *task;
  44         struct device *dev;
  45 };
  46
  47 /**
  48  * test_config - represents configuration for the test for different triggers
  49  *
  50  * @name: the name of the firmware file to look for
  51  * @into_buf: when the into_buf is used if this is true
  52  *      request_firmware_into_buf() will be used instead.
  53  * @sync_direct: when the sync trigger is used if this is true
  54  *      request_firmware_direct() will be used instead.
  55  * @send_uevent: whether or not to send a uevent for async requests
  56  * @num_requests: number of requests to try per test case. This is trigger
  57  *      specific.
  58  * @reqs: stores all requests information
  59  * @read_fw_idx: index of thread from which we want to read firmware results
  60  *      from through the read_fw trigger.
  61  * @test_result: a test may use this to collect the result from the call
  62  *      of the request_firmware*() calls used in their tests. In order of
  63  *      priority we always keep first any setup error. If no setup errors were
  64  *      found then we move on to the first error encountered while running the
  65  *      API. Note that for async calls this typically will be a successful
  66  *      result (0) unless of course you've used bogus parameters, or the system
  67  *      is out of memory.  In the async case the callback is expected to do a
  68  *      bit more homework to figure out what happened, unfortunately the only
  69  *      information passed today on error is the fact that no firmware was
  70  *      found so we can only assume -ENOENT on async calls if the firmware is
  71  *      NULL.
  72  *
  73  *      Errors you can expect:
  74  *
  75  *      API specific:
  76  *
  77  *      0:              success for sync, for async it means request was sent
  78  *      -EINVAL:        invalid parameters or request
  79  *      -ENOENT:        files not found
  80  *
  81  *      System environment:
  82  *
  83  *      -ENOMEM:        memory pressure on system
  84  *      -ENODEV:        out of number of devices to test
  85  *      -EINVAL:        an unexpected error has occurred
  86  * @req_firmware: if @sync_direct is true this is set to
  87  *      request_firmware_direct(), otherwise request_firmware()
  88  */
  89 struct test_config {
  90         char *name;
  91         bool into_buf;
  92         bool sync_direct;
  93         bool send_uevent;
  94         u8 num_requests;
  95         u8 read_fw_idx;
  96
  97         /*
  98          * These below don't belong her but we'll move them once we create
  99          * a struct fw_test_device and stuff the misc_dev under there later.
 100          */
 101         struct test_batched_req *reqs;
 102         int test_result;
 103         int (*req_firmware)(const struct firmware **fw, const char *name,
 104                             struct device *device);
 105 };
 106
 107 static struct test_config *test_fw_config;
 108
 109 static ssize_t test_fw_misc_read(struct file *f, char __user *buf,
 110                                  size_t size, loff_t *offset)
 111 {
 112         ssize_t rc = 0;
 113
 114         mutex_lock(&test_fw_mutex);
 115         if (test_firmware)
 116                 rc = simple_read_from_buffer(buf, size, offset,
 117                                              test_firmware->data,
 118                                              test_firmware->size);
 119         mutex_unlock(&test_fw_mutex);
 120         return rc;
 121 }
 122
 123 static const struct file_operations test_fw_fops = {
 124         .owner          = THIS_MODULE,
 125         .read           = test_fw_misc_read,
 126 };
 127
 128 static void __test_release_all_firmware(void)
 129 {
 130         struct test_batched_req *req;
 131         u8 i;
 132
 133         if (!test_fw_config->reqs)
 134                 return;
 135
 136         for (i = 0; i < test_fw_config->num_requests; i++) {
 137                 req = &test_fw_config->reqs[i];
 138                 if (req->fw)
 139                         release_firmware(req->fw);
 140         }
 141
 142         vfree(test_fw_config->reqs);
 143         test_fw_config->reqs = NULL;
 144 }
 145
 146 static void test_release_all_firmware(void)
 147 {
 148         mutex_lock(&test_fw_mutex);
 149         __test_release_all_firmware();
 150         mutex_unlock(&test_fw_mutex);
 151 }
 152
 153
 154 static void __test_firmware_config_free(void)
 155 {
 156         __test_release_all_firmware();
 157         kfree_const(test_fw_config->name);
 158         test_fw_config->name = NULL;
 159 }
 160
 161 /*
 162  * XXX: move to kstrncpy() once merged.
 163  *
 164  * Users should use kfree_const() when freeing these.
 165  */
 166 static int __kstrncpy(char **dst, const char *name, size_t count, gfp_t gfp)
 167 {
 168         *dst = kstrndup(name, count, gfp);
 169         if (!*dst)
 170                 return -ENOSPC;
 171         return count;
 172 }
 173
 174 static int __test_firmware_config_init(void)
 175 {
 176         int ret;
 177
 178         ret = __kstrncpy(&test_fw_config->name, TEST_FIRMWARE_NAME,
 179                          strlen(TEST_FIRMWARE_NAME), GFP_KERNEL);
 180         if (ret < 0)
 181                 goto out;
 182
 183         test_fw_config->num_requests = TEST_FIRMWARE_NUM_REQS;
 184         test_fw_config->send_uevent = true;
 185         test_fw_config->into_buf = false;
 186         test_fw_config->sync_direct = false;
 187         test_fw_config->req_firmware = request_firmware;
 188         test_fw_config->test_result = 0;
 189         test_fw_config->reqs = NULL;
 190
 191         return 0;
 192
 193 out:
 194         __test_firmware_config_free();
 195         return ret;
 196 }
 197
 198 static ssize_t reset_store(struct device *dev,
 199                            struct device_attribute *attr,
 200                            const char *buf, size_t count)
 201 {
 202         int ret;
 203
 204         mutex_lock(&test_fw_mutex);
 205
 206         __test_firmware_config_free();
 207
 208         ret = __test_firmware_config_init();
 209         if (ret < 0) {
 210                 ret = -ENOMEM;
 211                 pr_err("could not alloc settings for config trigger: %d\n",
 212                        ret);
 213                 goto out;
 214         }
 215
 216         pr_info("reset\n");
 217         ret = count;
 218
 219 out:
 220         mutex_unlock(&test_fw_mutex);
 221
 222         return ret;
 223 }
 224 static DEVICE_ATTR_WO(reset);
 225
 226 static ssize_t config_show(struct device *dev,
 227                            struct device_attribute *attr,
 228                            char *buf)
 229 {
 230         int len = 0;
 231
 232         mutex_lock(&test_fw_mutex);
 233
 234         len += scnprintf(buf, PAGE_SIZE - len,
 235                         "Custom trigger configuration for: %s\n",
 236                         dev_name(dev));
 237
 238         if (test_fw_config->name)
 239                 len += scnprintf(buf+len, PAGE_SIZE - len,
 240                                 "name:\t%s\n",
 241                                 test_fw_config->name);
 242         else
 243                 len += scnprintf(buf+len, PAGE_SIZE - len,
 244                                 "name:\tEMTPY\n");
 245
 246         len += scnprintf(buf+len, PAGE_SIZE - len,
 247                         "num_requests:\t%u\n", test_fw_config->num_requests);
 248
 249         len += scnprintf(buf+len, PAGE_SIZE - len,
 250                         "send_uevent:\t\t%s\n",
 251                         test_fw_config->send_uevent ?
 252                         "FW_ACTION_HOTPLUG" :
 253                         "FW_ACTION_NOHOTPLUG");
 254         len += scnprintf(buf+len, PAGE_SIZE - len,
 255                         "into_buf:\t\t%s\n",
 256                         test_fw_config->into_buf ? "true" : "false");
 257         len += scnprintf(buf+len, PAGE_SIZE - len,
 258                         "sync_direct:\t\t%s\n",
 259                         test_fw_config->sync_direct ? "true" : "false");
 260         len += scnprintf(buf+len, PAGE_SIZE - len,
 261                         "read_fw_idx:\t%u\n", test_fw_config->read_fw_idx);
 262
 263         mutex_unlock(&test_fw_mutex);
 264
 265         return len;
 266 }
 267 static DEVICE_ATTR_RO(config);
 268
 269 static ssize_t config_name_store(struct device *dev,
 270                                  struct device_attribute *attr,
 271                                  const char *buf, size_t count)
 272 {
 273         int ret;
 274
 275         mutex_lock(&test_fw_mutex);
 276         kfree_const(test_fw_config->name);
 277         ret = __kstrncpy(&test_fw_config->name, buf, count, GFP_KERNEL);
 278         mutex_unlock(&test_fw_mutex);
 279
 280         return ret;
 281 }
 282
 283 /*
 284  * As per sysfs_kf_seq_show() the buf is max PAGE_SIZE.
 285  */
 286 static ssize_t config_test_show_str(char *dst,
 287                                     char *src)
 288 {
 289         int len;
 290
 291         mutex_lock(&test_fw_mutex);
 292         len = snprintf(dst, PAGE_SIZE, "%s\n", src);
 293         mutex_unlock(&test_fw_mutex);
 294
 295         return len;
 296 }
 297
 298 static int test_dev_config_update_bool(const char *buf, size_t size,
 299                                        bool *cfg)
 300 {
 301         int ret;
 302
 303         mutex_lock(&test_fw_mutex);
 304         if (strtobool(buf, cfg) < 0)
 305                 ret = -EINVAL;
 306         else
 307                 ret = size;
 308         mutex_unlock(&test_fw_mutex);
 309
 310         return ret;
 311 }
 312
 313 static ssize_t test_dev_config_show_bool(char *buf, bool val)
 314 {
 315         return snprintf(buf, PAGE_SIZE, "%d\n", val);
 316 }
 317
 318 static ssize_t test_dev_config_show_int(char *buf, int val)
 319 {
 320         return snprintf(buf, PAGE_SIZE, "%d\n", val);
 321 }
 322
 323 static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg)
 324 {
 325         int ret;
 326         long new;
 327
 328         ret = kstrtol(buf, 10, &new);
 329         if (ret)
 330                 return ret;
 331
 332         if (new > U8_MAX)
 333                 return -EINVAL;
 334
 335         mutex_lock(&test_fw_mutex);
 336         *(u8 *)cfg = new;
 337         mutex_unlock(&test_fw_mutex);
 338
 339         /* Always return full write size even if we didn't consume all */
 340         return size;
 341 }
 342
 343 static ssize_t test_dev_config_show_u8(char *buf, u8 val)
 344 {
 345         return snprintf(buf, PAGE_SIZE, "%u\n", val);
 346 }
 347
 348 static ssize_t config_name_show(struct device *dev,
 349                                 struct device_attribute *attr,
 350                                 char *buf)
 351 {
 352         return config_test_show_str(buf, test_fw_config->name);
 353 }
 354 static DEVICE_ATTR_RW(config_name);
 355
 356 static ssize_t config_num_requests_store(struct device *dev,
 357                                          struct device_attribute *attr,
 358                                          const char *buf, size_t count)
 359 {
 360         int rc;
 361
 362         mutex_lock(&test_fw_mutex);
 363         if (test_fw_config->reqs) {
 364                 pr_err("Must call release_all_firmware prior to changing config\n");
 365                 rc = -EINVAL;
 366                 mutex_unlock(&test_fw_mutex);
 367                 goto out;
 368         }
 369         mutex_unlock(&test_fw_mutex);
 370
 371         rc = test_dev_config_update_u8(buf, count,
 372                                        &test_fw_config->num_requests);
 373
 374 out:
 375         return rc;
 376 }
 377
 378 static ssize_t config_num_requests_show(struct device *dev,
 379                                         struct device_attribute *attr,
 380                                         char *buf)
 381 {
 382         return test_dev_config_show_u8(buf, test_fw_config->num_requests);
 383 }
 384 static DEVICE_ATTR_RW(config_num_requests);
 385
 386 static ssize_t config_into_buf_store(struct device *dev,
 387                                      struct device_attribute *attr,
 388                                      const char *buf, size_t count)
 389 {
 390         return test_dev_config_update_bool(buf,
 391                                            count,
 392                                            &test_fw_config->into_buf);
 393 }
 394
 395 static ssize_t config_into_buf_show(struct device *dev,
 396                                     struct device_attribute *attr,
 397                                     char *buf)
 398 {
 399         return test_dev_config_show_bool(buf, test_fw_config->into_buf);
 400 }
 401 static DEVICE_ATTR_RW(config_into_buf);
 402
 403 static ssize_t config_sync_direct_store(struct device *dev,
 404                                         struct device_attribute *attr,
 405                                         const char *buf, size_t count)
 406 {
 407         int rc = test_dev_config_update_bool(buf, count,
 408                                              &test_fw_config->sync_direct);
 409
 410         if (rc == count)
 411                 test_fw_config->req_firmware = test_fw_config->sync_direct ?
 412                                        request_firmware_direct :
 413                                        request_firmware;
 414         return rc;
 415 }
 416
 417 static ssize_t config_sync_direct_show(struct device *dev,
 418                                        struct device_attribute *attr,
 419                                        char *buf)
 420 {
 421         return test_dev_config_show_bool(buf, test_fw_config->sync_direct);
 422 }
 423 static DEVICE_ATTR_RW(config_sync_direct);
 424
 425 static ssize_t config_send_uevent_store(struct device *dev,
 426                                         struct device_attribute *attr,
 427                                         const char *buf, size_t count)
 428 {
 429         return test_dev_config_update_bool(buf, count,
 430                                            &test_fw_config->send_uevent);
 431 }
 432
 433 static ssize_t config_send_uevent_show(struct device *dev,
 434                                        struct device_attribute *attr,
 435                                        char *buf)
 436 {
 437         return test_dev_config_show_bool(buf, test_fw_config->send_uevent);
 438 }
 439 static DEVICE_ATTR_RW(config_send_uevent);
 440
 441 static ssize_t config_read_fw_idx_store(struct device *dev,
 442                                         struct device_attribute *attr,
 443                                         const char *buf, size_t count)
 444 {
 445         return test_dev_config_update_u8(buf, count,
 446                                          &test_fw_config->read_fw_idx);
 447 }
 448
 449 static ssize_t config_read_fw_idx_show(struct device *dev,
 450                                        struct device_attribute *attr,
 451                                        char *buf)
 452 {
 453         return test_dev_config_show_u8(buf, test_fw_config->read_fw_idx);
 454 }
 455 static DEVICE_ATTR_RW(config_read_fw_idx);
 456
 457
 458 static ssize_t trigger_request_store(struct device *dev,
 459                                      struct device_attribute *attr,
 460                                      const char *buf, size_t count)
 461 {
 462         int rc;
 463         char *name;
 464
 465         name = kstrndup(buf, count, GFP_KERNEL);
 466         if (!name)
 467                 return -ENOSPC;
 468
 469         pr_info("loading '%s'\n", name);
 470
 471         mutex_lock(&test_fw_mutex);
 472         release_firmware(test_firmware);
 473         test_firmware = NULL;
 474         rc = request_firmware(&test_firmware, name, dev);
 475         if (rc) {
 476                 pr_info("load of '%s' failed: %d\n", name, rc);
 477                 goto out;
 478         }
 479         pr_info("loaded: %zu\n", test_firmware->size);
 480         rc = count;
 481
 482 out:
 483         mutex_unlock(&test_fw_mutex);
 484
 485         kfree(name);
 486
 487         return rc;
 488 }
 489 static DEVICE_ATTR_WO(trigger_request);
 490
 491 #ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
 492 #include "../drivers/firmware/efi/embedded-firmware.h"
 493 static ssize_t trigger_request_platform_store(struct device *dev,
 494                                               struct device_attribute *attr,
 495                                               const char *buf, size_t count)
 496 {
 497         static const u8 test_data[] = {
 498                 0x55, 0xaa, 0x55, 0xaa, 0x01, 0x02, 0x03, 0x04,
 499                 0x55, 0xaa, 0x55, 0xaa, 0x05, 0x06, 0x07, 0x08,
 500                 0x55, 0xaa, 0x55, 0xaa, 0x10, 0x20, 0x30, 0x40,
 501                 0x55, 0xaa, 0x55, 0xaa, 0x50, 0x60, 0x70, 0x80
 502         };
 503         struct efi_embedded_fw efi_embedded_fw;
 504         const struct firmware *firmware = NULL;
 505         bool saved_efi_embedded_fw_checked;
 506         char *name;
 507         int rc;
 508
 509         name = kstrndup(buf, count, GFP_KERNEL);
 510         if (!name)
 511                 return -ENOSPC;
 512
 513         pr_info("inserting test platform fw '%s'\n", name);
 514         efi_embedded_fw.name = name;
 515         efi_embedded_fw.data = (void *)test_data;
 516         efi_embedded_fw.length = sizeof(test_data);
 517         list_add(&efi_embedded_fw.list, &efi_embedded_fw_list);
 518         saved_efi_embedded_fw_checked = efi_embedded_fw_checked;
 519         efi_embedded_fw_checked = true;
 520
 521         pr_info("loading '%s'\n", name);
 522         rc = firmware_request_platform(&firmware, name, dev);
 523         if (rc) {
 524                 pr_info("load of '%s' failed: %d\n", name, rc);
 525                 goto out;
 526         }
 527         if (firmware->size != sizeof(test_data) ||
 528             memcmp(firmware->data, test_data, sizeof(test_data)) != 0) {
 529                 pr_info("firmware contents mismatch for '%s'\n", name);
 530                 rc = -EINVAL;
 531                 goto out;
 532         }
 533         pr_info("loaded: %zu\n", firmware->size);
 534         rc = count;
 535
 536 out:
 537         efi_embedded_fw_checked = saved_efi_embedded_fw_checked;
 538         release_firmware(firmware);
 539         list_del(&efi_embedded_fw.list);
 540         kfree(name);
 541
 542         return rc;
 543 }
 544 static DEVICE_ATTR_WO(trigger_request_platform);
 545 #endif
 546
 547 static DECLARE_COMPLETION(async_fw_done);
 548
 549 static void trigger_async_request_cb(const struct firmware *fw, void *context)
 550 {
 551         test_firmware = fw;
 552         complete(&async_fw_done);
 553 }
 554
 555 static ssize_t trigger_async_request_store(struct device *dev,
 556                                            struct device_attribute *attr,
 557                                            const char *buf, size_t count)
 558 {
 559         int rc;
 560         char *name;
 561
 562         name = kstrndup(buf, count, GFP_KERNEL);
 563         if (!name)
 564                 return -ENOSPC;
 565
 566         pr_info("loading '%s'\n", name);
 567
 568         mutex_lock(&test_fw_mutex);
 569         release_firmware(test_firmware);
 570         test_firmware = NULL;
 571         rc = request_firmware_nowait(THIS_MODULE, 1, name, dev, GFP_KERNEL,
 572                                      NULL, trigger_async_request_cb);
 573         if (rc) {
 574                 pr_info("async load of '%s' failed: %d\n", name, rc);
 575                 kfree(name);
 576                 goto out;
 577         }
 578         /* Free 'name' ASAP, to test for race conditions */
 579         kfree(name);
 580
 581         wait_for_completion(&async_fw_done);
 582
 583         if (test_firmware) {
 584                 pr_info("loaded: %zu\n", test_firmware->size);
 585                 rc = count;
 586         } else {
 587                 pr_err("failed to async load firmware\n");
 588                 rc = -ENOMEM;
 589         }
 590
 591 out:
 592         mutex_unlock(&test_fw_mutex);
 593
 594         return rc;
 595 }
 596 static DEVICE_ATTR_WO(trigger_async_request);
 597
 598 static ssize_t trigger_custom_fallback_store(struct device *dev,
 599                                              struct device_attribute *attr,
 600                                              const char *buf, size_t count)
 601 {
 602         int rc;
 603         char *name;
 604
 605         name = kstrndup(buf, count, GFP_KERNEL);
 606         if (!name)
 607                 return -ENOSPC;
 608
 609         pr_info("loading '%s' using custom fallback mechanism\n", name);
 610
 611         mutex_lock(&test_fw_mutex);
 612         release_firmware(test_firmware);
 613         test_firmware = NULL;
 614         rc = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOHOTPLUG, name,
 615                                      dev, GFP_KERNEL, NULL,
 616                                      trigger_async_request_cb);
 617         if (rc) {
 618                 pr_info("async load of '%s' failed: %d\n", name, rc);
 619                 kfree(name);
 620                 goto out;
 621         }
 622         /* Free 'name' ASAP, to test for race conditions */
 623         kfree(name);
 624
 625         wait_for_completion(&async_fw_done);
 626
 627         if (test_firmware) {
 628                 pr_info("loaded: %zu\n", test_firmware->size);
 629                 rc = count;
 630         } else {
 631                 pr_err("failed to async load firmware\n");
 632                 rc = -ENODEV;
 633         }
 634
 635 out:
 636         mutex_unlock(&test_fw_mutex);
 637
 638         return rc;
 639 }
 640 static DEVICE_ATTR_WO(trigger_custom_fallback);
 641
 642 static int test_fw_run_batch_request(void *data)
 643 {
 644         struct test_batched_req *req = data;
 645
 646         if (!req) {
 647                 test_fw_config->test_result = -EINVAL;
 648                 return -EINVAL;
 649         }
 650
 651         if (test_fw_config->into_buf) {
 652                 void *test_buf;
 653
 654                 test_buf = kzalloc(TEST_FIRMWARE_BUF_SIZE, GFP_KERNEL);
 655                 if (!test_buf)
 656                         return -ENOSPC;
 657
 658                 req->rc = request_firmware_into_buf(&req->fw,
 659                                                     req->name,
 660                                                     req->dev,
 661                                                     test_buf,
 662                                                     TEST_FIRMWARE_BUF_SIZE);
 663                 if (!req->fw)
 664                         kfree(test_buf);
 665         } else {
 666                 req->rc = test_fw_config->req_firmware(&req->fw,
 667                                                        req->name,
 668                                                        req->dev);
 669         }
 670
 671         if (req->rc) {
 672                 pr_info("#%u: batched sync load failed: %d\n",
 673                         req->idx, req->rc);
 674                 if (!test_fw_config->test_result)
 675                         test_fw_config->test_result = req->rc;
 676         } else if (req->fw) {
 677                 req->sent = true;
 678                 pr_info("#%u: batched sync loaded %zu\n",
 679                         req->idx, req->fw->size);
 680         }
 681         complete(&req->completion);
 682
 683         req->task = NULL;
 684
 685         return 0;
 686 }
 687
 688 /*
 689  * We use a kthread as otherwise the kernel serializes all our sync requests
 690  * and we would not be able to mimic batched requests on a sync call. Batched
 691  * requests on a sync call can for instance happen on a device driver when
 692  * multiple cards are used and firmware loading happens outside of probe.
 693  */
 694 static ssize_t trigger_batched_requests_store(struct device *dev,
 695                                               struct device_attribute *attr,
 696                                               const char *buf, size_t count)
 697 {
 698         struct test_batched_req *req;
 699         int rc;
 700         u8 i;
 701
 702         mutex_lock(&test_fw_mutex);
 703
 704         test_fw_config->reqs =
 705                 vzalloc(array3_size(sizeof(struct test_batched_req),
 706                                     test_fw_config->num_requests, 2));
 707         if (!test_fw_config->reqs) {
 708                 rc = -ENOMEM;
 709                 goto out_unlock;
 710         }
 711
 712         pr_info("batched sync firmware loading '%s' %u times\n",
 713                 test_fw_config->name, test_fw_config->num_requests);
 714
 715         for (i = 0; i < test_fw_config->num_requests; i++) {
 716                 req = &test_fw_config->reqs[i];
 717                 req->fw = NULL;
 718                 req->idx = i;
 719                 req->name = test_fw_config->name;
 720                 req->dev = dev;
 721                 init_completion(&req->completion);
 722                 req->task = kthread_run(test_fw_run_batch_request, req,
 723                                              "%s-%u", KBUILD_MODNAME, req->idx);
 724                 if (!req->task || IS_ERR(req->task)) {
 725                         pr_err("Setting up thread %u failed\n", req->idx);
 726                         req->task = NULL;
 727                         rc = -ENOMEM;
 728                         goto out_bail;
 729                 }
 730         }
 731
 732         rc = count;
 733
 734         /*
 735          * We require an explicit release to enable more time and delay of
 736          * calling release_firmware() to improve our chances of forcing a
 737          * batched request. If we instead called release_firmware() right away
 738          * then we might miss on an opportunity of having a successful firmware
 739          * request pass on the opportunity to be come a batched request.
 740          */
 741
 742 out_bail:
 743         for (i = 0; i < test_fw_config->num_requests; i++) {
 744                 req = &test_fw_config->reqs[i];
 745                 if (req->task || req->sent)
 746                         wait_for_completion(&req->completion);
 747         }
 748
 749         /* Override any worker error if we had a general setup error */
 750         if (rc < 0)
 751                 test_fw_config->test_result = rc;
 752
 753 out_unlock:
 754         mutex_unlock(&test_fw_mutex);
 755
 756         return rc;
 757 }
 758 static DEVICE_ATTR_WO(trigger_batched_requests);
 759
 760 /*
 761  * We wait for each callback to return with the lock held, no need to lock here
 762  */
 763 static void trigger_batched_cb(const struct firmware *fw, void *context)
 764 {
 765         struct test_batched_req *req = context;
 766
 767         if (!req) {
 768                 test_fw_config->test_result = -EINVAL;
 769                 return;
 770         }
 771
 772         /* forces *some* batched requests to queue up */
 773         if (!req->idx)
 774                 ssleep(2);
 775
 776         req->fw = fw;
 777
 778         /*
 779          * Unfortunately the firmware API gives us nothing other than a null FW
 780          * if the firmware was not found on async requests.  Best we can do is
 781          * just assume -ENOENT. A better API would pass the actual return
 782          * value to the callback.
 783          */
 784         if (!fw && !test_fw_config->test_result)
 785                 test_fw_config->test_result = -ENOENT;
 786
 787         complete(&req->completion);
 788 }
 789
 790 static
 791 ssize_t trigger_batched_requests_async_store(struct device *dev,
 792                                              struct device_attribute *attr,
 793                                              const char *buf, size_t count)
 794 {
 795         struct test_batched_req *req;
 796         bool send_uevent;
 797         int rc;
 798         u8 i;
 799
 800         mutex_lock(&test_fw_mutex);
 801
 802         test_fw_config->reqs =
 803                 vzalloc(array3_size(sizeof(struct test_batched_req),
 804                                     test_fw_config->num_requests, 2));
 805         if (!test_fw_config->reqs) {
 806                 rc = -ENOMEM;
 807                 goto out;
 808         }
 809
 810         pr_info("batched loading '%s' custom fallback mechanism %u times\n",
 811                 test_fw_config->name, test_fw_config->num_requests);
 812
 813         send_uevent = test_fw_config->send_uevent ? FW_ACTION_HOTPLUG :
 814                 FW_ACTION_NOHOTPLUG;
 815
 816         for (i = 0; i < test_fw_config->num_requests; i++) {
 817                 req = &test_fw_config->reqs[i];
 818                 req->name = test_fw_config->name;
 819                 req->fw = NULL;
 820                 req->idx = i;
 821                 init_completion(&req->completion);
 822                 rc = request_firmware_nowait(THIS_MODULE, send_uevent,
 823                                              req->name,
 824                                              dev, GFP_KERNEL, req,
 825                                              trigger_batched_cb);
 826                 if (rc) {
 827                         pr_info("#%u: batched async load failed setup: %d\n",
 828                                 i, rc);
 829                         req->rc = rc;
 830                         goto out_bail;
 831                 } else
 832                         req->sent = true;
 833         }
 834
 835         rc = count;
 836
 837 out_bail:
 838
 839         /*
 840          * We require an explicit release to enable more time and delay of
 841          * calling release_firmware() to improve our chances of forcing a
 842          * batched request. If we instead called release_firmware() right away
 843          * then we might miss on an opportunity of having a successful firmware
 844          * request pass on the opportunity to be come a batched request.
 845          */
 846
 847         for (i = 0; i < test_fw_config->num_requests; i++) {
 848                 req = &test_fw_config->reqs[i];
 849                 if (req->sent)
 850                         wait_for_completion(&req->completion);
 851         }
 852
 853         /* Override any worker error if we had a general setup error */
 854         if (rc < 0)
 855                 test_fw_config->test_result = rc;
 856
 857 out:
 858         mutex_unlock(&test_fw_mutex);
 859
 860         return rc;
 861 }
 862 static DEVICE_ATTR_WO(trigger_batched_requests_async);
 863
 864 static ssize_t test_result_show(struct device *dev,
 865                                 struct device_attribute *attr,
 866                                 char *buf)
 867 {
 868         return test_dev_config_show_int(buf, test_fw_config->test_result);
 869 }
 870 static DEVICE_ATTR_RO(test_result);
 871
 872 static ssize_t release_all_firmware_store(struct device *dev,
 873                                           struct device_attribute *attr,
 874                                           const char *buf, size_t count)
 875 {
 876         test_release_all_firmware();
 877         return count;
 878 }
 879 static DEVICE_ATTR_WO(release_all_firmware);
 880
 881 static ssize_t read_firmware_show(struct device *dev,
 882                                   struct device_attribute *attr,
 883                                   char *buf)
 884 {
 885         struct test_batched_req *req;
 886         u8 idx;
 887         ssize_t rc = 0;
 888
 889         mutex_lock(&test_fw_mutex);
 890
 891         idx = test_fw_config->read_fw_idx;
 892         if (idx >= test_fw_config->num_requests) {
 893                 rc = -ERANGE;
 894                 goto out;
 895         }
 896
 897         if (!test_fw_config->reqs) {
 898                 rc = -EINVAL;
 899                 goto out;
 900         }
 901
 902         req = &test_fw_config->reqs[idx];
 903         if (!req->fw) {
 904                 pr_err("#%u: failed to async load firmware\n", idx);
 905                 rc = -ENOENT;
 906                 goto out;
 907         }
 908
 909         pr_info("#%u: loaded %zu\n", idx, req->fw->size);
 910
 911         if (req->fw->size > PAGE_SIZE) {
 912                 pr_err("Testing interface must use PAGE_SIZE firmware for now\n");
 913                 rc = -EINVAL;
 914                 goto out;
 915         }
 916         memcpy(buf, req->fw->data, req->fw->size);
 917
 918         rc = req->fw->size;
 919 out:
 920         mutex_unlock(&test_fw_mutex);
 921
 922         return rc;
 923 }
 924 static DEVICE_ATTR_RO(read_firmware);
 925
 926 #define TEST_FW_DEV_ATTR(name)          &dev_attr_##name.attr
 927
 928 static struct attribute *test_dev_attrs[] = {
 929         TEST_FW_DEV_ATTR(reset),
 930
 931         TEST_FW_DEV_ATTR(config),
 932         TEST_FW_DEV_ATTR(config_name),
 933         TEST_FW_DEV_ATTR(config_num_requests),
 934         TEST_FW_DEV_ATTR(config_into_buf),
 935         TEST_FW_DEV_ATTR(config_sync_direct),
 936         TEST_FW_DEV_ATTR(config_send_uevent),
 937         TEST_FW_DEV_ATTR(config_read_fw_idx),
 938
 939         /* These don't use the config at all - they could be ported! */
 940         TEST_FW_DEV_ATTR(trigger_request),
 941         TEST_FW_DEV_ATTR(trigger_async_request),
 942         TEST_FW_DEV_ATTR(trigger_custom_fallback),
 943 #ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
 944         TEST_FW_DEV_ATTR(trigger_request_platform),
 945 #endif
 946
 947         /* These use the config and can use the test_result */
 948         TEST_FW_DEV_ATTR(trigger_batched_requests),
 949         TEST_FW_DEV_ATTR(trigger_batched_requests_async),
 950
 951         TEST_FW_DEV_ATTR(release_all_firmware),
 952         TEST_FW_DEV_ATTR(test_result),
 953         TEST_FW_DEV_ATTR(read_firmware),
 954         NULL,
 955 };
 956
 957 ATTRIBUTE_GROUPS(test_dev);
 958
 959 static struct miscdevice test_fw_misc_device = {
 960         .minor          = MISC_DYNAMIC_MINOR,
 961         .name           = "test_firmware",
 962         .fops           = &test_fw_fops,
 963         .groups         = test_dev_groups,
 964 };
 965
 966 static int __init test_firmware_init(void)
 967 {
 968         int rc;
 969
 970         test_fw_config = kzalloc(sizeof(struct test_config), GFP_KERNEL);
 971         if (!test_fw_config)
 972                 return -ENOMEM;
 973
 974         rc = __test_firmware_config_init();
 975         if (rc) {
 976                 kfree(test_fw_config);
 977                 pr_err("could not init firmware test config: %d\n", rc);
 978                 return rc;
 979         }
 980
 981         rc = misc_register(&test_fw_misc_device);
 982         if (rc) {
 983                 kfree(test_fw_config);
 984                 pr_err("could not register misc device: %d\n", rc);
 985                 return rc;
 986         }
 987
 988         pr_warn("interface ready\n");
 989
 990         return 0;
 991 }
 992
 993 module_init(test_firmware_init);
 994
 995 static void __exit test_firmware_exit(void)
 996 {
 997         mutex_lock(&test_fw_mutex);
 998         release_firmware(test_firmware);
 999         misc_deregister(&test_fw_misc_device);
1000         __test_firmware_config_free();
1001         kfree(test_fw_config);
1002         mutex_unlock(&test_fw_mutex);
1003
1004         pr_warn("removed interface\n");
1005 }
1006
1007 module_exit(test_firmware_exit);
1008
1009 MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
1010 MODULE_LICENSE("GPL");