[mirror_ubuntu-hirsute-kernel.git] / drivers / acpi / custom_method.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * custom_method.c - debugfs interface for customizing ACPI control method
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/uaccess.h>
#include <linux/debugfs.h>
#include <linux/acpi.h>
#include <linux/security.h>

#include "internal.h"

#define _COMPONENT		ACPI_SYSTEM_COMPONENT
ACPI_MODULE_NAME("custom_method");
MODULE_LICENSE("GPL");

static struct dentry *cm_dentry;

/* /sys/kernel/debug/acpi/custom_method */

static ssize_t cm_write(struct file *file, const char __user * user_buf,
			size_t count, loff_t *ppos)
{
	static char *buf;
	static u32 max_size;
	static u32 uncopied_bytes;

	struct acpi_table_header table;
	acpi_status status;
	int ret;

	ret = security_locked_down(LOCKDOWN_ACPI_TABLES);
	if (ret)
		return ret;

	if (!(*ppos)) {
		/* parse the table header to get the table length */
		if (count <= sizeof(struct acpi_table_header))
			return -EINVAL;
		if (copy_from_user(&table, user_buf,
				   sizeof(struct acpi_table_header)))
			return -EFAULT;
		uncopied_bytes = max_size = table.length;
		buf = kzalloc(max_size, GFP_KERNEL);
		if (!buf)
			return -ENOMEM;
	}

	if (buf == NULL)
		return -EINVAL;

	if ((*ppos > max_size) ||
	    (*ppos + count > max_size) ||
	    (*ppos + count < count) ||
	    (count > uncopied_bytes)) {
		kfree(buf);
		return -EINVAL;
	}

	if (copy_from_user(buf + (*ppos), user_buf, count)) {
		kfree(buf);
		buf = NULL;
		return -EFAULT;
	}

	uncopied_bytes -= count;
	*ppos += count;

	if (!uncopied_bytes) {
		status = acpi_install_method(buf);
		kfree(buf);
		buf = NULL;
		if (ACPI_FAILURE(status))
			return -EINVAL;
		add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
	}

	kfree(buf);
	return count;
}

static const struct file_operations cm_fops = {
	.write = cm_write,
	.llseek = default_llseek,
};

static int __init acpi_custom_method_init(void)
{
	cm_dentry = debugfs_create_file("custom_method", S_IWUSR,
					acpi_debugfs_dir, NULL, &cm_fops);
	return 0;
}

static void __exit acpi_custom_method_exit(void)
{
	debugfs_remove(cm_dentry);
}

module_init(acpi_custom_method_init);
module_exit(acpi_custom_method_exit);
Commit	Line	Data
09c434b8	1	// SPDX-License-Identifier: GPL-2.0-only
526b4af4	2	/*
5baa1be1	3	* custom_method.c - debugfs interface for customizing ACPI control method
526b4af4 TR	4	*/
	5
	6	#include <linux/init.h>
	7	#include <linux/module.h>
	8	#include <linux/kernel.h>
	9	#include <linux/uaccess.h>
	10	#include <linux/debugfs.h>
8b48463f	11	#include <linux/acpi.h>
f474e148	12	#include <linux/security.h>
526b4af4 TR	13
	14	#include "internal.h"
	15
	16	#define _COMPONENT ACPI_SYSTEM_COMPONENT
	17	ACPI_MODULE_NAME("custom_method");
	18	MODULE_LICENSE("GPL");
	19
	20	static struct dentry *cm_dentry;
	21
	22	/* /sys/kernel/debug/acpi/custom_method */
	23
	24	static ssize_t cm_write(struct file file, const char __user user_buf,
	25	size_t count, loff_t *ppos)
	26	{
	27	static char *buf;
	28	static u32 max_size;
	29	static u32 uncopied_bytes;
	30
	31	struct acpi_table_header table;
	32	acpi_status status;
f474e148 MG	33	int ret;
	34
	35	ret = security_locked_down(LOCKDOWN_ACPI_TABLES);
	36	if (ret)
	37	return ret;
526b4af4 TR	38
	39	if (!(*ppos)) {
	40	/* parse the table header to get the table length */
	41	if (count <= sizeof(struct acpi_table_header))
	42	return -EINVAL;
	43	if (copy_from_user(&table, user_buf,
	44	sizeof(struct acpi_table_header)))
	45	return -EFAULT;
	46	uncopied_bytes = max_size = table.length;
	47	buf = kzalloc(max_size, GFP_KERNEL);
	48	if (!buf)
	49	return -ENOMEM;
	50	}
	51
	52	if (buf == NULL)
	53	return -EINVAL;
	54
	55	if ((*ppos > max_size) \|\|
	56	(*ppos + count > max_size) \|\|
	57	(*ppos + count < count) \|\|
03d1571d WW	58	(count > uncopied_bytes)) {
03d1571d WW	59	kfree(buf);
526b4af4	60	return -EINVAL;
03d1571d	61	}
526b4af4 TR	62
	63	if (copy_from_user(buf + (*ppos), user_buf, count)) {
	64	kfree(buf);
	65	buf = NULL;
	66	return -EFAULT;
	67	}
	68
	69	uncopied_bytes -= count;
	70	*ppos += count;
	71
	72	if (!uncopied_bytes) {
	73	status = acpi_install_method(buf);
	74	kfree(buf);
	75	buf = NULL;
	76	if (ACPI_FAILURE(status))
	77	return -EINVAL;
373d4d09	78	add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
526b4af4 TR	79	}
526b4af4 TR	80
03d1571d	81	kfree(buf);
526b4af4 TR	82	return count;
	83	}
	84
	85	static const struct file_operations cm_fops = {
	86	.write = cm_write,
	87	.llseek = default_llseek,
	88	};
	89
	90	static int __init acpi_custom_method_init(void)
	91	{
526b4af4 TR	92	cm_dentry = debugfs_create_file("custom_method", S_IWUSR,
526b4af4 TR	93	acpi_debugfs_dir, NULL, &cm_fops);
526b4af4 TR	94	return 0;
	95	}
	96
	97	static void __exit acpi_custom_method_exit(void)
	98	{
7e79a692	99	debugfs_remove(cm_dentry);
447a5647	100	}
526b4af4 TR	101
	102	module_init(acpi_custom_method_init);
	103	module_exit(acpi_custom_method_exit);