[linux.git] / ipc / mq_sysctl.c

/*
 *  Copyright (C) 2007 IBM Corporation
 *
 *  Author: Cedric Le Goater <[email protected]>
 *
 *  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/nsproxy.h>
#include <linux/ipc_namespace.h>
#include <linux/sysctl.h>

/*
 * Define the ranges various user-specified maximum values can
 * be set to.
 */
#define MIN_MSGMAX	1		/* min value for msg_max */
#define MAX_MSGMAX	HARD_MSGMAX	/* max value for msg_max */
#define MIN_MSGSIZEMAX	128		/* min value for msgsize_max */
#define MAX_MSGSIZEMAX	(8192*128)	/* max value for msgsize_max */

#ifdef CONFIG_PROC_SYSCTL
static void *get_mq(ctl_table *table)
{
	char *which = table->data;
	struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
	which = (which - (char *)&init_ipc_ns) + (char *)ipc_ns;
	return which;
}

static int proc_mq_dointvec(ctl_table *table, int write,
	void __user *buffer, size_t *lenp, loff_t *ppos)
{
	struct ctl_table mq_table;
	memcpy(&mq_table, table, sizeof(mq_table));
	mq_table.data = get_mq(table);

	return proc_dointvec(&mq_table, write, buffer, lenp, ppos);
}

static int proc_mq_dointvec_minmax(ctl_table *table, int write,
	void __user *buffer, size_t *lenp, loff_t *ppos)
{
	struct ctl_table mq_table;
	memcpy(&mq_table, table, sizeof(mq_table));
	mq_table.data = get_mq(table);

	return proc_dointvec_minmax(&mq_table, write, buffer,
					lenp, ppos);
}
#else
#define proc_mq_dointvec NULL
#define proc_mq_dointvec_minmax NULL
#endif

static int msg_max_limit_min = MIN_MSGMAX;
static int msg_max_limit_max = MAX_MSGMAX;

static int msg_maxsize_limit_min = MIN_MSGSIZEMAX;
static int msg_maxsize_limit_max = MAX_MSGSIZEMAX;

static ctl_table mq_sysctls[] = {
	{
		.procname	= "queues_max",
		.data		= &init_ipc_ns.mq_queues_max,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_mq_dointvec,
	},
	{
		.procname	= "msg_max",
		.data		= &init_ipc_ns.mq_msg_max,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_mq_dointvec_minmax,
		.extra1		= &msg_max_limit_min,
		.extra2		= &msg_max_limit_max,
	},
	{
		.procname	= "msgsize_max",
		.data		= &init_ipc_ns.mq_msgsize_max,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_mq_dointvec_minmax,
		.extra1		= &msg_maxsize_limit_min,
		.extra2		= &msg_maxsize_limit_max,
	},
	{}
};

static ctl_table mq_sysctl_dir[] = {
	{
		.procname	= "mqueue",
		.mode		= 0555,
		.child		= mq_sysctls,
	},
	{}
};

static ctl_table mq_sysctl_root[] = {
	{
		.procname	= "fs",
		.mode		= 0555,
		.child		= mq_sysctl_dir,
	},
	{}
};

struct ctl_table_header *mq_register_sysctl_table(void)
{
	return register_sysctl_table(mq_sysctl_root);
}
Commit	Line	Data
bdc8e5f8 SH	1	/*
	2	* Copyright (C) 2007 IBM Corporation
	3	*
	4	* Author: Cedric Le Goater <[email protected]>
	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/nsproxy.h>
	13	#include <linux/ipc_namespace.h>
	14	#include <linux/sysctl.h>
	15
	16	/*
	17	* Define the ranges various user-specified maximum values can
	18	* be set to.
	19	*/
	20	#define MIN_MSGMAX 1 /* min value for msg_max */
	21	#define MAX_MSGMAX HARD_MSGMAX /* max value for msg_max */
	22	#define MIN_MSGSIZEMAX 128 /* min value for msgsize_max */
	23	#define MAX_MSGSIZEMAX (8192128) / max value for msgsize_max */
	24
f26ec5ba	25	#ifdef CONFIG_PROC_SYSCTL
bdc8e5f8 SH	26	static void get_mq(ctl_table table)
	27	{
	28	char *which = table->data;
	29	struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
	30	which = (which - (char )&init_ipc_ns) + (char )ipc_ns;
	31	return which;
	32	}
	33
8d65af78	34	static int proc_mq_dointvec(ctl_table *table, int write,
bdc8e5f8 SH	35	void __user buffer, size_t lenp, loff_t *ppos)
	36	{
	37	struct ctl_table mq_table;
	38	memcpy(&mq_table, table, sizeof(mq_table));
	39	mq_table.data = get_mq(table);
	40
8d65af78	41	return proc_dointvec(&mq_table, write, buffer, lenp, ppos);
bdc8e5f8 SH	42	}
	43
	44	static int proc_mq_dointvec_minmax(ctl_table *table, int write,
8d65af78	45	void __user buffer, size_t lenp, loff_t *ppos)
bdc8e5f8 SH	46	{
	47	struct ctl_table mq_table;
	48	memcpy(&mq_table, table, sizeof(mq_table));
	49	mq_table.data = get_mq(table);
	50
8d65af78	51	return proc_dointvec_minmax(&mq_table, write, buffer,
bdc8e5f8 SH	52	lenp, ppos);
	53	}
	54	#else
	55	#define proc_mq_dointvec NULL
	56	#define proc_mq_dointvec_minmax NULL
	57	#endif
	58
	59	static int msg_max_limit_min = MIN_MSGMAX;
	60	static int msg_max_limit_max = MAX_MSGMAX;
	61
	62	static int msg_maxsize_limit_min = MIN_MSGSIZEMAX;
	63	static int msg_maxsize_limit_max = MAX_MSGSIZEMAX;
	64
	65	static ctl_table mq_sysctls[] = {
	66	{
	67	.procname = "queues_max",
	68	.data = &init_ipc_ns.mq_queues_max,
	69	.maxlen = sizeof(int),
	70	.mode = 0644,
	71	.proc_handler = proc_mq_dointvec,
	72	},
	73	{
	74	.procname = "msg_max",
	75	.data = &init_ipc_ns.mq_msg_max,
	76	.maxlen = sizeof(int),
	77	.mode = 0644,
	78	.proc_handler = proc_mq_dointvec_minmax,
	79	.extra1 = &msg_max_limit_min,
	80	.extra2 = &msg_max_limit_max,
	81	},
	82	{
	83	.procname = "msgsize_max",
	84	.data = &init_ipc_ns.mq_msgsize_max,
	85	.maxlen = sizeof(int),
	86	.mode = 0644,
	87	.proc_handler = proc_mq_dointvec_minmax,
	88	.extra1 = &msg_maxsize_limit_min,
	89	.extra2 = &msg_maxsize_limit_max,
	90	},
2bc4657c	91	{}
bdc8e5f8 SH	92	};
	93
	94	static ctl_table mq_sysctl_dir[] = {
	95	{
	96	.procname = "mqueue",
	97	.mode = 0555,
	98	.child = mq_sysctls,
	99	},
2bc4657c	100	{}
bdc8e5f8 SH	101	};
	102
	103	static ctl_table mq_sysctl_root[] = {
	104	{
bdc8e5f8 SH	105	.procname = "fs",
	106	.mode = 0555,
	107	.child = mq_sysctl_dir,
	108	},
2bc4657c	109	{}
bdc8e5f8 SH	110	};
	111
	112	struct ctl_table_header *mq_register_sysctl_table(void)
	113	{
	114	return register_sysctl_table(mq_sysctl_root);
	115	}