efi: Make efivarfs entries immutable by default (ed8b0de5) · Commits · e / devices / android_kernel_teracube_mt6765

Documentation/filesystems/efivarfs.txt

+7 −0

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

	mount -t efivarfs none /sys/firmware/efi/efivars		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	Original line	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		* 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		* Note that it's sorted by {vendor,name}, but globbed names must come after
	* any other name with the same prefix.		* 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, "ErrOut", validate_device_path },
	{ EFI_GLOBAL_VARIABLE_GUID, "ErrOutDev", validate_device_path },		{ EFI_GLOBAL_VARIABLE_GUID, "ErrOutDev", validate_device_path },
	{ EFI_GLOBAL_VARIABLE_GUID, "Lang", validate_ascii_string },		{ 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, "PlatformLang", validate_ascii_string },
	{ EFI_GLOBAL_VARIABLE_GUID, "Timeout", validate_uint16 },		{ EFI_GLOBAL_VARIABLE_GUID, "Timeout", validate_uint16 },
	{ NULL_GUID, "", NULL },		{ 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		bool
	efivar_validate(efi_guid_t vendor, efi_char16_t var_name, u8 data,		efivar_validate(efi_guid_t vendor, efi_char16_t var_name, u8 data,
	unsigned long data_size)		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))		if (efi_guidcmp(vendor, variable_validate[i].vendor))
	continue;		continue;

	for (match = 0; ; match++) {		if (variable_matches(utf8_name, utf8_size+1, name, &match)) {
	char c = name[match];		if (variable_validate[i].validate == NULL)
	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)
	break;		break;

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

	kfree(utf8_name);		kfree(utf8_name);
	return true;		return true;
	}		}
	EXPORT_SYMBOL_GPL(efivar_validate);		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		static efi_status_t
	check_var_size(u32 attributes, unsigned long size)		check_var_size(u32 attributes, unsigned long size)
	{		{

fs/efivarfs/file.c

+70 −0

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

	#include "internal.h"		#include "internal.h"

	@@ -103,9 +104,78 @@ static ssize_t efivarfs_file_read(struct file file, char __user userbuf,
	return size;		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 = {		const struct file_operations efivarfs_file_operations = {
	.open = simple_open,		.open = simple_open,
	.read = efivarfs_file_read,		.read = efivarfs_file_read,
	.write = efivarfs_file_write,		.write = efivarfs_file_write,
	.llseek = no_llseek,		.llseek = no_llseek,
			.unlocked_ioctl = efivarfs_file_ioctl,
	};		};

fs/efivarfs/inode.c

+19 −11

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

	struct inode efivarfs_get_inode(struct super_block sb,		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);		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_ino = get_next_ino();
	inode->i_mode = mode;		inode->i_mode = mode;
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
			inode->i_flags = is_removable ? 0 : S_IMMUTABLE;
	switch (mode & S_IFMT) {		switch (mode & S_IFMT) {
	case S_IFREG:		case S_IFREG:
	inode->i_fop = &efivarfs_file_operations;		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,		static int efivarfs_create(struct inode dir, struct dentry dentry,
	umode_t mode, bool excl)		umode_t mode, bool excl)
	{		{
	struct inode *inode;		struct inode *inode = NULL;
	struct efivar_entry *var;		struct efivar_entry *var;
	int namelen, i = 0, err = 0;		int namelen, i = 0, err = 0;
			bool is_removable = false;

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

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

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

	/* length of the variable name itself: remove GUID and separator */		/* length of the variable name itself: remove GUID and separator */
	namelen = dentry->d_name.len - EFI_VARIABLE_GUID_LEN - 1;		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,		efivarfs_hex_to_guid(dentry->d_name.name + namelen + 1,
	&var->var.VendorGuid);		&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++)		for (i = 0; i < namelen; i++)
	var->var.VariableName[i] = dentry->d_name.name[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:		out:
	if (err) {		if (err) {
	kfree(var);		kfree(var);
			if (inode)
	iput(inode);		iput(inode);
	}		}
	return err;		return err;

fs/efivarfs/internal.h

+2 −1

Original line number	Original line	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 const struct inode_operations efivarfs_dir_inode_operations;
	extern bool efivarfs_valid_name(const char *str, int len);		extern bool efivarfs_valid_name(const char *str, int len);
	extern struct inode efivarfs_get_inode(struct super_block sb,		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;		extern struct list_head efivarfs_list;