Merge tag 'efi-urgent' of... (4682c211) · Commits · e / devices / android_kernel_fairphone_FP3

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/efivars.c

+14 −21

Original line number	Original line	Diff line number	Diff line
	@@ -221,7 +221,7 @@ sanity_check(struct efi_variable var, efi_char16_t name, efi_guid_t vendor,
	}		}

	if ((attributes & ~EFI_VARIABLE_MASK) != 0 \|\|		if ((attributes & ~EFI_VARIABLE_MASK) != 0 \|\|
	efivar_validate(name, data, size) == false) {		efivar_validate(vendor, name, data, size) == false) {
	printk(KERN_ERR "efivars: Malformed variable content\n");		printk(KERN_ERR "efivars: Malformed variable content\n");
	return -EINVAL;		return -EINVAL;
	}		}
	@@ -447,7 +447,8 @@ static ssize_t efivar_create(struct file filp, struct kobject kobj,
	}		}

	if ((attributes & ~EFI_VARIABLE_MASK) != 0 \|\|		if ((attributes & ~EFI_VARIABLE_MASK) != 0 \|\|
	efivar_validate(name, data, size) == false) {		efivar_validate(new_var->VendorGuid, name, data,
			size) == false) {
	printk(KERN_ERR "efivars: Malformed variable content\n");		printk(KERN_ERR "efivars: Malformed variable content\n");
	return -EINVAL;		return -EINVAL;
	}		}
	@@ -540,38 +541,30 @@ static ssize_t efivar_delete(struct file filp, struct kobject kobj,
	static int		static int
	efivar_create_sysfs_entry(struct efivar_entry *new_var)		efivar_create_sysfs_entry(struct efivar_entry *new_var)
	{		{
	int i, short_name_size;		int short_name_size;
	char *short_name;		char *short_name;
	unsigned long variable_name_size;		unsigned long utf8_name_size;
	efi_char16_t *variable_name;		efi_char16_t *variable_name = new_var->var.VariableName;
	int ret;		int ret;

	variable_name = new_var->var.VariableName;
	variable_name_size = ucs2_strlen(variable_name) * sizeof(efi_char16_t);

	/*		/*
	* Length of the variable bytes in ASCII, plus the '-' separator,		* Length of the variable bytes in UTF8, plus the '-' separator,
	* plus the GUID, plus trailing NUL		* plus the GUID, plus trailing NUL
	*/		*/
	short_name_size = variable_name_size / sizeof(efi_char16_t)		utf8_name_size = ucs2_utf8size(variable_name);
	+ 1 + EFI_VARIABLE_GUID_LEN + 1;		short_name_size = utf8_name_size + 1 + EFI_VARIABLE_GUID_LEN + 1;

	short_name = kzalloc(short_name_size, GFP_KERNEL);

			short_name = kmalloc(short_name_size, GFP_KERNEL);
	if (!short_name)		if (!short_name)
	return -ENOMEM;		return -ENOMEM;

	/* Convert Unicode to normal chars (assume top bits are 0),		ucs2_as_utf8(short_name, variable_name, short_name_size);
	ala UTF-8 */
	for (i=0; i < (int)(variable_name_size / sizeof(efi_char16_t)); i++) {
	short_name[i] = variable_name[i] & 0xFF;
	}
	/* This is ugly, but necessary to separate one vendor's		/* This is ugly, but necessary to separate one vendor's
	private variables from another's. */		private variables from another's. */
			short_name[utf8_name_size] = '-';
	*(short_name + strlen(short_name)) = '-';
	efi_guid_to_str(&new_var->var.VendorGuid,		efi_guid_to_str(&new_var->var.VendorGuid,
	short_name + strlen(short_name));		short_name + utf8_name_size + 1);

	new_var->kobj.kset = efivars_kset;		new_var->kobj.kset = efivars_kset;

drivers/firmware/efi/vars.c

+104 −39

Original line number	Original line	Diff line number	Diff line
	@@ -165,67 +165,132 @@ validate_ascii_string(efi_char16_t var_name, int match, u8 buffer,
	}		}

	struct variable_validate {		struct variable_validate {
			efi_guid_t vendor;
	char *name;		char *name;
	bool (validate)(efi_char16_t var_name, int match, u8 *data,		bool (validate)(efi_char16_t var_name, int match, u8 *data,
	unsigned long len);		unsigned long len);
	};		};

			/*
			* 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, 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.
			*/
	static const struct variable_validate variable_validate[] = {		static const struct variable_validate variable_validate[] = {
	{ "BootNext", validate_uint16 },		{ EFI_GLOBAL_VARIABLE_GUID, "BootNext", validate_uint16 },
	{ "BootOrder", validate_boot_order },		{ EFI_GLOBAL_VARIABLE_GUID, "BootOrder", validate_boot_order },
	{ "DriverOrder", validate_boot_order },		{ EFI_GLOBAL_VARIABLE_GUID, "Boot*", validate_load_option },
	{ "Boot*", validate_load_option },		{ EFI_GLOBAL_VARIABLE_GUID, "DriverOrder", validate_boot_order },
	{ "Driver*", validate_load_option },		{ EFI_GLOBAL_VARIABLE_GUID, "Driver*", validate_load_option },
	{ "ConIn", validate_device_path },		{ EFI_GLOBAL_VARIABLE_GUID, "ConIn", validate_device_path },
	{ "ConInDev", validate_device_path },		{ EFI_GLOBAL_VARIABLE_GUID, "ConInDev", validate_device_path },
	{ "ConOut", validate_device_path },		{ EFI_GLOBAL_VARIABLE_GUID, "ConOut", validate_device_path },
	{ "ConOutDev", validate_device_path },		{ EFI_GLOBAL_VARIABLE_GUID, "ConOutDev", validate_device_path },
	{ "ErrOut", validate_device_path },		{ EFI_GLOBAL_VARIABLE_GUID, "ErrOut", validate_device_path },
	{ "ErrOutDev", validate_device_path },		{ EFI_GLOBAL_VARIABLE_GUID, "ErrOutDev", validate_device_path },
	{ "Timeout", validate_uint16 },		{ EFI_GLOBAL_VARIABLE_GUID, "Lang", validate_ascii_string },
	{ "Lang", validate_ascii_string },		{ EFI_GLOBAL_VARIABLE_GUID, "OsIndications", NULL },
	{ "PlatformLang", validate_ascii_string },		{ EFI_GLOBAL_VARIABLE_GUID, "PlatformLang", validate_ascii_string },
	{ "", NULL },		{ EFI_GLOBAL_VARIABLE_GUID, "Timeout", validate_uint16 },
			{ NULL_GUID, "", NULL },
	};		};

	bool		static bool
	efivar_validate(efi_char16_t var_name, u8 data, unsigned long len)		variable_matches(const char var_name, size_t len, const char match_name,
			int *match)
	{		{
	int i;		for (match = 0; ; (match)++) {
	u16 *unicode_name = var_name;		char c = match_name[*match];
			char u = var_name[*match];
	for (i = 0; variable_validate[i].validate != NULL; i++) {
	const char *name = variable_validate[i].name;
	int match;

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

	/* All special variables are plain ascii */
	if (u > 127)
	return true;

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

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

	if (c != u)		if (c != u)
	break;		return false;

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

			bool
			efivar_validate(efi_guid_t vendor, efi_char16_t var_name, u8 data,
			unsigned long data_size)
			{
			int i;
			unsigned long utf8_size;
			u8 *utf8_name;

			utf8_size = ucs2_utf8size(var_name);
			utf8_name = kmalloc(utf8_size + 1, GFP_KERNEL);
			if (!utf8_name)
			return false;

			ucs2_as_utf8(utf8_name, var_name, utf8_size);
			utf8_name[utf8_size] = '\0';

			for (i = 0; variable_validate[i].name[0] != '\0'; i++) {
			const char *name = variable_validate[i].name;
			int match = 0;

			if (efi_guidcmp(vendor, variable_validate[i].vendor))
			continue;

			if (variable_matches(utf8_name, utf8_size+1, name, &match)) {
			if (variable_validate[i].validate == NULL)
			break;
			kfree(utf8_name);
			return variable_validate[i].validate(var_name, match,
			data, data_size);
			}
			}
			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)
	{		{
	@@ -852,7 +917,7 @@ int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes,

	*set = false;		*set = false;

	if (efivar_validate(name, data, *size) == false)		if (efivar_validate(vendor, name, data, size) == false)
	return -EINVAL;		return -EINVAL;

	/*		/*

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;