[mirror_ubuntu-focal-kernel.git] / arch / alpha / kernel / srm_env.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * srm_env.c - Access to SRM environment
 *             variables through linux' procfs
 *
 * (C) 2001,2002,2006 by Jan-Benedict Glaw <jbglaw@lug-owl.de>
 *
 * This driver is a modified version of Erik Mouw's example proc
 * interface, so: thank you, Erik! He can be reached via email at
 * <J.A.K.Mouw@its.tudelft.nl>. It is based on an idea
 * provided by DEC^WCompaq^WIntel's "Jumpstart" CD. They
 * included a patch like this as well. Thanks for idea!
 */

#include <linux/kernel.h>
#include <linux/gfp.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/console.h>
#include <linux/uaccess.h>
#include <asm/machvec.h>

#define BASE_DIR	"srm_environment"	/* Subdir in /proc/		*/
#define NAMED_DIR	"named_variables"	/* Subdir for known variables	*/
#define NUMBERED_DIR	"numbered_variables"	/* Subdir for all variables	*/
#define VERSION		"0.0.6"			/* Module version		*/
#define NAME		"srm_env"		/* Module name			*/

MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
MODULE_DESCRIPTION("Accessing Alpha SRM environment through procfs interface");
MODULE_LICENSE("GPL");

typedef struct _srm_env {
	char			*name;
	unsigned long		id;
} srm_env_t;

static struct proc_dir_entry	*base_dir;
static struct proc_dir_entry	*named_dir;
static struct proc_dir_entry	*numbered_dir;

static srm_env_t	srm_named_entries[] = {
	{ "auto_action",	ENV_AUTO_ACTION		},
	{ "boot_dev",		ENV_BOOT_DEV		},
	{ "bootdef_dev",	ENV_BOOTDEF_DEV		},
	{ "booted_dev",		ENV_BOOTED_DEV		},
	{ "boot_file",		ENV_BOOT_FILE		},
	{ "booted_file",	ENV_BOOTED_FILE		},
	{ "boot_osflags",	ENV_BOOT_OSFLAGS	},
	{ "booted_osflags",	ENV_BOOTED_OSFLAGS	},
	{ "boot_reset",		ENV_BOOT_RESET		},
	{ "dump_dev",		ENV_DUMP_DEV		},
	{ "enable_audit",	ENV_ENABLE_AUDIT	},
	{ "license",		ENV_LICENSE		},
	{ "char_set",		ENV_CHAR_SET		},
	{ "language",		ENV_LANGUAGE		},
	{ "tty_dev",		ENV_TTY_DEV		},
	{ NULL,			0			},
};

static int srm_env_proc_show(struct seq_file *m, void *v)
{
	unsigned long	ret;
	unsigned long	id = (unsigned long)m->private;
	char		*page;

	page = (char *)__get_free_page(GFP_USER);
	if (!page)
		return -ENOMEM;

	ret = callback_getenv(id, page, PAGE_SIZE);

	if ((ret >> 61) == 0) {
		seq_write(m, page, ret);
		ret = 0;
	} else
		ret = -EFAULT;
	free_page((unsigned long)page);
	return ret;
}

static int srm_env_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, srm_env_proc_show, PDE_DATA(inode));
}

static ssize_t srm_env_proc_write(struct file *file, const char __user *buffer,
				  size_t count, loff_t *pos)
{
	int res;
	unsigned long	id = (unsigned long)PDE_DATA(file_inode(file));
	char		*buf = (char *) __get_free_page(GFP_USER);
	unsigned long	ret1, ret2;

	if (!buf)
		return -ENOMEM;

	res = -EINVAL;
	if (count >= PAGE_SIZE)
		goto out;

	res = -EFAULT;
	if (copy_from_user(buf, buffer, count))
		goto out;
	buf[count] = '\0';

	ret1 = callback_setenv(id, buf, count);
	if ((ret1 >> 61) == 0) {
		do
			ret2 = callback_save_env();
		while((ret2 >> 61) == 1);
		res = (int) ret1;
	}

 out:
	free_page((unsigned long)buf);
	return res;
}

