[thirdparty/kernel/stable.git] / kernel / sysctl_binary.c

#include <linux/stat.h>
#include <linux/sysctl.h>
#include "../fs/xfs/linux-2.6/xfs_sysctl.h"
#include <linux/sunrpc/debug.h>
#include <linux/string.h>
#include <net/ip_vs.h>
#include <linux/syscalls.h>
#include <linux/namei.h>
#include <linux/mount.h>
#include <linux/fs.h>
#include <linux/nsproxy.h>
#include <linux/pid_namespace.h>
#include <linux/file.h>
#include <linux/ctype.h>
#include <linux/smp_lock.h>

static int deprecated_sysctl_warning(struct __sysctl_args *args);

#ifdef CONFIG_SYSCTL_SYSCALL

/* Perform the actual read/write of a sysctl table entry. */
static int do_sysctl_strategy(struct ctl_table_root *root,
			struct ctl_table *table,
			void __user *oldval, size_t __user *oldlenp,
			void __user *newval, size_t newlen)
{
	int op = 0, rc;

	if (oldval)
		op |= MAY_READ;
	if (newval)
		op |= MAY_WRITE;
	if (sysctl_perm(root, table, op))
		return -EPERM;

	if (table->strategy) {
		rc = table->strategy(table, oldval, oldlenp, newval, newlen);
		if (rc < 0)
			return rc;
		if (rc > 0)
			return 0;
	}

	/* If there is no strategy routine, or if the strategy returns
	 * zero, proceed with automatic r/w */
	if (table->data && table->maxlen) {
		rc = sysctl_data(table, oldval, oldlenp, newval, newlen);
		if (rc < 0)
			return rc;
	}
	return 0;
}

static int parse_table(int __user *name, int nlen,
		       void __user *oldval, size_t __user *oldlenp,
		       void __user *newval, size_t newlen,
		       struct ctl_table_root *root,
		       struct ctl_table *table)
{
	int n;
repeat:
	if (!nlen)
		return -ENOTDIR;
	if (get_user(n, name))
		return -EFAULT;
	for ( ; table->ctl_name || table->procname; table++) {
		if (!table->ctl_name)
			continue;
		if (n == table->ctl_name) {
			int error;
			if (table->child) {
				if (sysctl_perm(root, table, MAY_EXEC))
					return -EPERM;
				name++;
				nlen--;
				table = table->child;
				goto repeat;
			}
			error = do_sysctl_strategy(root, table,
						   oldval, oldlenp,
						   newval, newlen);
			return error;
		}
	}
	return -ENOTDIR;
}

int do_sysctl(int __user *name, int nlen, void __user *oldval, size_t __user *oldlenp,
	       void __user *newval, size_t newlen)
{
	struct ctl_table_header *head;
	int error = -ENOTDIR;

	if (nlen <= 0 || nlen >= CTL_MAXNAME)
		return -ENOTDIR;
	if (oldval) {
		int old_len;
		if (!oldlenp || get_user(old_len, oldlenp))
			return -EFAULT;
	}

	for (head = sysctl_head_next(NULL); head;
			head = sysctl_head_next(head)) {
		error = parse_table(name, nlen, oldval, oldlenp, 
					newval, newlen,
					head->root, head->ctl_table);
		if (error != -ENOTDIR) {
			sysctl_head_finish(head);
			break;
		}
	}
	return error;
}

SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
{
	struct __sysctl_args tmp;
	int error;

	if (copy_from_user(&tmp, args, sizeof(tmp)))
		return -EFAULT;

	error = deprecated_sysctl_warning(&tmp);
	if (error)
		goto out;

	lock_kernel();
	error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,
			  tmp.newval, tmp.newlen);
	unlock_kernel();
out:
	return error;
}

#else /* CONFIG_SYSCTL_SYSCALL */

SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
{
	struct __sysctl_args tmp;
	int error;

	if (copy_from_user(&tmp, args, sizeof(tmp)))
		return -EFAULT;

	error = deprecated_sysctl_warning(&tmp);

	/* If no error reading the parameters then just -ENOSYS ... */
	if (!error)
		error = -ENOSYS;

	return error;
}

#endif /* CONFIG_SYSCTL_SYSCALL */

