Release 4.11 drivers/firmware/efi/runtime-map.c

/*
 * linux/drivers/efi/runtime-map.c
 * Copyright (C) 2013 Red Hat, Inc., Dave Young <dyoung@redhat.com>
 *
 * This file is released under the GPLv2.
 */

#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/efi.h>
#include <linux/slab.h>

#include <asm/setup.h>


struct efi_runtime_map_entry {
	
efi_memory_desc_t md;
	
struct kobject kobj;   /* kobject for each entry */
};


static struct efi_runtime_map_entry **map_entries;


struct map_attribute {
	
struct attribute attr;
	
ssize_t (*show)(struct efi_runtime_map_entry *entry, char *buf);
};



static inline struct map_attribute *to_map_attr(struct attribute *attr)
{
	return container_of(attr, struct map_attribute, attr);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
25
100.00%
1
100.00%
Total
25
100.00%
1
100.00%



static ssize_t type_show(struct efi_runtime_map_entry *entry, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "0x%x\n", entry->md.type);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
31
100.00%
1
100.00%
Total
31
100.00%
1
100.00%


#define EFI_RUNTIME_FIELD(var) entry->md.var


#define EFI_RUNTIME_U64_ATTR_SHOW(name) \
static ssize_t name##_show(struct efi_runtime_map_entry *entry, char *buf) \
{ \
        return snprintf(buf, PAGE_SIZE, "0x%llx\n", EFI_RUNTIME_FIELD(name)); \
}


EFI_RUNTIME_U64_ATTR_SHOW(phys_addr);

EFI_RUNTIME_U64_ATTR_SHOW(virt_addr);

EFI_RUNTIME_U64_ATTR_SHOW(num_pages);

EFI_RUNTIME_U64_ATTR_SHOW(attribute);



static inline struct efi_runtime_map_entry *to_map_entry(struct kobject *kobj)
{
	return container_of(kobj, struct efi_runtime_map_entry, kobj);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
25
100.00%
1
100.00%
Total
25
100.00%
1
100.00%



static ssize_t map_attr_show(struct kobject *kobj, struct attribute *attr,
			      char *buf)
{
	struct efi_runtime_map_entry *entry = to_map_entry(kobj);
	struct map_attribute *map_attr = to_map_attr(attr);

	return map_attr->show(entry, buf);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
50
100.00%
1
100.00%
Total
50
100.00%
1
100.00%


static struct map_attribute map_type_attr = __ATTR_RO(type);

static struct map_attribute map_phys_addr_attr   = __ATTR_RO(phys_addr);

static struct map_attribute map_virt_addr_attr  = __ATTR_RO(virt_addr);

static struct map_attribute map_num_pages_attr  = __ATTR_RO(num_pages);

static struct map_attribute map_attribute_attr  = __ATTR_RO(attribute);

/*
 * These are default attributes that are added for every memmap entry.
 */

static struct attribute *def_attrs[] = {
	&map_type_attr.attr,
	&map_phys_addr_attr.attr,
	&map_virt_addr_attr.attr,
	&map_num_pages_attr.attr,
	&map_attribute_attr.attr,
	NULL
};


static const struct sysfs_ops map_attr_ops = {
	.show = map_attr_show,
};



static void map_release(struct kobject *kobj)
{
	struct efi_runtime_map_entry *entry;

	entry = to_map_entry(kobj);
	kfree(entry);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
28
100.00%
1
100.00%
Total
28
100.00%
1
100.00%


static struct kobj_type __refdata map_ktype = {
	.sysfs_ops	= &map_attr_ops,
	.default_attrs	= def_attrs,
	.release	= map_release,
};


static struct kset *map_kset;


static struct efi_runtime_map_entry *

add_sysfs_runtime_map_entry(struct kobject *kobj, int nr,
			    efi_memory_desc_t *md)
{
	int ret;
	struct efi_runtime_map_entry *entry;

	if (!map_kset) {
		map_kset = kset_create_and_add("runtime-map", NULL, kobj);
		if (!map_kset)
			return ERR_PTR(-ENOMEM);
	}

	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	if (!entry) {
		kset_unregister(map_kset);
		map_kset = NULL;
		return ERR_PTR(-ENOMEM);
	}

	memcpy(&entry->md, md, sizeof(efi_memory_desc_t));

	kobject_init(&entry->kobj, &map_ktype);
	entry->kobj.kset = map_kset;
	ret = kobject_add(&entry->kobj, NULL, "%d", nr);
	if (ret) {
		kobject_put(&entry->kobj);
		kset_unregister(map_kset);
		map_kset = NULL;
		return ERR_PTR(ret);
	}

	return entry;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
158
89.77%
1
33.33%
Dan Carpenter
13
7.39%
1
33.33%
Matt Fleming
5
2.84%
1
33.33%
Total
176
100.00%
3
100.00%



int efi_get_runtime_map_size(void)
{
	return efi.memmap.nr_map * efi.memmap.desc_size;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Matt Fleming
10
50.00%
1
50.00%
Vivek Goyal
10
50.00%
1
50.00%
Total
20
100.00%
2
100.00%



int efi_get_runtime_map_desc_size(void)
{
	return efi.memmap.desc_size;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Vivek Goyal
9
64.29%
1
50.00%
Matt Fleming
5
35.71%
1
50.00%
Total
14
100.00%
2
100.00%



int efi_runtime_map_copy(void *buf, size_t bufsz)
{
	size_t sz = efi_get_runtime_map_size();

	if (sz > bufsz)
		sz = bufsz;

	memcpy(buf, efi.memmap.map, sz);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Vivek Goyal
39
88.64%
1
50.00%
Matt Fleming
5
11.36%
1
50.00%
Total
44
100.00%
2
100.00%



int __init efi_runtime_map_init(struct kobject *efi_kobj)
{
	int i, j, ret = 0;
	struct efi_runtime_map_entry *entry;
	efi_memory_desc_t *md;

	if (!efi_enabled(EFI_MEMMAP))
		return 0;

	map_entries = kzalloc(efi.memmap.nr_map * sizeof(entry), GFP_KERNEL);
	if (!map_entries) {
		ret = -ENOMEM;
		goto out;
	}

	i = 0;
	for_each_efi_memory_desc(md) {
		entry = add_sysfs_runtime_map_entry(efi_kobj, i, md);
		if (IS_ERR(entry)) {
			ret = PTR_ERR(entry);
			goto out_add_entry;
		}
		*(map_entries + i++) = entry;
	}

	return 0;
out_add_entry:
	for (j = i - 1; j >= 0; j--) {
		entry = *(map_entries + j);
		kobject_put(&entry->kobj);
	}
out:
	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
145
86.83%
1
33.33%
Matt Fleming
21
12.57%
1
33.33%
Dan Carpenter
1
0.60%
1
33.33%
Total
167
100.00%
3
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Dave Young
694
85.47%
1
20.00%
Vivek Goyal
58
7.14%
1
20.00%
Matt Fleming
46
5.67%
1
20.00%
Dan Carpenter
14
1.72%
2
40.00%
Total
812
100.00%
5
100.00%
Directory: drivers/firmware/efi

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.