esrt.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437
  1. /*
  2. * esrt.c
  3. *
  4. * This module exports EFI System Resource Table (ESRT) entries into userspace
  5. * through the sysfs file system. The ESRT provides a read-only catalog of
  6. * system components for which the system accepts firmware upgrades via UEFI's
  7. * "Capsule Update" feature. This module allows userland utilities to evaluate
  8. * what firmware updates can be applied to this system, and potentially arrange
  9. * for those updates to occur.
  10. *
  11. * Data is currently found below /sys/firmware/efi/esrt/...
  12. */
  13. #define pr_fmt(fmt) "esrt: " fmt
  14. #include <linux/capability.h>
  15. #include <linux/device.h>
  16. #include <linux/efi.h>
  17. #include <linux/init.h>
  18. #include <linux/io.h>
  19. #include <linux/kernel.h>
  20. #include <linux/kobject.h>
  21. #include <linux/list.h>
  22. #include <linux/memblock.h>
  23. #include <linux/slab.h>
  24. #include <linux/types.h>
  25. #include <asm/io.h>
  26. #include <asm/early_ioremap.h>
  27. struct efi_system_resource_entry_v1 {
  28. efi_guid_t fw_class;
  29. u32 fw_type;
  30. u32 fw_version;
  31. u32 lowest_supported_fw_version;
  32. u32 capsule_flags;
  33. u32 last_attempt_version;
  34. u32 last_attempt_status;
  35. };
  36. /*
  37. * _count and _version are what they seem like. _max is actually just
  38. * accounting info for the firmware when creating the table; it should never
  39. * have been exposed to us. To wit, the spec says:
  40. * The maximum number of resource array entries that can be within the
  41. * table without reallocating the table, must not be zero.
  42. * Since there's no guidance about what that means in terms of memory layout,
  43. * it means nothing to us.
  44. */
  45. struct efi_system_resource_table {
  46. u32 fw_resource_count;
  47. u32 fw_resource_count_max;
  48. u64 fw_resource_version;
  49. u8 entries[];
  50. };
  51. static phys_addr_t esrt_data;
  52. static size_t esrt_data_size;
  53. static struct efi_system_resource_table *esrt;
  54. struct esre_entry {
  55. union {
  56. struct efi_system_resource_entry_v1 *esre1;
  57. } esre;
  58. struct kobject kobj;
  59. struct list_head list;
  60. };
  61. /* global list of esre_entry. */
  62. static LIST_HEAD(entry_list);
  63. /* entry attribute */
  64. struct esre_attribute {
  65. struct attribute attr;
  66. ssize_t (*show)(struct esre_entry *entry, char *buf);
  67. ssize_t (*store)(struct esre_entry *entry,
  68. const char *buf, size_t count);
  69. };
  70. static struct esre_entry *to_entry(struct kobject *kobj)
  71. {
  72. return container_of(kobj, struct esre_entry, kobj);
  73. }
  74. static struct esre_attribute *to_attr(struct attribute *attr)
  75. {
  76. return container_of(attr, struct esre_attribute, attr);
  77. }
  78. static ssize_t esre_attr_show(struct kobject *kobj,
  79. struct attribute *_attr, char *buf)
  80. {
  81. struct esre_entry *entry = to_entry(kobj);
  82. struct esre_attribute *attr = to_attr(_attr);
  83. /* Don't tell normal users what firmware versions we've got... */
  84. if (!capable(CAP_SYS_ADMIN))
  85. return -EACCES;
  86. return attr->show(entry, buf);
  87. }
  88. static const struct sysfs_ops esre_attr_ops = {
  89. .show = esre_attr_show,
  90. };
  91. /* Generic ESRT Entry ("ESRE") support. */
  92. static ssize_t fw_class_show(struct esre_entry *entry, char *buf)
  93. {
  94. char *str = buf;
  95. efi_guid_to_str(&entry->esre.esre1->fw_class, str);
  96. str += strlen(str);
  97. str += sprintf(str, "\n");
  98. return str - buf;
  99. }
  100. static struct esre_attribute esre_fw_class = __ATTR_RO_MODE(fw_class, 0400);
  101. #define esre_attr_decl(name, size, fmt) \
  102. static ssize_t name##_show(struct esre_entry *entry, char *buf) \
  103. { \
  104. return sprintf(buf, fmt "\n", \
  105. le##size##_to_cpu(entry->esre.esre1->name)); \
  106. } \
  107. \
  108. static struct esre_attribute esre_##name = __ATTR_RO_MODE(name, 0400)
  109. esre_attr_decl(fw_type, 32, "%u");
  110. esre_attr_decl(fw_version, 32, "%u");
  111. esre_attr_decl(lowest_supported_fw_version, 32, "%u");
  112. esre_attr_decl(capsule_flags, 32, "0x%x");
  113. esre_attr_decl(last_attempt_version, 32, "%u");
  114. esre_attr_decl(last_attempt_status, 32, "%u");
  115. static struct attribute *esre1_attrs[] = {
  116. &esre_fw_class.attr,
  117. &esre_fw_type.attr,
  118. &esre_fw_version.attr,
  119. &esre_lowest_supported_fw_version.attr,
  120. &esre_capsule_flags.attr,
  121. &esre_last_attempt_version.attr,
  122. &esre_last_attempt_status.attr,
  123. NULL
  124. };
  125. static void esre_release(struct kobject *kobj)
  126. {
  127. struct esre_entry *entry = to_entry(kobj);
  128. list_del(&entry->list);
  129. kfree(entry);
  130. }
  131. static struct kobj_type esre1_ktype = {
  132. .release = esre_release,
  133. .sysfs_ops = &esre_attr_ops,
  134. .default_attrs = esre1_attrs,
  135. };
  136. static struct kobject *esrt_kobj;
  137. static struct kset *esrt_kset;
  138. static int esre_create_sysfs_entry(void *esre, int entry_num)
  139. {
  140. struct esre_entry *entry;
  141. entry = kzalloc(sizeof(*entry), GFP_KERNEL);
  142. if (!entry)
  143. return -ENOMEM;
  144. entry->kobj.kset = esrt_kset;
  145. if (esrt->fw_resource_version == 1) {
  146. int rc = 0;
  147. entry->esre.esre1 = esre;
  148. rc = kobject_init_and_add(&entry->kobj, &esre1_ktype, NULL,
  149. "entry%d", entry_num);
  150. if (rc) {
  151. kfree(entry);
  152. return rc;
  153. }
  154. }
  155. list_add_tail(&entry->list, &entry_list);
  156. return 0;
  157. }
  158. /* support for displaying ESRT fields at the top level */
  159. #define esrt_attr_decl(name, size, fmt) \
  160. static ssize_t name##_show(struct kobject *kobj, \
  161. struct kobj_attribute *attr, char *buf)\
  162. { \
  163. return sprintf(buf, fmt "\n", le##size##_to_cpu(esrt->name)); \
  164. } \
  165. \
  166. static struct kobj_attribute esrt_##name = __ATTR_RO_MODE(name, 0400)
  167. esrt_attr_decl(fw_resource_count, 32, "%u");
  168. esrt_attr_decl(fw_resource_count_max, 32, "%u");
  169. esrt_attr_decl(fw_resource_version, 64, "%llu");
  170. static struct attribute *esrt_attrs[] = {
  171. &esrt_fw_resource_count.attr,
  172. &esrt_fw_resource_count_max.attr,
  173. &esrt_fw_resource_version.attr,
  174. NULL,
  175. };
  176. static inline int esrt_table_exists(void)
  177. {
  178. if (!efi_enabled(EFI_CONFIG_TABLES))
  179. return 0;
  180. if (efi.esrt == EFI_INVALID_TABLE_ADDR)
  181. return 0;
  182. return 1;
  183. }
  184. static umode_t esrt_attr_is_visible(struct kobject *kobj,
  185. struct attribute *attr, int n)
  186. {
  187. if (!esrt_table_exists())
  188. return 0;
  189. return attr->mode;
  190. }
  191. static const struct attribute_group esrt_attr_group = {
  192. .attrs = esrt_attrs,
  193. .is_visible = esrt_attr_is_visible,
  194. };
  195. /*
  196. * remap the table, validate it, mark it reserved and unmap it.
  197. */
  198. void __init efi_esrt_init(void)
  199. {
  200. void *va;
  201. struct efi_system_resource_table tmpesrt;
  202. struct efi_system_resource_entry_v1 *v1_entries;
  203. size_t size, max, entry_size, entries_size;
  204. efi_memory_desc_t md;
  205. int rc;
  206. phys_addr_t end;
  207. pr_debug("esrt-init: loading.\n");
  208. if (!esrt_table_exists())
  209. return;
  210. rc = efi_mem_desc_lookup(efi.esrt, &md);
  211. if (rc < 0 ||
  212. (!(md.attribute & EFI_MEMORY_RUNTIME) &&
  213. md.type != EFI_BOOT_SERVICES_DATA &&
  214. md.type != EFI_RUNTIME_SERVICES_DATA)) {
  215. pr_warn("ESRT header is not in the memory map.\n");
  216. return;
  217. }
  218. max = efi_mem_desc_end(&md);
  219. if (max < efi.esrt) {
  220. pr_err("EFI memory descriptor is invalid. (esrt: %p max: %p)\n",
  221. (void *)efi.esrt, (void *)max);
  222. return;
  223. }
  224. size = sizeof(*esrt);
  225. max -= efi.esrt;
  226. if (max < size) {
  227. pr_err("ESRT header doesn't fit on single memory map entry. (size: %zu max: %zu)\n",
  228. size, max);
  229. return;
  230. }
  231. va = early_memremap(efi.esrt, size);
  232. if (!va) {
  233. pr_err("early_memremap(%p, %zu) failed.\n", (void *)efi.esrt,
  234. size);
  235. return;
  236. }
  237. memcpy(&tmpesrt, va, sizeof(tmpesrt));
  238. early_memunmap(va, size);
  239. if (tmpesrt.fw_resource_version == 1) {
  240. entry_size = sizeof (*v1_entries);
  241. } else {
  242. pr_err("Unsupported ESRT version %lld.\n",
  243. tmpesrt.fw_resource_version);
  244. return;
  245. }
  246. if (tmpesrt.fw_resource_count > 0 && max - size < entry_size) {
  247. pr_err("ESRT memory map entry can only hold the header. (max: %zu size: %zu)\n",
  248. max - size, entry_size);
  249. return;
  250. }
  251. /*
  252. * The format doesn't really give us any boundary to test here,
  253. * so I'm making up 128 as the max number of individually updatable
  254. * components we support.
  255. * 128 should be pretty excessive, but there's still some chance
  256. * somebody will do that someday and we'll need to raise this.
  257. */
  258. if (tmpesrt.fw_resource_count > 128) {
  259. pr_err("ESRT says fw_resource_count has very large value %d.\n",
  260. tmpesrt.fw_resource_count);
  261. return;
  262. }
  263. /*
  264. * We know it can't be larger than N * sizeof() here, and N is limited
  265. * by the previous test to a small number, so there's no overflow.
  266. */
  267. entries_size = tmpesrt.fw_resource_count * entry_size;
  268. if (max < size + entries_size) {
  269. pr_err("ESRT does not fit on single memory map entry (size: %zu max: %zu)\n",
  270. size, max);
  271. return;
  272. }
  273. size += entries_size;
  274. esrt_data = (phys_addr_t)efi.esrt;
  275. esrt_data_size = size;
  276. end = esrt_data + size;
  277. pr_info("Reserving ESRT space from %pa to %pa.\n", &esrt_data, &end);
  278. if (md.type == EFI_BOOT_SERVICES_DATA)
  279. efi_mem_reserve(esrt_data, esrt_data_size);
  280. pr_debug("esrt-init: loaded.\n");
  281. }
  282. static int __init register_entries(void)
  283. {
  284. struct efi_system_resource_entry_v1 *v1_entries = (void *)esrt->entries;
  285. int i, rc;
  286. if (!esrt_table_exists())
  287. return 0;
  288. for (i = 0; i < le32_to_cpu(esrt->fw_resource_count); i++) {
  289. void *esre = NULL;
  290. if (esrt->fw_resource_version == 1) {
  291. esre = &v1_entries[i];
  292. } else {
  293. pr_err("Unsupported ESRT version %lld.\n",
  294. esrt->fw_resource_version);
  295. return -EINVAL;
  296. }
  297. rc = esre_create_sysfs_entry(esre, i);
  298. if (rc < 0) {
  299. pr_err("ESRT entry creation failed with error %d.\n",
  300. rc);
  301. return rc;
  302. }
  303. }
  304. return 0;
  305. }
  306. static void cleanup_entry_list(void)
  307. {
  308. struct esre_entry *entry, *next;
  309. list_for_each_entry_safe(entry, next, &entry_list, list) {
  310. kobject_put(&entry->kobj);
  311. }
  312. }
  313. static int __init esrt_sysfs_init(void)
  314. {
  315. int error;
  316. pr_debug("esrt-sysfs: loading.\n");
  317. if (!esrt_data || !esrt_data_size)
  318. return -ENOSYS;
  319. esrt = memremap(esrt_data, esrt_data_size, MEMREMAP_WB);
  320. if (!esrt) {
  321. pr_err("memremap(%pa, %zu) failed.\n", &esrt_data,
  322. esrt_data_size);
  323. return -ENOMEM;
  324. }
  325. esrt_kobj = kobject_create_and_add("esrt", efi_kobj);
  326. if (!esrt_kobj) {
  327. pr_err("Firmware table registration failed.\n");
  328. error = -ENOMEM;
  329. goto err;
  330. }
  331. error = sysfs_create_group(esrt_kobj, &esrt_attr_group);
  332. if (error) {
  333. pr_err("Sysfs attribute export failed with error %d.\n",
  334. error);
  335. goto err_remove_esrt;
  336. }
  337. esrt_kset = kset_create_and_add("entries", NULL, esrt_kobj);
  338. if (!esrt_kset) {
  339. pr_err("kset creation failed.\n");
  340. error = -ENOMEM;
  341. goto err_remove_group;
  342. }
  343. error = register_entries();
  344. if (error)
  345. goto err_cleanup_list;
  346. pr_debug("esrt-sysfs: loaded.\n");
  347. return 0;
  348. err_cleanup_list:
  349. cleanup_entry_list();
  350. kset_unregister(esrt_kset);
  351. err_remove_group:
  352. sysfs_remove_group(esrt_kobj, &esrt_attr_group);
  353. err_remove_esrt:
  354. kobject_put(esrt_kobj);
  355. err:
  356. memunmap(esrt);
  357. esrt = NULL;
  358. return error;
  359. }
  360. device_initcall(esrt_sysfs_init);
  361. /*
  362. MODULE_AUTHOR("Peter Jones <pjones@redhat.com>");
  363. MODULE_DESCRIPTION("EFI System Resource Table support");
  364. MODULE_LICENSE("GPL");
  365. */