static int deprecated_sysctl_warning(struct __sysctl_args *args)
{
	static int msg_count;
	int name[CTL_MAXNAME];
	int i;

	/* Check args->nlen. */
	if (args->nlen < 0 || args->nlen > CTL_MAXNAME)
		return -ENOTDIR;

	/* Read in the sysctl name for better debug message logging */
	for (i = 0; i < args->nlen; i++)
		if (get_user(name[i], args->name + i))
			return -EFAULT;

	/* Ignore accesses to kernel.version */
	if ((args->nlen == 2) && (name[0] == CTL_KERN) && (name[1] == KERN_VERSION))
		return 0;

	if (msg_count < 5) {
		msg_count++;
		printk(KERN_INFO
			"warning: process `%s' used the deprecated sysctl "
			"system call with ", current->comm);
		for (i = 0; i < args->nlen; i++)
			printk("%d.", name[i]);
		printk("\n");
	}
	return 0;
}
Commit	Line	Data
afa588b2 EB	1	#include <linux/stat.h>
	2	#include <linux/sysctl.h>
	3	#include "../fs/xfs/linux-2.6/xfs_sysctl.h"
	4	#include <linux/sunrpc/debug.h>
	5	#include <linux/string.h>
	6	#include <net/ip_vs.h>
	7	#include <linux/syscalls.h>
	8	#include <linux/namei.h>
	9	#include <linux/mount.h>
	10	#include <linux/fs.h>
	11	#include <linux/nsproxy.h>
	12	#include <linux/pid_namespace.h>
	13	#include <linux/file.h>
	14	#include <linux/ctype.h>
	15	#include <linux/smp_lock.h>
	16
	17	static int deprecated_sysctl_warning(struct __sysctl_args *args);
	18
	19	#ifdef CONFIG_SYSCTL_SYSCALL
	20
	21	/* Perform the actual read/write of a sysctl table entry. */
	22	static int do_sysctl_strategy(struct ctl_table_root *root,
	23	struct ctl_table *table,
	24	void __user oldval, size_t __user oldlenp,
	25	void __user *newval, size_t newlen)
	26	{
	27	int op = 0, rc;
	28
	29	if (oldval)
	30	op \|= MAY_READ;
	31	if (newval)
	32	op \|= MAY_WRITE;
	33	if (sysctl_perm(root, table, op))
	34	return -EPERM;
	35
	36	if (table->strategy) {
	37	rc = table->strategy(table, oldval, oldlenp, newval, newlen);
	38	if (rc < 0)
	39	return rc;
	40	if (rc > 0)
	41	return 0;
	42	}
	43
	44	/* If there is no strategy routine, or if the strategy returns
	45	* zero, proceed with automatic r/w */
	46	if (table->data && table->maxlen) {
	47	rc = sysctl_data(table, oldval, oldlenp, newval, newlen);
	48	if (rc < 0)
	49	return rc;
	50	}
	51	return 0;
	52	}
	53
	54	static int parse_table(int __user *name, int nlen,
	55	void __user oldval, size_t __user oldlenp,
	56	void __user *newval, size_t newlen,
	57	struct ctl_table_root *root,
	58	struct ctl_table *table)
	59	{
	60	int n;
	61	repeat:
	62	if (!nlen)
	63	return -ENOTDIR;
	64	if (get_user(n, name))
65	return -EFAULT;
66	for ( ; table->ctl_name \|\| table->procname; table++) {
67	if (!table->ctl_name)
68	continue;
69	if (n == table->ctl_name) {
70	int error;
71	if (table->child) {
72	if (sysctl_perm(root, table, MAY_EXEC))
73	return -EPERM;
74	name++;
75	nlen--;
76	table = table->child;
77	goto repeat;
78	}
79	error = do_sysctl_strategy(root, table,
80	oldval, oldlenp,
81	newval, newlen);
82	return error;
83	}
84	}
85	return -ENOTDIR;
86	}
87
88	int do_sysctl(int __user name, int nlen, void __user oldval, size_t __user *oldlenp,
89	void __user *newval, size_t newlen)
90	{
91	struct ctl_table_header *head;
92	int error = -ENOTDIR;
93
94	if (nlen <= 0 \|\| nlen >= CTL_MAXNAME)
95	return -ENOTDIR;
96	if (oldval) {
97	int old_len;
98	if (!oldlenp \|\| get_user(old_len, oldlenp))
99	return -EFAULT;
100	}
101
102	for (head = sysctl_head_next(NULL); head;
103	head = sysctl_head_next(head)) {
104	error = parse_table(name, nlen, oldval, oldlenp,
105	newval, newlen,
106	head->root, head->ctl_table);
107	if (error != -ENOTDIR) {
108	sysctl_head_finish(head);
109	break;
110	}
111	}
112	return error;
113	}
114
115	SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
116	{
117	struct __sysctl_args tmp;
118	int error;
119
120	if (copy_from_user(&tmp, args, sizeof(tmp)))
121	return -EFAULT;
122
123	error = deprecated_sysctl_warning(&tmp);
124	if (error)
125	goto out;
126
127	lock_kernel();
128	error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,
129	tmp.newval, tmp.newlen);
130	unlock_kernel();
131	out:
132	return error;
133	}
134
135	#else /* CONFIG_SYSCTL_SYSCALL */
136
137	SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
138	{
139	struct __sysctl_args tmp;
140	int error;
141
142	if (copy_from_user(&tmp, args, sizeof(tmp)))
143	return -EFAULT;
144
145	error = deprecated_sysctl_warning(&tmp);
146
147	/* If no error reading the parameters then just -ENOSYS ... */
148	if (!error)
149	error = -ENOSYS;
150
151	return error;
152	}
153
154	#endif /* CONFIG_SYSCTL_SYSCALL */
155
156	static int deprecated_sysctl_warning(struct __sysctl_args *args)
157	{
158	static int msg_count;
159	int name[CTL_MAXNAME];
160	int i;
161
162	/* Check args->nlen. */
163	if (args->nlen < 0 \|\| args->nlen > CTL_MAXNAME)
164	return -ENOTDIR;
165
166	/* Read in the sysctl name for better debug message logging */
167	for (i = 0; i < args->nlen; i++)
168	if (get_user(name[i], args->name + i))
169	return -EFAULT;
170
171	/* Ignore accesses to kernel.version */
172	if ((args->nlen == 2) && (name[0] == CTL_KERN) && (name[1] == KERN_VERSION))
173	return 0;
174
175	if (msg_count < 5) {
176	msg_count++;
177	printk(KERN_INFO
178	"warning: process `%s' used the deprecated sysctl "
179	"system call with ", current->comm);
180	for (i = 0; i < args->nlen; i++)
181	printk("%d.", name[i]);
182	printk("\n");
183	}
184	return 0;
185	}