static const struct file_operations srm_env_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= srm_env_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= srm_env_proc_write,
};

static int __init
srm_env_init(void)
{
	srm_env_t	*entry;
	unsigned long	var_num;

	/*
	 * Check system
	 */
	if (!alpha_using_srm) {
		printk(KERN_INFO "%s: This Alpha system doesn't "
				"know about SRM (or you've booted "
				"SRM->MILO->Linux, which gets "
				"misdetected)...\n", __func__);
		return -ENODEV;
	}

	/*
	 * Create base directory
	 */
	base_dir = proc_mkdir(BASE_DIR, NULL);
	if (!base_dir) {
		printk(KERN_ERR "Couldn't create base dir /proc/%s\n",
				BASE_DIR);
		return -ENOMEM;
	}

	/*
	 * Create per-name subdirectory
	 */
	named_dir = proc_mkdir(NAMED_DIR, base_dir);
	if (!named_dir) {
		printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
				BASE_DIR, NAMED_DIR);
		goto cleanup;
	}

	/*
	 * Create per-number subdirectory
	 */
	numbered_dir = proc_mkdir(NUMBERED_DIR, base_dir);
	if (!numbered_dir) {
		printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
				BASE_DIR, NUMBERED_DIR);
		goto cleanup;

	}

	/*
	 * Create all named nodes
	 */
	entry = srm_named_entries;
	while (entry->name && entry->id) {
		if (!proc_create_data(entry->name, 0644, named_dir,
			     &srm_env_proc_fops, (void *)entry->id))
			goto cleanup;
		entry++;
	}

	/*
	 * Create all numbered nodes
	 */
	for (var_num = 0; var_num <= 255; var_num++) {
		char name[4];
		sprintf(name, "%ld", var_num);
		if (!proc_create_data(name, 0644, numbered_dir,
			     &srm_env_proc_fops, (void *)var_num))
			goto cleanup;
	}

	printk(KERN_INFO "%s: version %s loaded successfully\n", NAME,
			VERSION);

	return 0;

cleanup:
	remove_proc_subtree(BASE_DIR, NULL);
	return -ENOMEM;
}

static void __exit
srm_env_exit(void)
{
	remove_proc_subtree(BASE_DIR, NULL);
	printk(KERN_INFO "%s: unloaded successfully\n", NAME);
}

module_init(srm_env_init);
module_exit(srm_env_exit);
Commit	Line	Data
45051539	1	// SPDX-License-Identifier: GPL-2.0-only
1da177e4 LT	2	/*
	3	* srm_env.c - Access to SRM environment
	4	* variables through linux' procfs
	5	*
16b7f4dc	6	* (C) 2001,2002,2006 by Jan-Benedict Glaw <jbglaw@lug-owl.de>
1da177e4	7	*
395cf969 PB	8	* This driver is a modified version of Erik Mouw's example proc
395cf969 PB	9	* interface, so: thank you, Erik! He can be reached via email at
1da177e4 LT	10	* <J.A.K.Mouw@its.tudelft.nl>. It is based on an idea
	11	* provided by DEC^WCompaq^WIntel's "Jumpstart" CD. They
	12	* included a patch like this as well. Thanks for idea!
1da177e4 LT	13	*/
1da177e4 LT	14
1da177e4	15	#include <linux/kernel.h>
5a0e3ad6	16	#include <linux/gfp.h>
1da177e4 LT	17	#include <linux/module.h>
	18	#include <linux/init.h>
	19	#include <linux/proc_fs.h>
0ead0f84	20	#include <linux/seq_file.h>
1da177e4	21	#include <asm/console.h>
7c0f6ba6	22	#include <linux/uaccess.h>
1da177e4 LT	23	#include <asm/machvec.h>
	24
	25	#define BASE_DIR "srm_environment" /* Subdir in /proc/ */
	26	#define NAMED_DIR "named_variables" /* Subdir for known variables */
	27	#define NUMBERED_DIR "numbered_variables" /* Subdir for all variables */
