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

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 *  Copyright (C) 2007 IBM Corporation
  4 *
  5 *  Author: Cedric Le Goater <clg@fr.ibm.com>
 
 
 
 
 
  6 */
  7
  8#include <linux/nsproxy.h>
  9#include <linux/ipc_namespace.h>
 10#include <linux/sysctl.h>
 11
 12#include <linux/stat.h>
 13#include <linux/capability.h>
 14#include <linux/slab.h>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 15
 16static int msg_max_limit_min = MIN_MSGMAX;
 17static int msg_max_limit_max = HARD_MSGMAX;
 18
 19static int msg_maxsize_limit_min = MIN_MSGSIZEMAX;
 20static int msg_maxsize_limit_max = HARD_MSGSIZEMAX;
 21
 22static struct ctl_table mq_sysctls[] = {
 23	{
 24		.procname	= "queues_max",
 25		.data		= &init_ipc_ns.mq_queues_max,
 26		.maxlen		= sizeof(int),
 27		.mode		= 0644,
 28		.proc_handler	= proc_dointvec,
 29	},
 30	{
 31		.procname	= "msg_max",
 32		.data		= &init_ipc_ns.mq_msg_max,
 33		.maxlen		= sizeof(int),
 34		.mode		= 0644,
 35		.proc_handler	= proc_dointvec_minmax,
 36		.extra1		= &msg_max_limit_min,
 37		.extra2		= &msg_max_limit_max,
 38	},
 39	{
 40		.procname	= "msgsize_max",
 41		.data		= &init_ipc_ns.mq_msgsize_max,
 42		.maxlen		= sizeof(int),
 43		.mode		= 0644,
 44		.proc_handler	= proc_dointvec_minmax,
 45		.extra1		= &msg_maxsize_limit_min,
 46		.extra2		= &msg_maxsize_limit_max,
 47	},
 48	{
 49		.procname	= "msg_default",
 50		.data		= &init_ipc_ns.mq_msg_default,
 51		.maxlen		= sizeof(int),
 52		.mode		= 0644,
 53		.proc_handler	= proc_dointvec_minmax,
 54		.extra1		= &msg_max_limit_min,
 55		.extra2		= &msg_max_limit_max,
 56	},
 57	{
 58		.procname	= "msgsize_default",
 59		.data		= &init_ipc_ns.mq_msgsize_default,
 60		.maxlen		= sizeof(int),
 61		.mode		= 0644,
 62		.proc_handler	= proc_dointvec_minmax,
 63		.extra1		= &msg_maxsize_limit_min,
 64		.extra2		= &msg_maxsize_limit_max,
 65	},
 66	{}
 67};
 68
 69static struct ctl_table_set *set_lookup(struct ctl_table_root *root)
 70{
 71	return &current->nsproxy->ipc_ns->mq_set;
 72}
 
 
 
 
 73
 74static int set_is_seen(struct ctl_table_set *set)
 75{
 76	return &current->nsproxy->ipc_ns->mq_set == set;
 77}
 78
 79static struct ctl_table_root set_root = {
 80	.lookup = set_lookup,
 81};
 82
 83bool setup_mq_sysctls(struct ipc_namespace *ns)
 84{
 85	struct ctl_table *tbl;
 86
 87	setup_sysctl_set(&ns->mq_set, &set_root, set_is_seen);
 88
 89	tbl = kmemdup(mq_sysctls, sizeof(mq_sysctls), GFP_KERNEL);
 90	if (tbl) {
 91		int i;
 92
 93		for (i = 0; i < ARRAY_SIZE(mq_sysctls); i++) {
 94			if (tbl[i].data == &init_ipc_ns.mq_queues_max)
 95				tbl[i].data = &ns->mq_queues_max;
 96
 97			else if (tbl[i].data == &init_ipc_ns.mq_msg_max)
 98				tbl[i].data = &ns->mq_msg_max;
 99
100			else if (tbl[i].data == &init_ipc_ns.mq_msgsize_max)
101				tbl[i].data = &ns->mq_msgsize_max;
102
103			else if (tbl[i].data == &init_ipc_ns.mq_msg_default)
104				tbl[i].data = &ns->mq_msg_default;
105
106			else if (tbl[i].data == &init_ipc_ns.mq_msgsize_default)
107				tbl[i].data = &ns->mq_msgsize_default;
108			else
109				tbl[i].data = NULL;
110		}
111
112		ns->mq_sysctls = __register_sysctl_table(&ns->mq_set,
113							 "fs/mqueue", tbl,
114							 ARRAY_SIZE(mq_sysctls));
115	}
116	if (!ns->mq_sysctls) {
117		kfree(tbl);
118		retire_sysctl_set(&ns->mq_set);
119		return false;
120	}
121
122	return true;
123}
124
125void retire_mq_sysctls(struct ipc_namespace *ns)
126{
127	struct ctl_table *tbl;
128
129	tbl = ns->mq_sysctls->ctl_table_arg;
130	unregister_sysctl_table(ns->mq_sysctls);
131	retire_sysctl_set(&ns->mq_set);
132	kfree(tbl);
133}