efi: Make efivarfs entries immutable by default (ed8b0de5) · Commits · 戴 / test

Documentation/filesystems/efivarfs.txt

+7 −0

Original line number	Diff line number	Diff line
		@@ -14,3 +14,10 @@ filesystem.
		efivarfs is typically mounted like this,

		mount -t efivarfs none /sys/firmware/efi/efivars

		Due to the presence of numerous firmware bugs where removing non-standard
		UEFI variables causes the system firmware to fail to POST, efivarfs
		files that are not well-known standardized variables are created
		as immutable files. This doesn't prevent removal - "chattr -i" will work -
		but it does prevent this kind of failure from being accomplished
		accidentally.

drivers/firmware/efi/vars.c

+64 −23

Original line number	Diff line number	Diff line
		@@ -172,10 +172,12 @@ struct variable_validate {
		};

		/*
		* This is the list of variables we need to validate.
		* This is the list of variables we need to validate, as well as the
		* whitelist for what we think is safe not to default to immutable.
		*
		* If it has a validate() method that's not NULL, it'll go into the
		* validation routine. If not, it is assumed valid.
		* validation routine. If not, it is assumed valid, but still used for
		* whitelisting.
		*
		* Note that it's sorted by {vendor,name}, but globbed names must come after
		* any other name with the same prefix.
		@@ -193,11 +195,37 @@ static const struct variable_validate variable_validate[] = {
		{ EFI_GLOBAL_VARIABLE_GUID, "ErrOut", validate_device_path },
		{ EFI_GLOBAL_VARIABLE_GUID, "ErrOutDev", validate_device_path },
		{ EFI_GLOBAL_VARIABLE_GUID, "Lang", validate_ascii_string },
		{ EFI_GLOBAL_VARIABLE_GUID, "OsIndications", NULL },
		{ EFI_GLOBAL_VARIABLE_GUID, "PlatformLang", validate_ascii_string },
		{ EFI_GLOBAL_VARIABLE_GUID, "Timeout", validate_uint16 },
		{ NULL_GUID, "", NULL },
		};

		static bool
		variable_matches(const char var_name, size_t len, const char match_name,
		int *match)
		{
		for (match = 0; ; (match)++) {
		char c = match_name[*match];
		char u = var_name[*match];

		/* Wildcard in the matching name means we've matched */
		if (c == '*')
		return true;

		/* Case sensitive match */
		if (!c && *match == len)
		return true;

		if (c != u)
		return false;

		if (!c)
		return true;
		}
		return true;
		}

		bool
		efivar_validate(efi_guid_t vendor, efi_char16_t var_name, u8 data,
		unsigned long data_size)
		@@ -221,35 +249,48 @@ efivar_validate(efi_guid_t vendor, efi_char16_t var_name, u8 data,
		if (efi_guidcmp(vendor, variable_validate[i].vendor))
		continue;

		for (match = 0; ; match++) {
		char c = name[match];
		char u = utf8_name[match];

		/* Wildcard in the matching name means we've matched */
		if (c == '*') {
		kfree(utf8_name);
		return variable_validate[i].validate(var_name,
		match, data, data_size);
		}

		/* Case sensitive match */
		if (c != u)
		if (variable_matches(utf8_name, utf8_size+1, name, &match)) {
		if (variable_validate[i].validate == NULL)
		break;

		/* Reached the end of the string while matching */
		if (!c) {
		kfree(utf8_name);
		return variable_validate[i].validate(var_name,
		match, data, data_size);
		}
		return variable_validate[i].validate(var_name, match,
		data, data_size);
		}
		}

		kfree(utf8_name);
		return true;
		}
		EXPORT_SYMBOL_GPL(efivar_validate);

		bool
		efivar_variable_is_removable(efi_guid_t vendor, const char *var_name,
		size_t len)
		{
		int i;
		bool found = false;
		int match = 0;

		/*
		* Check if our variable is in the validated variables list
		*/
		for (i = 0; variable_validate[i].name[0] != '\0'; i++) {
		if (efi_guidcmp(variable_validate[i].vendor, vendor))
		continue;

		if (variable_matches(var_name, len,
		variable_validate[i].name, &match)) {
		found = true;
		break;
		}
		}

		/*
		* If it's in our list, it is removable.
		*/
		return found;
		}
		EXPORT_SYMBOL_GPL(efivar_variable_is_removable);

		static efi_status_t
		check_var_size(u32 attributes, unsigned long size)
		{

fs/efivarfs/file.c

+70 −0

Original line number	Diff line number	Diff line
		@@ -10,6 +10,7 @@
		#include <linux/efi.h>
		#include <linux/fs.h>
		#include <linux/slab.h>
		#include <linux/mount.h>

		#include "internal.h"

		@@ -103,9 +104,78 @@ out_free:
		return size;
		}

		static int
		efivarfs_ioc_getxflags(struct file file, void __user arg)
		{
		struct inode *inode = file->f_mapping->host;
		unsigned int i_flags;
		unsigned int flags = 0;

		i_flags = inode->i_flags;
		if (i_flags & S_IMMUTABLE)
		flags \|= FS_IMMUTABLE_FL;

		if (copy_to_user(arg, &flags, sizeof(flags)))
		return -EFAULT;
		return 0;
		}

		static int
		efivarfs_ioc_setxflags(struct file file, void __user arg)
		{
		struct inode *inode = file->f_mapping->host;
		unsigned int flags;
		unsigned int i_flags = 0;
		int error;

		if (!inode_owner_or_capable(inode))
		return -EACCES;

		if (copy_from_user(&flags, arg, sizeof(flags)))
		return -EFAULT;

		if (flags & ~FS_IMMUTABLE_FL)
		return -EOPNOTSUPP;

		if (!capable(CAP_LINUX_IMMUTABLE))
		return -EPERM;

		if (flags & FS_IMMUTABLE_FL)
		i_flags \|= S_IMMUTABLE;


		error = mnt_want_write_file(file);
		if (error)
		return error;

		inode_lock(inode);
		inode_set_flags(inode, i_flags, S_IMMUTABLE);
		inode_unlock(inode);

		mnt_drop_write_file(file);

		return 0;
		}

		long
		efivarfs_file_ioctl(struct file *file, unsigned int cmd, unsigned long p)
		{
		void __user arg = (void __user )p;

		switch (cmd) {
		case FS_IOC_GETFLAGS:
		return efivarfs_ioc_getxflags(file, arg);
		case FS_IOC_SETFLAGS:
		return efivarfs_ioc_setxflags(file, arg);
		}

		return -ENOTTY;
		}

		const struct file_operations efivarfs_file_operations = {
		.open = simple_open,
		.read = efivarfs_file_read,
		.write = efivarfs_file_write,
		.llseek = no_llseek,
		.unlocked_ioctl = efivarfs_file_ioctl,
		};