16b7f4dc	28	#define VERSION "0.0.6" /* Module version */
1da177e4 LT	29	#define NAME "srm_env" /* Module name */
	30
	31	MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
	32	MODULE_DESCRIPTION("Accessing Alpha SRM environment through procfs interface");
	33	MODULE_LICENSE("GPL");
	34
	35	typedef struct _srm_env {
	36	char *name;
	37	unsigned long id;
1da177e4 LT	38	} srm_env_t;
	39
	40	static struct proc_dir_entry *base_dir;
	41	static struct proc_dir_entry *named_dir;
	42	static struct proc_dir_entry *numbered_dir;
1da177e4 LT	43
	44	static srm_env_t srm_named_entries[] = {
	45	{ "auto_action", ENV_AUTO_ACTION },
	46	{ "boot_dev", ENV_BOOT_DEV },
	47	{ "bootdef_dev", ENV_BOOTDEF_DEV },
	48	{ "booted_dev", ENV_BOOTED_DEV },
	49	{ "boot_file", ENV_BOOT_FILE },
	50	{ "booted_file", ENV_BOOTED_FILE },
	51	{ "boot_osflags", ENV_BOOT_OSFLAGS },
	52	{ "booted_osflags", ENV_BOOTED_OSFLAGS },
	53	{ "boot_reset", ENV_BOOT_RESET },
	54	{ "dump_dev", ENV_DUMP_DEV },
	55	{ "enable_audit", ENV_ENABLE_AUDIT },
	56	{ "license", ENV_LICENSE },
	57	{ "char_set", ENV_CHAR_SET },
	58	{ "language", ENV_LANGUAGE },
	59	{ "tty_dev", ENV_TTY_DEV },
	60	{ NULL, 0 },
	61	};
1da177e4	62
0ead0f84	63	static int srm_env_proc_show(struct seq_file m, void v)
1da177e4	64	{
1da177e4	65	unsigned long ret;
1c1ec6c6	66	unsigned long id = (unsigned long)m->private;
0ead0f84	67	char *page;
1da177e4	68
0ead0f84 AD	69	page = (char *)__get_free_page(GFP_USER);
	70	if (!page)
	71	return -ENOMEM;
1da177e4	72
1c1ec6c6	73	ret = callback_getenv(id, page, PAGE_SIZE);
1da177e4	74
16b7f4dc	75	if ((ret >> 61) == 0) {
0ead0f84 AD	76	seq_write(m, page, ret);
0ead0f84 AD	77	ret = 0;
16b7f4dc	78	} else
0ead0f84 AD	79	ret = -EFAULT;
	80	free_page((unsigned long)page);
	81	return ret;
	82	}
1da177e4	83
0ead0f84 AD	84	static int srm_env_proc_open(struct inode inode, struct file file)
0ead0f84 AD	85	{
d9dda78b	86	return single_open(file, srm_env_proc_show, PDE_DATA(inode));
1da177e4 LT	87	}
1da177e4 LT	88
0ead0f84 AD	89	static ssize_t srm_env_proc_write(struct file file, const char __user buffer,
0ead0f84 AD	90	size_t count, loff_t *pos)
1da177e4 LT	91	{
1da177e4 LT	92	int res;
1c1ec6c6	93	unsigned long id = (unsigned long)PDE_DATA(file_inode(file));
1da177e4 LT	94	char buf = (char ) __get_free_page(GFP_USER);
	95	unsigned long ret1, ret2;
	96
1da177e4 LT	97	if (!buf)
	98	return -ENOMEM;
	99
	100	res = -EINVAL;
	101	if (count >= PAGE_SIZE)
	102	goto out;
	103
	104	res = -EFAULT;
	105	if (copy_from_user(buf, buffer, count))
	106	goto out;
	107	buf[count] = '\0';
	108
1c1ec6c6	109	ret1 = callback_setenv(id, buf, count);
1da177e4	110	if ((ret1 >> 61) == 0) {
16b7f4dc	111	do
1da177e4 LT	112	ret2 = callback_save_env();
	113	while((ret2 >> 61) == 1);
	114	res = (int) ret1;
	115	}
	116
	117	out:
	118	free_page((unsigned long)buf);
	119	return res;
	120	}
	121
