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