drivers/firmware/efi/runtime-map.c

   1 /*
   2  * linux/drivers/efi/runtime-map.c
   3  * Copyright (C) 2013 Red Hat, Inc., Dave Young <dyoung@redhat.com>
   4  *
   5  * This file is released under the GPLv2.
   6  */
   7
   8 #include <linux/string.h>
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/types.h>
  12 #include <linux/efi.h>
  13 #include <linux/slab.h>
  14
  15 #include <asm/setup.h>
  16
  17 struct efi_runtime_map_entry {
  18         efi_memory_desc_t md;
  19         struct kobject kobj;   /* kobject for each entry */
  20 };
  21
  22 static struct efi_runtime_map_entry **map_entries;
  23
  24 struct map_attribute {
  25         struct attribute attr;
  26         ssize_t (*show)(struct efi_runtime_map_entry *entry, char *buf);
  27 };
  28
  29 static inline struct map_attribute *to_map_attr(struct attribute *attr)
  30 {
  31         return container_of(attr, struct map_attribute, attr);
  32 }
  33
  34 static ssize_t type_show(struct efi_runtime_map_entry *entry, char *buf)
  35 {
  36         return snprintf(buf, PAGE_SIZE, "0x%x\n", entry->md.type);
  37 }
  38
  39 #define EFI_RUNTIME_FIELD(var) entry->md.var
  40
  41 #define EFI_RUNTIME_U64_ATTR_SHOW(name) \
  42 static ssize_t name##_show(struct efi_runtime_map_entry *entry, char *buf) \
  43 { \
  44         return snprintf(buf, PAGE_SIZE, "0x%llx\n", EFI_RUNTIME_FIELD(name)); \
  45 }
  46
  47 EFI_RUNTIME_U64_ATTR_SHOW(phys_addr);
  48 EFI_RUNTIME_U64_ATTR_SHOW(virt_addr);
  49 EFI_RUNTIME_U64_ATTR_SHOW(num_pages);
  50 EFI_RUNTIME_U64_ATTR_SHOW(attribute);
  51
  52 static inline struct efi_runtime_map_entry *to_map_entry(struct kobject *kobj)
  53 {
  54         return container_of(kobj, struct efi_runtime_map_entry, kobj);
  55 }
  56
  57 static ssize_t map_attr_show(struct kobject *kobj, struct attribute *attr,
  58                               char *buf)
  59 {
  60         struct efi_runtime_map_entry *entry = to_map_entry(kobj);
  61         struct map_attribute *map_attr = to_map_attr(attr);
  62
  63         return map_attr->show(entry, buf);
  64 }
  65
  66 static struct map_attribute map_type_attr = __ATTR_RO_MODE(type, 0400);
  67 static struct map_attribute map_phys_addr_attr = __ATTR_RO_MODE(phys_addr, 0400);
  68 static struct map_attribute map_virt_addr_attr = __ATTR_RO_MODE(virt_addr, 0400);
  69 static struct map_attribute map_num_pages_attr = __ATTR_RO_MODE(num_pages, 0400);
  70 static struct map_attribute map_attribute_attr = __ATTR_RO_MODE(attribute, 0400);
  71
  72 /*
  73  * These are default attributes that are added for every memmap entry.
  74  */
  75 static struct attribute *def_attrs[] = {
  76         &map_type_attr.attr,
  77         &map_phys_addr_attr.attr,
  78         &map_virt_addr_attr.attr,
  79         &map_num_pages_attr.attr,
  80         &map_attribute_attr.attr,
  81         NULL
  82 };
  83
  84 static const struct sysfs_ops map_attr_ops = {
  85         .show = map_attr_show,
  86 };
  87
  88 static void map_release(struct kobject *kobj)
  89 {
  90         struct efi_runtime_map_entry *entry;
  91
  92         entry = to_map_entry(kobj);
  93         kfree(entry);
  94 }
  95
  96 static struct kobj_type __refdata map_ktype = {
  97         .sysfs_ops      = &map_attr_ops,
  98         .default_attrs  = def_attrs,
  99         .release        = map_release,
 100 };
 101
 102 static struct kset *map_kset;
 103
 104 static struct efi_runtime_map_entry *
 105 add_sysfs_runtime_map_entry(struct kobject *kobj, int nr,
 106                             efi_memory_desc_t *md)
 107 {
 108         int ret;
 109         struct efi_runtime_map_entry *entry;
 110
 111         if (!map_kset) {
 112                 map_kset = kset_create_and_add("runtime-map", NULL, kobj);
 113                 if (!map_kset)
 114                         return ERR_PTR(-ENOMEM);
 115         }
 116
 117         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
 118         if (!entry) {
 119                 kset_unregister(map_kset);
 120                 map_kset = NULL;
 121                 return ERR_PTR(-ENOMEM);
 122         }
 123
 124         memcpy(&entry->md, md, sizeof(efi_memory_desc_t));
 125
 126         kobject_init(&entry->kobj, &map_ktype);
 127         entry->kobj.kset = map_kset;
 128         ret = kobject_add(&entry->kobj, NULL, "%d", nr);
 129         if (ret) {
 130                 kobject_put(&entry->kobj);
 131                 kset_unregister(map_kset);
 132                 map_kset = NULL;
 133                 return ERR_PTR(ret);
 134         }
 135
 136         return entry;
 137 }
 138
 139 int efi_get_runtime_map_size(void)
 140 {
 141         return efi.memmap.nr_map * efi.memmap.desc_size;
 142 }
 143
 144 int efi_get_runtime_map_desc_size(void)
 145 {
 146         return efi.memmap.desc_size;
 147 }
 148
 149 int efi_runtime_map_copy(void *buf, size_t bufsz)
 150 {
 151         size_t sz = efi_get_runtime_map_size();
 152
 153         if (sz > bufsz)
 154                 sz = bufsz;
 155
 156         memcpy(buf, efi.memmap.map, sz);
 157         return 0;
 158 }
 159
 160 int __init efi_runtime_map_init(struct kobject *efi_kobj)
 161 {
 162         int i, j, ret = 0;
 163         struct efi_runtime_map_entry *entry;
 164         efi_memory_desc_t *md;
 165
 166         if (!efi_enabled(EFI_MEMMAP))
 167                 return 0;
 168
 169         map_entries = kzalloc(efi.memmap.nr_map * sizeof(entry), GFP_KERNEL);
 170         if (!map_entries) {
 171                 ret = -ENOMEM;
 172                 goto out;
 173         }
 174
 175         i = 0;
 176         for_each_efi_memory_desc(md) {
 177                 entry = add_sysfs_runtime_map_entry(efi_kobj, i, md);
 178                 if (IS_ERR(entry)) {
 179                         ret = PTR_ERR(entry);
 180                         goto out_add_entry;
 181                 }
 182                 *(map_entries + i++) = entry;
 183         }
 184
 185         return 0;
 186 out_add_entry:
 187         for (j = i - 1; j >= 0; j--) {
 188                 entry = *(map_entries + j);
 189                 kobject_put(&entry->kobj);
 190         }
 191 out:
 192         return ret;
 193 }