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