[linux-2.6-block.git] / kernel / utsname_sysctl.c

/*
 *  Copyright (C) 2007
 *
 *  Author: Eric Biederman <ebiederm@xmision.com>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation, version 2 of the
 *  License.
 */

#include <linux/module.h>
#include <linux/uts.h>
#include <linux/utsname.h>
#include <linux/sysctl.h>

static void *get_uts(ctl_table *table, int write)
{
	char *which = table->data;
	struct uts_namespace *uts_ns;

	uts_ns = current->nsproxy->uts_ns;
	which = (which - (char *)&init_uts_ns) + (char *)uts_ns;

	if (!write)
		down_read(&uts_sem);
	else
		down_write(&uts_sem);
	return which;
}

static void put_uts(ctl_table *table, int write, void *which)
{
	if (!write)
		up_read(&uts_sem);
	else
		up_write(&uts_sem);
}

#ifdef CONFIG_PROC_FS
/*
 *	Special case of dostring for the UTS structure. This has locks
 *	to observe. Should this be in kernel/sys.c ????
 */
static int proc_do_uts_string(ctl_table *table, int write, struct file *filp,
		  void __user *buffer, size_t *lenp, loff_t *ppos)
{
	struct ctl_table uts_table;
	int r;
	memcpy(&uts_table, table, sizeof(uts_table));
	uts_table.data = get_uts(table, write);
	r = proc_dostring(&uts_table,write,filp,buffer,lenp, ppos);
	put_uts(table, write, uts_table.data);
	return r;
}
#else
#define proc_do_uts_string NULL
#endif


#ifdef CONFIG_SYSCTL_SYSCALL
/* The generic string strategy routine: */
static int sysctl_uts_string(ctl_table *table,
		  void __user *oldval, size_t __user *oldlenp,
		  void __user *newval, size_t newlen)
{
	struct ctl_table uts_table;
	int r, write;
	write = newval && newlen;
	memcpy(&uts_table, table, sizeof(uts_table));
	uts_table.data = get_uts(table, write);
	r = sysctl_string(&uts_table, oldval, oldlenp, newval, newlen);
	put_uts(table, write, uts_table.data);
	return r;
}
#else
#define sysctl_uts_string NULL
#endif

static struct ctl_table uts_kern_table[] = {
	{
		.ctl_name	= KERN_OSTYPE,
		.procname	= "ostype",
		.data		= init_uts_ns.name.sysname,
		.maxlen		= sizeof(init_uts_ns.name.sysname),
		.mode		= 0444,
		.proc_handler	= proc_do_uts_string,
		.strategy	= sysctl_uts_string,
	},
	{
		.ctl_name	= KERN_OSRELEASE,
		.procname	= "osrelease",
		.data		= init_uts_ns.name.release,
		.maxlen		= sizeof(init_uts_ns.name.release),
		.mode		= 0444,
		.proc_handler	= proc_do_uts_string,
		.strategy	= sysctl_uts_string,
	},
	{
		.ctl_name	= KERN_VERSION,
		.procname	= "version",
		.data		= init_uts_ns.name.version,
		.maxlen		= sizeof(init_uts_ns.name.version),
		.mode		= 0444,
		.proc_handler	= proc_do_uts_string,
		.strategy	= sysctl_uts_string,
	},
	{
		.ctl_name	= KERN_NODENAME,
		.procname	= "hostname",
		.data		= init_uts_ns.name.nodename,
		.maxlen		= sizeof(init_uts_ns.name.nodename),
		.mode		= 0644,
		.proc_handler	= proc_do_uts_string,
		.strategy	= sysctl_uts_string,
	},
	{
		.ctl_name	= KERN_DOMAINNAME,
		.procname	= "domainname",
		.data		= init_uts_ns.name.domainname,
		.maxlen		= sizeof(init_uts_ns.name.domainname),
		.mode		= 0644,
		.proc_handler	= proc_do_uts_string,
		.strategy	= sysctl_uts_string,
	},
	{}
};

static struct ctl_table uts_root_table[] = {
	{
		.ctl_name	= CTL_KERN,
		.procname	= "kernel",
		.mode		= 0555,
		.child		= uts_kern_table,
	},
	{}
};

static int __init utsname_sysctl_init(void)
{
	register_sysctl_table(uts_root_table);
	return 0;
}

