root/drivers/firmware/efi/efibc.c

DEFINITIONS

1. efibc_str_to_str16
2. efibc_set_variable
3. efibc_reboot_notifier_call
4. efibc_init
5. efibc_exit

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * efibc: control EFI bootloaders which obey LoaderEntryOneShot var
   4  * Copyright (c) 2013-2016, Intel Corporation.
   5  */
   6 
   7 #define pr_fmt(fmt) "efibc: " fmt
   8 
   9 #include <linux/efi.h>
  10 #include <linux/module.h>
  11 #include <linux/reboot.h>
  12 #include <linux/slab.h>
  13 
  14 static void efibc_str_to_str16(const char *str, efi_char16_t *str16)
  15 {
  16         size_t i;
  17 
  18         for (i = 0; i < strlen(str); i++)
  19                 str16[i] = str[i];
  20 
  21         str16[i] = '\0';
  22 }
  23 
  24 static int efibc_set_variable(const char *name, const char *value)
  25 {
  26         int ret;
  27         efi_guid_t guid = LINUX_EFI_LOADER_ENTRY_GUID;
  28         struct efivar_entry *entry;
  29         size_t size = (strlen(value) + 1) * sizeof(efi_char16_t);
  30 
  31         if (size > sizeof(entry->var.Data)) {
  32                 pr_err("value is too large (%zu bytes) for '%s' EFI variable\n", size, name);
  33                 return -EINVAL;
  34         }
  35 
  36         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
  37         if (!entry) {
  38                 pr_err("failed to allocate efivar entry for '%s' EFI variable\n", name);
  39                 return -ENOMEM;
  40         }
  41 
  42         efibc_str_to_str16(name, entry->var.VariableName);
  43         efibc_str_to_str16(value, (efi_char16_t *)entry->var.Data);
  44         memcpy(&entry->var.VendorGuid, &guid, sizeof(guid));
  45 
  46         ret = efivar_entry_set_safe(entry->var.VariableName,
  47                                     entry->var.VendorGuid,
  48                                     EFI_VARIABLE_NON_VOLATILE
  49                                     | EFI_VARIABLE_BOOTSERVICE_ACCESS
  50                                     | EFI_VARIABLE_RUNTIME_ACCESS,
  51                                     false, size, entry->var.Data);
  52 
  53         if (ret)
  54                 pr_err("failed to set %s EFI variable: 0x%x\n",
  55                        name, ret);
  56 
  57         kfree(entry);
  58         return ret;
  59 }
  60 
  61 static int efibc_reboot_notifier_call(struct notifier_block *notifier,
  62                                       unsigned long event, void *data)
  63 {
  64         const char *reason = "shutdown";
  65         int ret;
  66 
  67         if (event == SYS_RESTART)
  68                 reason = "reboot";
  69 
  70         ret = efibc_set_variable("LoaderEntryRebootReason", reason);
  71         if (ret || !data)
  72                 return NOTIFY_DONE;
  73 
  74         efibc_set_variable("LoaderEntryOneShot", (char *)data);
  75 
  76         return NOTIFY_DONE;
  77 }
  78 
  79 static struct notifier_block efibc_reboot_notifier = {
  80         .notifier_call = efibc_reboot_notifier_call,
  81 };
  82 
  83 static int __init efibc_init(void)
  84 {
  85         int ret;
  86 
  87         if (!efi_enabled(EFI_RUNTIME_SERVICES))
  88                 return -ENODEV;
  89 
  90         ret = register_reboot_notifier(&efibc_reboot_notifier);
  91         if (ret)
  92                 pr_err("unable to register reboot notifier\n");
  93 
  94         return ret;
  95 }
  96 module_init(efibc_init);
  97 
  98 static void __exit efibc_exit(void)
  99 {
 100         unregister_reboot_notifier(&efibc_reboot_notifier);
 101 }
 102 module_exit(efibc_exit);
 103 
 104 MODULE_AUTHOR("Jeremy Compostella <jeremy.compostella@intel.com>");
 105 MODULE_AUTHOR("Matt Gumbel <matthew.k.gumbel@intel.com");
 106 MODULE_DESCRIPTION("EFI Bootloader Control");
 107 MODULE_LICENSE("GPL v2");