2019-06-04 16:11:33 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2013-02-09 00:27:24 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2012 Red Hat, Inc.
|
|
|
|
* Copyright (C) 2012 Jeremy Kerr <jeremy.kerr@canonical.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/ctype.h>
|
|
|
|
#include <linux/efi.h>
|
|
|
|
#include <linux/fs.h>
|
2019-03-26 00:38:29 +08:00
|
|
|
#include <linux/fs_context.h>
|
2013-02-09 00:27:24 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pagemap.h>
|
2013-04-30 18:30:24 +08:00
|
|
|
#include <linux/ucs2_string.h>
|
2013-05-02 08:51:54 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/magic.h>
|
2013-02-09 00:27:24 +08:00
|
|
|
|
|
|
|
#include "internal.h"
|
|
|
|
|
|
|
|
LIST_HEAD(efivarfs_list);
|
|
|
|
|
|
|
|
static void efivarfs_evict_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
clear_inode(inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct super_operations efivarfs_ops = {
|
|
|
|
.statfs = simple_statfs,
|
|
|
|
.drop_inode = generic_delete_inode,
|
|
|
|
.evict_inode = efivarfs_evict_inode,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare two efivarfs file names.
|
|
|
|
*
|
|
|
|
* An efivarfs filename is composed of two parts,
|
|
|
|
*
|
|
|
|
* 1. A case-sensitive variable name
|
|
|
|
* 2. A case-insensitive GUID
|
|
|
|
*
|
|
|
|
* So we need to perform a case-sensitive match on part 1 and a
|
|
|
|
* case-insensitive match on part 2.
|
|
|
|
*/
|
2016-08-01 04:37:25 +08:00
|
|
|
static int efivarfs_d_compare(const struct dentry *dentry,
|
2013-02-09 00:27:24 +08:00
|
|
|
unsigned int len, const char *str,
|
|
|
|
const struct qstr *name)
|
|
|
|
{
|
|
|
|
int guid = len - EFI_VARIABLE_GUID_LEN;
|
|
|
|
|
|
|
|
if (name->len != len)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Case-sensitive compare for the variable name */
|
|
|
|
if (memcmp(str, name->name, guid))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Case-insensitive compare for the GUID */
|
|
|
|
return strncasecmp(name->name + guid, str + guid, EFI_VARIABLE_GUID_LEN);
|
|
|
|
}
|
|
|
|
|
2013-05-22 06:22:44 +08:00
|
|
|
static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr)
|
2013-02-09 00:27:24 +08:00
|
|
|
{
|
2016-06-10 22:51:30 +08:00
|
|
|
unsigned long hash = init_name_hash(dentry);
|
2013-02-09 00:27:24 +08:00
|
|
|
const unsigned char *s = qstr->name;
|
|
|
|
unsigned int len = qstr->len;
|
|
|
|
|
|
|
|
if (!efivarfs_valid_name(s, len))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
while (len-- > EFI_VARIABLE_GUID_LEN)
|
|
|
|
hash = partial_name_hash(*s++, hash);
|
|
|
|
|
|
|
|
/* GUID is case-insensitive. */
|
|
|
|
while (len--)
|
|
|
|
hash = partial_name_hash(tolower(*s++), hash);
|
|
|
|
|
|
|
|
qstr->hash = end_name_hash(hash);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-05 07:11:14 +08:00
|
|
|
static const struct dentry_operations efivarfs_d_ops = {
|
2013-02-09 00:27:24 +08:00
|
|
|
.d_compare = efivarfs_d_compare,
|
|
|
|
.d_hash = efivarfs_d_hash,
|
2013-10-26 06:47:37 +08:00
|
|
|
.d_delete = always_delete_dentry,
|
2013-02-09 00:27:24 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name)
|
|
|
|
{
|
|
|
|
struct dentry *d;
|
|
|
|
struct qstr q;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
q.name = name;
|
|
|
|
q.len = strlen(name);
|
|
|
|
|
2016-06-10 22:51:30 +08:00
|
|
|
err = efivarfs_d_hash(parent, &q);
|
2013-02-09 00:27:24 +08:00
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
|
|
|
d = d_alloc(parent, &q);
|
|
|
|
if (d)
|
|
|
|
return d;
|
|
|
|
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int efivarfs_callback(efi_char16_t *name16, efi_guid_t vendor,
|
|
|
|
unsigned long name_size, void *data)
|
|
|
|
{
|
|
|
|
struct super_block *sb = (struct super_block *)data;
|
|
|
|
struct efivar_entry *entry;
|
|
|
|
struct inode *inode = NULL;
|
|
|
|
struct dentry *dentry, *root = sb->s_root;
|
|
|
|
unsigned long size = 0;
|
|
|
|
char *name;
|
2016-02-09 03:48:12 +08:00
|
|
|
int len;
|
2013-02-09 00:27:24 +08:00
|
|
|
int err = -ENOMEM;
|
2016-02-09 03:48:15 +08:00
|
|
|
bool is_removable = false;
|
2013-02-09 00:27:24 +08:00
|
|
|
|
2022-11-22 10:04:00 +08:00
|
|
|
if (guid_equal(&vendor, &LINUX_EFI_RANDOM_SEED_TABLE_GUID))
|
|
|
|
return 0;
|
|
|
|
|
2015-04-02 15:39:00 +08:00
|
|
|
entry = kzalloc(sizeof(*entry), GFP_KERNEL);
|
2013-02-09 00:27:24 +08:00
|
|
|
if (!entry)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
memcpy(entry->var.VariableName, name16, name_size);
|
|
|
|
memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t));
|
|
|
|
|
2016-02-09 03:48:12 +08:00
|
|
|
len = ucs2_utf8size(entry->var.VariableName);
|
2013-02-09 00:27:24 +08:00
|
|
|
|
|
|
|
/* name, plus '-', plus GUID, plus NUL*/
|
|
|
|
name = kmalloc(len + 1 + EFI_VARIABLE_GUID_LEN + 1, GFP_KERNEL);
|
|
|
|
if (!name)
|
|
|
|
goto fail;
|
|
|
|
|
2016-02-09 03:48:12 +08:00
|
|
|
ucs2_as_utf8(name, entry->var.VariableName, len);
|
2013-02-09 00:27:24 +08:00
|
|
|
|
2016-02-09 03:48:15 +08:00
|
|
|
if (efivar_variable_is_removable(entry->var.VendorGuid, name, len))
|
|
|
|
is_removable = true;
|
|
|
|
|
2013-02-09 00:27:24 +08:00
|
|
|
name[len] = '-';
|
|
|
|
|
2014-12-18 23:02:17 +08:00
|
|
|
efi_guid_to_str(&entry->var.VendorGuid, name + len + 1);
|
2013-02-09 00:27:24 +08:00
|
|
|
|
|
|
|
name[len + EFI_VARIABLE_GUID_LEN+1] = '\0';
|
|
|
|
|
2020-09-25 15:45:02 +08:00
|
|
|
/* replace invalid slashes like kobject_set_name_vargs does for /sys/firmware/efi/vars. */
|
|
|
|
strreplace(name, '/', '!');
|
|
|
|
|
2016-02-09 03:48:15 +08:00
|
|
|
inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0,
|
|
|
|
is_removable);
|
2013-02-09 00:27:24 +08:00
|
|
|
if (!inode)
|
|
|
|
goto fail_name;
|
|
|
|
|
|
|
|
dentry = efivarfs_alloc_dentry(root, name);
|
|
|
|
if (IS_ERR(dentry)) {
|
|
|
|
err = PTR_ERR(dentry);
|
|
|
|
goto fail_inode;
|
|
|
|
}
|
|
|
|
|
efi: vars: Don't drop lock in the middle of efivar_init()
Even though the efivars_lock lock is documented as protecting the
efivars->ops pointer (among other things), efivar_init() happily
releases and reacquires the lock for every EFI variable that it
enumerates. This used to be needed because the lock was originally a
spinlock, which prevented the callback that is invoked for every
variable from being able to sleep. However, releasing the lock could
potentially invalidate the ops pointer, but more importantly, it might
allow a SetVariable() runtime service call to take place concurrently,
and the UEFI spec does not define how this affects an enumeration that
is running in parallel using the GetNextVariable() runtime service,
which is what efivar_init() uses.
In the meantime, the lock has been converted into a semaphore, and the
only reason we need to drop the lock is because the efivarfs pseudo
filesystem driver will otherwise deadlock when it invokes the efivars
API from the callback to create the efivar_entry items and insert them
into the linked list. (EFI pstore is affected in a similar way)
So let's switch to helpers that can be used while the lock is already
taken. This way, we can hold on to the lock throughout the enumeration.
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
2022-06-20 23:04:32 +08:00
|
|
|
__efivar_entry_get(entry, NULL, &size, NULL);
|
|
|
|
__efivar_entry_add(entry, &efivarfs_list);
|
2013-02-09 00:27:24 +08:00
|
|
|
|
2016-08-15 22:29:20 +08:00
|
|
|
/* copied by the above to local storage in the dentry. */
|
|
|
|
kfree(name);
|
|
|
|
|
2016-01-23 04:40:57 +08:00
|
|
|
inode_lock(inode);
|
2013-02-09 00:27:24 +08:00
|
|
|
inode->i_private = entry;
|
|
|
|
i_size_write(inode, size + sizeof(entry->var.Attributes));
|
2016-01-23 04:40:57 +08:00
|
|
|
inode_unlock(inode);
|
2013-02-09 00:27:24 +08:00
|
|
|
d_add(dentry, inode);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail_inode:
|
|
|
|
iput(inode);
|
|
|
|
fail_name:
|
|
|
|
kfree(name);
|
|
|
|
fail:
|
|
|
|
kfree(entry);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int efivarfs_destroy(struct efivar_entry *entry, void *data)
|
|
|
|
{
|
2022-06-21 21:48:29 +08:00
|
|
|
efivar_entry_remove(entry);
|
2013-02-09 00:27:24 +08:00
|
|
|
kfree(entry);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-26 00:38:29 +08:00
|
|
|
static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc)
|
2013-02-09 00:27:24 +08:00
|
|
|
{
|
|
|
|
struct inode *inode = NULL;
|
|
|
|
struct dentry *root;
|
|
|
|
int err;
|
|
|
|
|
2023-01-20 00:42:53 +08:00
|
|
|
if (!efivar_is_available())
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2013-02-09 00:27:24 +08:00
|
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 20:29:47 +08:00
|
|
|
sb->s_blocksize = PAGE_SIZE;
|
|
|
|
sb->s_blocksize_bits = PAGE_SHIFT;
|
2013-02-09 00:27:24 +08:00
|
|
|
sb->s_magic = EFIVARFS_MAGIC;
|
|
|
|
sb->s_op = &efivarfs_ops;
|
|
|
|
sb->s_d_op = &efivarfs_d_ops;
|
|
|
|
sb->s_time_gran = 1;
|
|
|
|
|
2020-07-08 18:01:57 +08:00
|
|
|
if (!efivar_supports_writes())
|
|
|
|
sb->s_flags |= SB_RDONLY;
|
|
|
|
|
2016-02-09 03:48:15 +08:00
|
|
|
inode = efivarfs_get_inode(sb, NULL, S_IFDIR | 0755, 0, true);
|
2013-02-09 00:27:24 +08:00
|
|
|
if (!inode)
|
|
|
|
return -ENOMEM;
|
|
|
|
inode->i_op = &efivarfs_dir_inode_operations;
|
|
|
|
|
|
|
|
root = d_make_root(inode);
|
|
|
|
sb->s_root = root;
|
|
|
|
if (!root)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&efivarfs_list);
|
|
|
|
|
2016-05-07 05:39:30 +08:00
|
|
|
err = efivar_init(efivarfs_callback, (void *)sb, true, &efivarfs_list);
|
2013-02-09 00:27:24 +08:00
|
|
|
if (err)
|
2022-06-21 21:48:29 +08:00
|
|
|
efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL);
|
2013-02-09 00:27:24 +08:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2019-03-26 00:38:29 +08:00
|
|
|
static int efivarfs_get_tree(struct fs_context *fc)
|
|
|
|
{
|
|
|
|
return get_tree_single(fc, efivarfs_fill_super);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct fs_context_operations efivarfs_context_ops = {
|
|
|
|
.get_tree = efivarfs_get_tree,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int efivarfs_init_fs_context(struct fs_context *fc)
|
2013-02-09 00:27:24 +08:00
|
|
|
{
|
2019-03-26 00:38:29 +08:00
|
|
|
fc->ops = &efivarfs_context_ops;
|
|
|
|
return 0;
|
2013-02-09 00:27:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void efivarfs_kill_sb(struct super_block *sb)
|
|
|
|
{
|
|
|
|
kill_litter_super(sb);
|
|
|
|
|
2023-01-20 00:42:53 +08:00
|
|
|
if (!efivar_is_available())
|
|
|
|
return;
|
|
|
|
|
2013-02-09 00:27:24 +08:00
|
|
|
/* Remove all entries and destroy */
|
2022-06-21 21:48:29 +08:00
|
|
|
efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL);
|
2013-02-09 00:27:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type efivarfs_type = {
|
2014-10-24 05:20:37 +08:00
|
|
|
.owner = THIS_MODULE,
|
2013-02-09 00:27:24 +08:00
|
|
|
.name = "efivarfs",
|
2019-03-26 00:38:29 +08:00
|
|
|
.init_fs_context = efivarfs_init_fs_context,
|
2013-02-09 00:27:24 +08:00
|
|
|
.kill_sb = efivarfs_kill_sb,
|
|
|
|
};
|
|
|
|
|
|
|
|
static __init int efivarfs_init(void)
|
|
|
|
{
|
|
|
|
return register_filesystem(&efivarfs_type);
|
|
|
|
}
|
|
|
|
|
2014-10-24 05:20:37 +08:00
|
|
|
static __exit void efivarfs_exit(void)
|
|
|
|
{
|
|
|
|
unregister_filesystem(&efivarfs_type);
|
|
|
|
}
|
|
|
|
|
2013-02-09 00:27:24 +08:00
|
|
|
MODULE_AUTHOR("Matthew Garrett, Jeremy Kerr");
|
|
|
|
MODULE_DESCRIPTION("EFI Variable Filesystem");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS_FS("efivarfs");
|
|
|
|
|
|
|
|
module_init(efivarfs_init);
|
2014-10-24 05:20:37 +08:00
|
|
|
module_exit(efivarfs_exit);
|