__initcall(utsname_sysctl_init);
Commit	Line	Data
39732acd EB	1	/*
	2	* Copyright (C) 2007
	3	*
	4	* Author: Eric Biederman <ebiederm@xmision.com>
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation, version 2 of the
	9	* License.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/uts.h>
	14	#include <linux/utsname.h>
39732acd EB	15	#include <linux/sysctl.h>
	16
	17	static void get_uts(ctl_table table, int write)
	18	{
	19	char *which = table->data;
32df81cb PE	20	struct uts_namespace *uts_ns;
	21
	22	uts_ns = current->nsproxy->uts_ns;
	23	which = (which - (char )&init_uts_ns) + (char )uts_ns;
7d69a1f4	24
39732acd EB	25	if (!write)
	26	down_read(&uts_sem);
	27	else
	28	down_write(&uts_sem);
	29	return which;
	30	}
	31
	32	static void put_uts(ctl_table table, int write, void which)
	33	{
	34	if (!write)
	35	up_read(&uts_sem);
	36	else
	37	up_write(&uts_sem);
	38	}
	39
	40	#ifdef CONFIG_PROC_FS
	41	/*
	42	* Special case of dostring for the UTS structure. This has locks
	43	* to observe. Should this be in kernel/sys.c ????
	44	*/
	45	static int proc_do_uts_string(ctl_table table, int write, struct file filp,
	46	void __user buffer, size_t lenp, loff_t *ppos)
	47	{
	48	struct ctl_table uts_table;
	49	int r;
	50	memcpy(&uts_table, table, sizeof(uts_table));
	51	uts_table.data = get_uts(table, write);
	52	r = proc_dostring(&uts_table,write,filp,buffer,lenp, ppos);
	53	put_uts(table, write, uts_table.data);
	54	return r;
	55	}
	56	#else
	57	#define proc_do_uts_string NULL
	58	#endif
	59
	60
	61	#ifdef CONFIG_SYSCTL_SYSCALL
	62	/* The generic string strategy routine: */
f221e726	63	static int sysctl_uts_string(ctl_table *table,
39732acd EB	64	void __user oldval, size_t __user oldlenp,
	65	void __user *newval, size_t newlen)
	66	{
	67	struct ctl_table uts_table;
	68	int r, write;
	69	write = newval && newlen;
	70	memcpy(&uts_table, table, sizeof(uts_table));
	71	uts_table.data = get_uts(table, write);
f221e726	72	r = sysctl_string(&uts_table, oldval, oldlenp, newval, newlen);
39732acd EB	73	put_uts(table, write, uts_table.data);
	74	return r;
	75	}
	76	#else
	77	#define sysctl_uts_string NULL
	78	#endif
	79
	80	static struct ctl_table uts_kern_table[] = {
	81	{
	82	.ctl_name = KERN_OSTYPE,
	83	.procname = "ostype",
	84	.data = init_uts_ns.name.sysname,
	85	.maxlen = sizeof(init_uts_ns.name.sysname),
	86	.mode = 0444,
	87	.proc_handler = proc_do_uts_string,
	88	.strategy = sysctl_uts_string,
	89	},
	90	{
	91	.ctl_name = KERN_OSRELEASE,
	92	.procname = "osrelease",
	93	.data = init_uts_ns.name.release,
	94	.maxlen = sizeof(init_uts_ns.name.release),
	95	.mode = 0444,
	96	.proc_handler = proc_do_uts_string,
	97	.strategy = sysctl_uts_string,
	98	},
	99	{
	100	.ctl_name = KERN_VERSION,
	101	.procname = "version",
	102	.data = init_uts_ns.name.version,
	103	.maxlen = sizeof(init_uts_ns.name.version),
	104	.mode = 0444,
	105	.proc_handler = proc_do_uts_string,
	106	.strategy = sysctl_uts_string,
	107	},
	108	{
	109	.ctl_name = KERN_NODENAME,
	110	.procname = "hostname",
	111	.data = init_uts_ns.name.nodename,
	112	.maxlen = sizeof(init_uts_ns.name.nodename),
	113	.mode = 0644,
	114	.proc_handler = proc_do_uts_string,
	115	.strategy = sysctl_uts_string,
	116	},
	117	{
	118	.ctl_name = KERN_DOMAINNAME,
	119	.procname = "domainname",
	120	.data = init_uts_ns.name.domainname,
	121	.maxlen = sizeof(init_uts_ns.name.domainname),
	122	.mode = 0644,
	123	.proc_handler = proc_do_uts_string,
	124	.strategy = sysctl_uts_string,
	125	},
	126	{}
	127	};
	128
	129	static struct ctl_table uts_root_table[] = {
	130	{
	131	.ctl_name = CTL_KERN,
	132	.procname = "kernel",
	133	.mode = 0555,
	134	.child = uts_kern_table,
	135	},
	136	{}
137	};
138
139	static int __init utsname_sysctl_init(void)
140	{
0b4d4147	141	register_sysctl_table(uts_root_table);
39732acd EB	142	return 0;
	143	}
	144
	145	__initcall(utsname_sysctl_init);