fs/efivarfs/inode.c

+19 −11

Original line number	Diff line number	Diff line
		@@ -15,7 +15,8 @@
		#include "internal.h"

		struct inode efivarfs_get_inode(struct super_block sb,
		const struct inode *dir, int mode, dev_t dev)
		const struct inode *dir, int mode,
		dev_t dev, bool is_removable)
		{
		struct inode *inode = new_inode(sb);

		@@ -23,6 +24,7 @@ struct inode efivarfs_get_inode(struct super_block sb,
		inode->i_ino = get_next_ino();
		inode->i_mode = mode;
		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
		inode->i_flags = is_removable ? 0 : S_IMMUTABLE;
		switch (mode & S_IFMT) {
		case S_IFREG:
		inode->i_fop = &efivarfs_file_operations;
		@@ -102,22 +104,17 @@ static void efivarfs_hex_to_guid(const char str, efi_guid_t guid)
		static int efivarfs_create(struct inode dir, struct dentry dentry,
		umode_t mode, bool excl)
		{
		struct inode *inode;
		struct inode *inode = NULL;
		struct efivar_entry *var;
		int namelen, i = 0, err = 0;
		bool is_removable = false;

		if (!efivarfs_valid_name(dentry->d_name.name, dentry->d_name.len))
		return -EINVAL;

		inode = efivarfs_get_inode(dir->i_sb, dir, mode, 0);
		if (!inode)
		return -ENOMEM;

		var = kzalloc(sizeof(struct efivar_entry), GFP_KERNEL);
		if (!var) {
		err = -ENOMEM;
		goto out;
		}
		if (!var)
		return -ENOMEM;

		/* length of the variable name itself: remove GUID and separator */
		namelen = dentry->d_name.len - EFI_VARIABLE_GUID_LEN - 1;
		@@ -125,6 +122,16 @@ static int efivarfs_create(struct inode dir, struct dentry dentry,
		efivarfs_hex_to_guid(dentry->d_name.name + namelen + 1,
		&var->var.VendorGuid);

		if (efivar_variable_is_removable(var->var.VendorGuid,
		dentry->d_name.name, namelen))
		is_removable = true;

		inode = efivarfs_get_inode(dir->i_sb, dir, mode, 0, is_removable);
		if (!inode) {
		err = -ENOMEM;
		goto out;
		}

		for (i = 0; i < namelen; i++)
		var->var.VariableName[i] = dentry->d_name.name[i];

		@@ -138,6 +145,7 @@ static int efivarfs_create(struct inode dir, struct dentry dentry,
		out:
		if (err) {
		kfree(var);
		if (inode)
		iput(inode);
		}
		return err;

fs/efivarfs/internal.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -15,7 +15,8 @@ extern const struct file_operations efivarfs_file_operations;
		extern const struct inode_operations efivarfs_dir_inode_operations;
		extern bool efivarfs_valid_name(const char *str, int len);
		extern struct inode efivarfs_get_inode(struct super_block sb,
		const struct inode *dir, int mode, dev_t dev);
		const struct inode *dir, int mode, dev_t dev,
		bool is_removable);

		extern struct list_head efivarfs_list;

Admin message