0ead0f84 AD	122	static const struct file_operations srm_env_proc_fops = {
	123	.owner = THIS_MODULE,
	124	.open = srm_env_proc_open,
	125	.read = seq_read,
	126	.llseek = seq_lseek,
	127	.release = single_release,
	128	.write = srm_env_proc_write,
	129	};
	130
1da177e4 LT	131	static int __init
	132	srm_env_init(void)
	133	{
	134	srm_env_t *entry;
	135	unsigned long var_num;
	136
	137	/*
	138	* Check system
	139	*/
16b7f4dc	140	if (!alpha_using_srm) {
1da177e4 LT	141	printk(KERN_INFO "%s: This Alpha system doesn't "
	142	"know about SRM (or you've booted "
	143	"SRM->MILO->Linux, which gets "
bbb8d343	144	"misdetected)...\n", __func__);
1da177e4 LT	145	return -ENODEV;
	146	}
	147
1da177e4 LT	148	/*
	149	* Create base directory
	150	*/
	151	base_dir = proc_mkdir(BASE_DIR, NULL);
16b7f4dc	152	if (!base_dir) {
1da177e4 LT	153	printk(KERN_ERR "Couldn't create base dir /proc/%s\n",
1da177e4 LT	154	BASE_DIR);
c35f2e49	155	return -ENOMEM;
1da177e4	156	}
1da177e4 LT	157
	158	/*
	159	* Create per-name subdirectory
	160	*/
	161	named_dir = proc_mkdir(NAMED_DIR, base_dir);
16b7f4dc	162	if (!named_dir) {
1da177e4 LT	163	printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
	164	BASE_DIR, NAMED_DIR);
	165	goto cleanup;
	166	}
1da177e4 LT	167
	168	/*
	169	* Create per-number subdirectory
	170	*/
	171	numbered_dir = proc_mkdir(NUMBERED_DIR, base_dir);
16b7f4dc	172	if (!numbered_dir) {
1da177e4 LT	173	printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
	174	BASE_DIR, NUMBERED_DIR);
	175	goto cleanup;
	176
	177	}
1da177e4 LT	178
	179	/*
	180	* Create all named nodes
	181	*/
	182	entry = srm_named_entries;
16b7f4dc	183	while (entry->name && entry->id) {
c35f2e49	184	if (!proc_create_data(entry->name, 0644, named_dir,
1c1ec6c6	185	&srm_env_proc_fops, (void *)entry->id))
1da177e4	186	goto cleanup;
1da177e4 LT	187	entry++;
	188	}
	189
	190	/*
	191	* Create all numbered nodes
	192	*/
16b7f4dc	193	for (var_num = 0; var_num <= 255; var_num++) {
1c1ec6c6 AV	194	char name[4];
	195	sprintf(name, "%ld", var_num);
	196	if (!proc_create_data(name, 0644, numbered_dir,
	197	&srm_env_proc_fops, (void *)var_num))
1da177e4	198	goto cleanup;
1da177e4 LT	199	}
	200
	201	printk(KERN_INFO "%s: version %s loaded successfully\n", NAME,
	202	VERSION);
	203
	204	return 0;
	205
	206	cleanup:
c35f2e49	207	remove_proc_subtree(BASE_DIR, NULL);
1da177e4 LT	208	return -ENOMEM;
	209	}
	210
1da177e4 LT	211	static void __exit
	212	srm_env_exit(void)
	213	{
c35f2e49	214	remove_proc_subtree(BASE_DIR, NULL);
1da177e4	215	printk(KERN_INFO "%s: unloaded successfully\n", NAME);
1da177e4 LT	216	}
1da177e4 LT	217
1da177e4 LT	218	module_init(srm_env_init);
1da177e4 LT	219	module_exit(srm_env_exit);