[linux-2.6-block.git] / net / sctp / sysctl.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* SCTP kernel implementation
 * (C) Copyright IBM Corp. 2002, 2004
 * Copyright (c) 2002 Intel Corp.
 *
 * This file is part of the SCTP kernel implementation
 *
 * Sysctl related interfaces for SCTP.
 *
 * Please send any bug reports or fixes you make to the
 * email address(es):
 *    lksctp developers <linux-sctp@vger.kernel.org>
 *
 * Written or modified by:
 *    Mingqin Liu           <liuming@us.ibm.com>
 *    Jon Grimm             <jgrimm@us.ibm.com>
 *    Ardelle Fan           <ardelle.fan@intel.com>
 *    Ryan Layer            <rmlayer@us.ibm.com>
 *    Sridhar Samudrala     <sri@us.ibm.com>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <net/sctp/structs.h>
#include <net/sctp/sctp.h>
#include <linux/sysctl.h>

static int timer_max = 86400000; /* ms in one day */
static int sack_timer_min = 1;
static int sack_timer_max = 500;
static int addr_scope_max = SCTP_SCOPE_POLICY_MAX;
static int rwnd_scale_max = 16;
static int rto_alpha_min = 0;
static int rto_beta_min = 0;
static int rto_alpha_max = 1000;
static int rto_beta_max = 1000;
static int pf_expose_max = SCTP_PF_EXPOSE_MAX;
static int ps_retrans_max = SCTP_PS_RETRANS_MAX;
static int udp_port_max = 65535;

static unsigned long max_autoclose_min = 0;
static unsigned long max_autoclose_max =
	(MAX_SCHEDULE_TIMEOUT / HZ > UINT_MAX)
	? UINT_MAX : MAX_SCHEDULE_TIMEOUT / HZ;

static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
				 void *buffer, size_t *lenp, loff_t *ppos);
static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
				void *buffer, size_t *lenp, loff_t *ppos);
static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write, void *buffer,
				size_t *lenp, loff_t *ppos);
static int proc_sctp_do_udp_port(struct ctl_table *ctl, int write, void *buffer,
				 size_t *lenp, loff_t *ppos);
static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
				   void *buffer, size_t *lenp, loff_t *ppos);
static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
			     void *buffer, size_t *lenp, loff_t *ppos);
static int proc_sctp_do_probe_interval(struct ctl_table *ctl, int write,
				       void *buffer, size_t *lenp, loff_t *ppos);

static struct ctl_table sctp_table[] = {
	{
		.procname	= "sctp_mem",
		.data		= &sysctl_sctp_mem,
		.maxlen		= sizeof(sysctl_sctp_mem),
		.mode		= 0644,
		.proc_handler	= proc_doulongvec_minmax
	},
	{
		.procname	= "sctp_rmem",
		.data		= &sysctl_sctp_rmem,
		.maxlen		= sizeof(sysctl_sctp_rmem),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "sctp_wmem",
		.data		= &sysctl_sctp_wmem,
		.maxlen		= sizeof(sysctl_sctp_wmem),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},

	{ /* sentinel */ }
};

/* The following index defines are used in sctp_sysctl_net_register().
 * If you add new items to the sctp_net_table, please ensure that
 * the index values of these defines hold the same meaning indicated by
 * their macro names when they appear in sctp_net_table.
 */
#define SCTP_RTO_MIN_IDX       0
#define SCTP_RTO_MAX_IDX       1
#define SCTP_PF_RETRANS_IDX    2
#define SCTP_PS_RETRANS_IDX    3

static struct ctl_table sctp_net_table[] = {
	[SCTP_RTO_MIN_IDX] = {
		.procname	= "rto_min",
		.data		= &init_net.sctp.rto_min,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= proc_sctp_do_rto_min,
		.extra1         = SYSCTL_ONE,
		.extra2         = &init_net.sctp.rto_max
	},
	[SCTP_RTO_MAX_IDX] =  {
		.procname	= "rto_max",
		.data		= &init_net.sctp.rto_max,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= proc_sctp_do_rto_max,
		.extra1         = &init_net.sctp.rto_min,
		.extra2         = &timer_max
	},
	[SCTP_PF_RETRANS_IDX] = {
		.procname	= "pf_retrans",
		.data		= &init_net.sctp.pf_retrans,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ZERO,
		.extra2		= &init_net.sctp.ps_retrans,
	},
	[SCTP_PS_RETRANS_IDX] = {
		.procname	= "ps_retrans",
		.data		= &init_net.sctp.ps_retrans,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &init_net.sctp.pf_retrans,
		.extra2		= &ps_retrans_max,
	},
	{
		.procname	= "rto_initial",
		.data		= &init_net.sctp.rto_initial,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1         = SYSCTL_ONE,
		.extra2         = &timer_max
	},
	{
		.procname	= "rto_alpha_exp_divisor",
		.data		= &init_net.sctp.rto_alpha,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_sctp_do_alpha_beta,
		.extra1		= &rto_alpha_min,
		.extra2		= &rto_alpha_max,
	},
	{
		.procname	= "rto_beta_exp_divisor",
		.data		= &init_net.sctp.rto_beta,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_sctp_do_alpha_beta,
		.extra1		= &rto_beta_min,
		.extra2		= &rto_beta_max,
	},
	{
		.procname	= "max_burst",
		.data		= &init_net.sctp.max_burst,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ZERO,
		.extra2		= SYSCTL_INT_MAX,
	},
	{
		.procname	= "cookie_preserve_enable",
		.data		= &init_net.sctp.cookie_preserve_enable,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "cookie_hmac_alg",
		.data		= &init_net.sctp.sctp_hmac_alg,
		.maxlen		= 8,
		.mode		= 0644,
		.proc_handler	= proc_sctp_do_hmac_alg,
	},
	{
		.procname	= "valid_cookie_life",
		.data		= &init_net.sctp.valid_cookie_life,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1         = SYSCTL_ONE,
		.extra2         = &timer_max
	},
	{
		.procname	= "sack_timeout",
		.data		= &init_net.sctp.sack_timeout,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1         = &sack_timer_min,
		.extra2         = &sack_timer_max,
	},
	{
		.procname	= "hb_interval",
		.data		= &init_net.sctp.hb_interval,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1         = SYSCTL_ONE,
		.extra2         = &timer_max
	},
	{
		.procname	= "association_max_retrans",
		.data		= &init_net.sctp.max_retrans_association,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ONE,
		.extra2		= SYSCTL_INT_MAX,
	},
	{
		.procname	= "path_max_retrans",
		.data		= &init_net.sctp.max_retrans_path,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ONE,
		.extra2		= SYSCTL_INT_MAX,
	},
	{
		.procname	= "max_init_retransmits",
		.data		= &init_net.sctp.max_retrans_init,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ONE,
		.extra2		= SYSCTL_INT_MAX,
	},
	{
		.procname	= "sndbuf_policy",
		.data		= &init_net.sctp.sndbuf_policy,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "rcvbuf_policy",
		.data		= &init_net.sctp.rcvbuf_policy,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "default_auto_asconf",
		.data		= &init_net.sctp.default_auto_asconf,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "addip_enable",
		.data		= &init_net.sctp.addip_enable,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "addip_noauth_enable",
		.data		= &init_net.sctp.addip_noauth,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "prsctp_enable",
		.data		= &init_net.sctp.prsctp_enable,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "reconf_enable",
		.data		= &init_net.sctp.reconf_enable,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "auth_enable",
		.data		= &init_net.sctp.auth_enable,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_sctp_do_auth,
	},
	{
		.procname	= "intl_enable",
		.data		= &init_net.sctp.intl_enable,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "ecn_enable",
		.data		= &init_net.sctp.ecn_enable,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "plpmtud_probe_interval",
		.data		= &init_net.sctp.probe_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_sctp_do_probe_interval,
	},
	{
		.procname	= "udp_port",
		.data		= &init_net.sctp.udp_port,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_sctp_do_udp_port,
		.extra1		= SYSCTL_ZERO,
		.extra2		= &udp_port_max,
	},
	{
		.procname	= "encap_port",
		.data		= &init_net.sctp.encap_port,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ZERO,
		.extra2		= &udp_port_max,
	},
	{
		.procname	= "addr_scope_policy",
		.data		= &init_net.sctp.scope_policy,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ZERO,
		.extra2		= &addr_scope_max,
	},
	{
		.procname	= "rwnd_update_shift",
		.data		= &init_net.sctp.rwnd_upd_shift,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &proc_dointvec_minmax,
		.extra1		= SYSCTL_ONE,
		.extra2		= &rwnd_scale_max,
	},
	{
		.procname	= "max_autoclose",
		.data		= &init_net.sctp.max_autoclose,
		.maxlen		= sizeof(unsigned long),
		.mode		= 0644,
		.proc_handler	= &proc_doulongvec_minmax,
		.extra1		= &max_autoclose_min,
		.extra2		= &max_autoclose_max,
	},
#ifdef CONFIG_NET_L3_MASTER_DEV
	{
		.procname	= "l3mdev_accept",
		.data		= &init_net.sctp.l3mdev_accept,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ZERO,
		.extra2		= SYSCTL_ONE,
	},
#endif
	{
		.procname	= "pf_enable",
		.data		= &init_net.sctp.pf_enable,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
	},
	{
		.procname	= "pf_expose",
		.data		= &init_net.sctp.pf_expose,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= SYSCTL_ZERO,
		.extra2		= &pf_expose_max,
	},

	{ /* sentinel */ }
};

static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
				 void *buffer, size_t *lenp, loff_t *ppos)
{
	struct net *net = current->nsproxy->net_ns;
	struct ctl_table tbl;
	bool changed = false;
	char *none = "none";
	char tmp[8] = {0};
	int ret;

	memset(&tbl, 0, sizeof(struct ctl_table));

	if (write) {
		tbl.data = tmp;
		tbl.maxlen = sizeof(tmp);
	} else {
		tbl.data = net->sctp.sctp_hmac_alg ? : none;
		tbl.maxlen = strlen(tbl.data);
	}

	ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
	if (write && ret == 0) {
#ifdef CONFIG_CRYPTO_MD5
		if (!strncmp(tmp, "md5", 3)) {
			net->sctp.sctp_hmac_alg = "md5";
			changed = true;
		}
#endif
#ifdef CONFIG_CRYPTO_SHA1
		if (!strncmp(tmp, "sha1", 4)) {
			net->sctp.sctp_hmac_alg = "sha1";
			changed = true;
		}
#endif
		if (!strncmp(tmp, "none", 4)) {
			net->sctp.sctp_hmac_alg = NULL;
			changed = true;
		}
		if (!changed)
			ret = -EINVAL;
	}

	return ret;
}

static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
				void *buffer, size_t *lenp, loff_t *ppos)
{
	struct net *net = current->nsproxy->net_ns;
	unsigned int min = *(unsigned int *) ctl->extra1;
	unsigned int max = *(unsigned int *) ctl->extra2;
	struct ctl_table tbl;
	int ret, new_value;

	memset(&tbl, 0, sizeof(struct ctl_table));
	tbl.maxlen = sizeof(unsigned int);

	if (write)
		tbl.data = &new_value;
	else
		tbl.data = &net->sctp.rto_min;

	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
	if (write && ret == 0) {
		if (new_value > max || new_value < min)
			return -EINVAL;

		net->sctp.rto_min = new_value;
	}

	return ret;
}

static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
				void *buffer, size_t *lenp, loff_t *ppos)
{
	struct net *net = current->nsproxy->net_ns;
	unsigned int min = *(unsigned int *) ctl->extra1;
	unsigned int max = *(unsigned int *) ctl->extra2;
	struct ctl_table tbl;
	int ret, new_value;

	memset(&tbl, 0, sizeof(struct ctl_table));
	tbl.maxlen = sizeof(unsigned int);

	if (write)
		tbl.data = &new_value;
	else
		tbl.data = &net->sctp.rto_max;

	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
	if (write && ret == 0) {
		if (new_value > max || new_value < min)
			return -EINVAL;

		net->sctp.rto_max = new_value;
	}

	return ret;
}

static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
				   void *buffer, size_t *lenp, loff_t *ppos)
{
	if (write)
		pr_warn_once("Changing rto_alpha or rto_beta may lead to "
			     "suboptimal rtt/srtt estimations!\n");

	return proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
}

static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
			     void *buffer, size_t *lenp, loff_t *ppos)
{
	struct net *net = current->nsproxy->net_ns;
	struct ctl_table tbl;
	int new_value, ret;

	memset(&tbl, 0, sizeof(struct ctl_table));
	tbl.maxlen = sizeof(unsigned int);

	if (write)
		tbl.data = &new_value;
	else
		tbl.data = &net->sctp.auth_enable;

	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
	if (write && ret == 0) {
		struct sock *sk = net->sctp.ctl_sock;

		net->sctp.auth_enable = new_value;
		/* Update the value in the control socket */
		lock_sock(sk);
		sctp_sk(sk)->ep->auth_enable = new_value;
		release_sock(sk);
	}

	return ret;
}

static int proc_sctp_do_udp_port(struct ctl_table *ctl, int write,
				 void *buffer, size_t *lenp, loff_t *ppos)
{
	struct net *net = current->nsproxy->net_ns;
	unsigned int min = *(unsigned int *)ctl->extra1;
	unsigned int max = *(unsigned int *)ctl->extra2;
	struct ctl_table tbl;
	int ret, new_value;

	memset(&tbl, 0, sizeof(struct ctl_table));
	tbl.maxlen = sizeof(unsigned int);

	if (write)
		tbl.data = &new_value;
	else
		tbl.data = &net->sctp.udp_port;

	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
	if (write && ret == 0) {
		struct sock *sk = net->sctp.ctl_sock;

		if (new_value > max || new_value < min)
			return -EINVAL;

		net->sctp.udp_port = new_value;
		sctp_udp_sock_stop(net);
		if (new_value) {
			ret = sctp_udp_sock_start(net);
			if (ret)
				net->sctp.udp_port = 0;
		}

		/* Update the value in the control socket */
		lock_sock(sk);
		sctp_sk(sk)->udp_port = htons(net->sctp.udp_port);
		release_sock(sk);
	}

	return ret;
}

static int proc_sctp_do_probe_interval(struct ctl_table *ctl, int write,
				       void *buffer, size_t *lenp, loff_t *ppos)
{
	struct net *net = current->nsproxy->net_ns;
	struct ctl_table tbl;
	int ret, new_value;

	memset(&tbl, 0, sizeof(struct ctl_table));
	tbl.maxlen = sizeof(unsigned int);

	if (write)
		tbl.data = &new_value;
	else
		tbl.data = &net->sctp.probe_interval;

	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
	if (write && ret == 0) {
		if (new_value && new_value < SCTP_PROBE_TIMER_MIN)
			return -EINVAL;

		net->sctp.probe_interval = new_value;
	}

	return ret;
}

int sctp_sysctl_net_register(struct net *net)
{
	struct ctl_table *table;
	int i;

	table = kmemdup(sctp_net_table, sizeof(sctp_net_table), GFP_KERNEL);
	if (!table)
		return -ENOMEM;

	for (i = 0; table[i].data; i++)
		table[i].data += (char *)(&net->sctp) - (char *)&init_net.sctp;

	table[SCTP_RTO_MIN_IDX].extra2 = &net->sctp.rto_max;
	table[SCTP_RTO_MAX_IDX].extra1 = &net->sctp.rto_min;
	table[SCTP_PF_RETRANS_IDX].extra2 = &net->sctp.ps_retrans;
	table[SCTP_PS_RETRANS_IDX].extra1 = &net->sctp.pf_retrans;

	net->sctp.sysctl_header = register_net_sysctl(net, "net/sctp", table);
	if (net->sctp.sysctl_header == NULL) {
		kfree(table);
		return -ENOMEM;
	}
	return 0;
}

void sctp_sysctl_net_unregister(struct net *net)
{
	struct ctl_table *table;

	table = net->sctp.sysctl_header->ctl_table_arg;
	unregister_net_sysctl_table(net->sctp.sysctl_header);
	kfree(table);
}

static struct ctl_table_header *sctp_sysctl_header;

/* Sysctl registration.  */
void sctp_sysctl_register(void)
{
	sctp_sysctl_header = register_net_sysctl(&init_net, "net/sctp", sctp_table);
}

/* Sysctl deregistration.  */
void sctp_sysctl_unregister(void)
{
	unregister_net_sysctl_table(sctp_sysctl_header);
}
Commit	Line	Data
47505b8b	1	// SPDX-License-Identifier: GPL-2.0-or-later
60c778b2	2	/* SCTP kernel implementation
1da177e4 LT	3	* (C) Copyright IBM Corp. 2002, 2004
	4	* Copyright (c) 2002 Intel Corp.
	5	*
60c778b2	6	* This file is part of the SCTP kernel implementation
1da177e4 LT	7	*
	8	* Sysctl related interfaces for SCTP.
	9	*
1da177e4 LT	10	* Please send any bug reports or fixes you make to the
1da177e4 LT	11	* email address(es):
91705c61	12	* lksctp developers <linux-sctp@vger.kernel.org>
1da177e4	13	*
1da177e4 LT	14	* Written or modified by:
	15	* Mingqin Liu <liuming@us.ibm.com>
	16	* Jon Grimm <jgrimm@us.ibm.com>
	17	* Ardelle Fan <ardelle.fan@intel.com>
	18	* Ryan Layer <rmlayer@us.ibm.com>
	19	* Sridhar Samudrala <sri@us.ibm.com>
1da177e4 LT	20	*/
1da177e4 LT	21
b58537a1 DB	22	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
b58537a1 DB	23
1da177e4	24	#include <net/sctp/structs.h>
8c5955d8	25	#include <net/sctp/sctp.h>
1da177e4 LT	26	#include <linux/sysctl.h>
1da177e4 LT	27
3fd091e7	28	static int timer_max = 86400000; /* ms in one day */
d48e074d JMG	29	static int sack_timer_min = 1;
d48e074d JMG	30	static int sack_timer_max = 500;
701ef3e6	31	static int addr_scope_max = SCTP_SCOPE_POLICY_MAX;
90f2f531	32	static int rwnd_scale_max = 16;
b58537a1 DB	33	static int rto_alpha_min = 0;
	34	static int rto_beta_min = 0;
	35	static int rto_alpha_max = 1000;
	36	static int rto_beta_max = 1000;
aef587be	37	static int pf_expose_max = SCTP_PF_EXPOSE_MAX;
34515e94	38	static int ps_retrans_max = SCTP_PS_RETRANS_MAX;
e8a3001c	39	static int udp_port_max = 65535;
b58537a1	40
2692ba61 XW	41	static unsigned long max_autoclose_min = 0;
	42	static unsigned long max_autoclose_max =
	43	(MAX_SCHEDULE_TIMEOUT / HZ > UINT_MAX)
	44	? UINT_MAX : MAX_SCHEDULE_TIMEOUT / HZ;
1da177e4	45
b486b228	46	static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
32927393	47	void buffer, size_t lenp, loff_t *ppos);
4f3fdf3b	48	static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
32927393 CH	49	void buffer, size_t lenp, loff_t *ppos);
	50	static int proc_sctp_do_rto_max(struct ctl_table ctl, int write, void buffer,
	51	size_t lenp, loff_t ppos);
046c052b XL	52	static int proc_sctp_do_udp_port(struct ctl_table ctl, int write, void buffer,
046c052b XL	53	size_t lenp, loff_t ppos);
b58537a1	54	static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
32927393	55	void buffer, size_t lenp, loff_t *ppos);
b14878cc	56	static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
32927393	57	void buffer, size_t lenp, loff_t *ppos);
d1e462a7 XL	58	static int proc_sctp_do_probe_interval(struct ctl_table *ctl, int write,
d1e462a7 XL	59	void buffer, size_t lenp, loff_t *ppos);
4f3fdf3b	60
fe2c6338	61	static struct ctl_table sctp_table[] = {
e1fc3b14 EB	62	{
	63	.procname = "sctp_mem",
	64	.data = &sysctl_sctp_mem,
	65	.maxlen = sizeof(sysctl_sctp_mem),
	66	.mode = 0644,
	67	.proc_handler = proc_doulongvec_minmax
	68	},
	69	{
	70	.procname = "sctp_rmem",
	71	.data = &sysctl_sctp_rmem,
	72	.maxlen = sizeof(sysctl_sctp_rmem),
	73	.mode = 0644,
	74	.proc_handler = proc_dointvec,
	75	},
	76	{
	77	.procname = "sctp_wmem",
	78	.data = &sysctl_sctp_wmem,
	79	.maxlen = sizeof(sysctl_sctp_wmem),
	80	.mode = 0644,
	81	.proc_handler = proc_dointvec,
	82	},
	83
	84	{ /* sentinel */ }
	85	};
	86
da05cecc FY	87	/* The following index defines are used in sctp_sysctl_net_register().
	88	* If you add new items to the sctp_net_table, please ensure that
	89	* the index values of these defines hold the same meaning indicated by
	90	* their macro names when they appear in sctp_net_table.
	91	*/
	92	#define SCTP_RTO_MIN_IDX 0
	93	#define SCTP_RTO_MAX_IDX 1
	94	#define SCTP_PF_RETRANS_IDX 2
	95	#define SCTP_PS_RETRANS_IDX 3
	96
fe2c6338	97	static struct ctl_table sctp_net_table[] = {
da05cecc	98	[SCTP_RTO_MIN_IDX] = {
1da177e4	99	.procname = "rto_min",
e1fc3b14	100	.data = &init_net.sctp.rto_min,
3fd091e7	101	.maxlen = sizeof(unsigned int),
1da177e4	102	.mode = 0644,
4f3fdf3b	103	.proc_handler = proc_sctp_do_rto_min,
eec4844f	104	.extra1 = SYSCTL_ONE,
4f3fdf3b	105	.extra2 = &init_net.sctp.rto_max
1da177e4	106	},
da05cecc	107	[SCTP_RTO_MAX_IDX] = {
1da177e4	108	.procname = "rto_max",
e1fc3b14	109	.data = &init_net.sctp.rto_max,
3fd091e7	110	.maxlen = sizeof(unsigned int),
1da177e4	111	.mode = 0644,
4f3fdf3b	112	.proc_handler = proc_sctp_do_rto_max,
4f3fdf3b	113	.extra1 = &init_net.sctp.rto_min,
3fd091e7	114	.extra2 = &timer_max
1da177e4	115	},
da05cecc FY	116	[SCTP_PF_RETRANS_IDX] = {
	117	.procname = "pf_retrans",
	118	.data = &init_net.sctp.pf_retrans,
	119	.maxlen = sizeof(int),
	120	.mode = 0644,
	121	.proc_handler = proc_dointvec_minmax,
	122	.extra1 = SYSCTL_ZERO,
	123	.extra2 = &init_net.sctp.ps_retrans,
	124	},
	125	[SCTP_PS_RETRANS_IDX] = {
	126	.procname = "ps_retrans",
	127	.data = &init_net.sctp.ps_retrans,
	128	.maxlen = sizeof(int),
	129	.mode = 0644,
	130	.proc_handler = proc_dointvec_minmax,
	131	.extra1 = &init_net.sctp.pf_retrans,
	132	.extra2 = &ps_retrans_max,
	133	},
	134	{
	135	.procname = "rto_initial",
	136	.data = &init_net.sctp.rto_initial,
	137	.maxlen = sizeof(unsigned int),
	138	.mode = 0644,
	139	.proc_handler = proc_dointvec_minmax,
	140	.extra1 = SYSCTL_ONE,
	141	.extra2 = &timer_max
	142	},
1da177e4	143	{
e1fc3b14 EB	144	.procname = "rto_alpha_exp_divisor",
	145	.data = &init_net.sctp.rto_alpha,
	146	.maxlen = sizeof(int),
b58537a1 DB	147	.mode = 0644,
	148	.proc_handler = proc_sctp_do_alpha_beta,
	149	.extra1 = &rto_alpha_min,
	150	.extra2 = &rto_alpha_max,
e1fc3b14 EB	151	},
	152	{
	153	.procname = "rto_beta_exp_divisor",
	154	.data = &init_net.sctp.rto_beta,
	155	.maxlen = sizeof(int),
b58537a1 DB	156	.mode = 0644,
	157	.proc_handler = proc_sctp_do_alpha_beta,
	158	.extra1 = &rto_beta_min,
	159	.extra2 = &rto_beta_max,
1da177e4 LT	160	},
1da177e4 LT	161	{
1da177e4	162	.procname = "max_burst",
e1fc3b14	163	.data = &init_net.sctp.max_burst,
1da177e4 LT	164	.maxlen = sizeof(int),
1da177e4 LT	165	.mode = 0644,
6d9f239a	166	.proc_handler = proc_dointvec_minmax,
eec4844f MC	167	.extra1 = SYSCTL_ZERO,
eec4844f MC	168	.extra2 = SYSCTL_INT_MAX,
1da177e4 LT	169	},
1da177e4 LT	170	{
e1fc3b14 EB	171	.procname = "cookie_preserve_enable",
e1fc3b14 EB	172	.data = &init_net.sctp.cookie_preserve_enable,
1da177e4 LT	173	.maxlen = sizeof(int),
1da177e4 LT	174	.mode = 0644,
e1fc3b14 EB	175	.proc_handler = proc_dointvec,
e1fc3b14 EB	176	},
3c68198e NH	177	{
3c68198e NH	178	.procname = "cookie_hmac_alg",
22a1f514	179	.data = &init_net.sctp.sctp_hmac_alg,
3c68198e NH	180	.maxlen = 8,
	181	.mode = 0644,
	182	.proc_handler = proc_sctp_do_hmac_alg,
	183	},
e1fc3b14 EB	184	{
	185	.procname = "valid_cookie_life",
	186	.data = &init_net.sctp.valid_cookie_life,
	187	.maxlen = sizeof(unsigned int),
	188	.mode = 0644,
6d9f239a	189	.proc_handler = proc_dointvec_minmax,
eec4844f	190	.extra1 = SYSCTL_ONE,
e1fc3b14	191	.extra2 = &timer_max
1da177e4	192	},
4eb701df	193	{
e1fc3b14 EB	194	.procname = "sack_timeout",
e1fc3b14 EB	195	.data = &init_net.sctp.sack_timeout,
4eb701df NH	196	.maxlen = sizeof(int),
4eb701df NH	197	.mode = 0644,
e1fc3b14 EB	198	.proc_handler = proc_dointvec_minmax,
	199	.extra1 = &sack_timer_min,
	200	.extra2 = &sack_timer_max,
4eb701df	201	},
049b3ff5	202	{
e1fc3b14 EB	203	.procname = "hb_interval",
	204	.data = &init_net.sctp.hb_interval,
	205	.maxlen = sizeof(unsigned int),
049b3ff5	206	.mode = 0644,
e1fc3b14	207	.proc_handler = proc_dointvec_minmax,
eec4844f	208	.extra1 = SYSCTL_ONE,
e1fc3b14	209	.extra2 = &timer_max
049b3ff5	210	},
1da177e4	211	{
e1fc3b14 EB	212	.procname = "association_max_retrans",
e1fc3b14 EB	213	.data = &init_net.sctp.max_retrans_association,
1da177e4 LT	214	.maxlen = sizeof(int),
1da177e4 LT	215	.mode = 0644,
6d9f239a	216	.proc_handler = proc_dointvec_minmax,
eec4844f MC	217	.extra1 = SYSCTL_ONE,
eec4844f MC	218	.extra2 = SYSCTL_INT_MAX,
1da177e4	219	},
5aa93bcf	220	{
e1fc3b14 EB	221	.procname = "path_max_retrans",
e1fc3b14 EB	222	.data = &init_net.sctp.max_retrans_path,
5aa93bcf NH	223	.maxlen = sizeof(int),
	224	.mode = 0644,
	225	.proc_handler = proc_dointvec_minmax,
eec4844f MC	226	.extra1 = SYSCTL_ONE,
eec4844f MC	227	.extra2 = SYSCTL_INT_MAX,
5aa93bcf	228	},
1da177e4	229	{
1da177e4	230	.procname = "max_init_retransmits",
e1fc3b14	231	.data = &init_net.sctp.max_retrans_init,
1da177e4 LT	232	.maxlen = sizeof(int),
1da177e4 LT	233	.mode = 0644,
6d9f239a	234	.proc_handler = proc_dointvec_minmax,
eec4844f MC	235	.extra1 = SYSCTL_ONE,
eec4844f MC	236	.extra2 = SYSCTL_INT_MAX,
1da177e4	237	},
1da177e4	238	{
e1fc3b14 EB	239	.procname = "sndbuf_policy",
e1fc3b14 EB	240	.data = &init_net.sctp.sndbuf_policy,
8116ffad	241	.maxlen = sizeof(int),
1da177e4	242	.mode = 0644,
6d9f239a	243	.proc_handler = proc_dointvec,
1da177e4 LT	244	},
1da177e4 LT	245	{
e1fc3b14 EB	246	.procname = "rcvbuf_policy",
e1fc3b14 EB	247	.data = &init_net.sctp.rcvbuf_policy,
dd51be0f MH	248	.maxlen = sizeof(int),
	249	.mode = 0644,
	250	.proc_handler = proc_dointvec,
	251	},
	252	{
	253	.procname = "default_auto_asconf",
e1fc3b14	254	.data = &init_net.sctp.default_auto_asconf,
1da177e4 LT	255	.maxlen = sizeof(int),
1da177e4 LT	256	.mode = 0644,
6d9f239a	257	.proc_handler = proc_dointvec,
1da177e4 LT	258	},
1da177e4 LT	259	{
e1fc3b14 EB	260	.procname = "addip_enable",
e1fc3b14 EB	261	.data = &init_net.sctp.addip_enable,
1da177e4 LT	262	.maxlen = sizeof(int),
1da177e4 LT	263	.mode = 0644,
6d9f239a	264	.proc_handler = proc_dointvec,
1da177e4	265	},
2f85a429	266	{
e1fc3b14 EB	267	.procname = "addip_noauth_enable",
e1fc3b14 EB	268	.data = &init_net.sctp.addip_noauth,
d48e074d	269	.maxlen = sizeof(int),
2f85a429	270	.mode = 0644,
6d9f239a	271	.proc_handler = proc_dointvec,
4d93df0a NH	272	},
4d93df0a NH	273	{
e1fc3b14 EB	274	.procname = "prsctp_enable",
e1fc3b14 EB	275	.data = &init_net.sctp.prsctp_enable,
a29a5bd4 VY	276	.maxlen = sizeof(int),
a29a5bd4 VY	277	.mode = 0644,
6d9f239a	278	.proc_handler = proc_dointvec,
a29a5bd4	279	},
c0d8bab6 XL	280	{
	281	.procname = "reconf_enable",
	282	.data = &init_net.sctp.reconf_enable,
	283	.maxlen = sizeof(int),
	284	.mode = 0644,
	285	.proc_handler = proc_dointvec,
	286	},
73d9c4fd	287	{
e1fc3b14 EB	288	.procname = "auth_enable",
e1fc3b14 EB	289	.data = &init_net.sctp.auth_enable,
73d9c4fd VY	290	.maxlen = sizeof(int),
73d9c4fd VY	291	.mode = 0644,
b14878cc	292	.proc_handler = proc_sctp_do_auth,
73d9c4fd	293	},
463118c3 XL	294	{
	295	.procname = "intl_enable",
	296	.data = &init_net.sctp.intl_enable,
	297	.maxlen = sizeof(int),
	298	.mode = 0644,
	299	.proc_handler = proc_dointvec,
	300	},
2f5268a9 XL	301	{
	302	.procname = "ecn_enable",
	303	.data = &init_net.sctp.ecn_enable,
	304	.maxlen = sizeof(int),
	305	.mode = 0644,
	306	.proc_handler = proc_dointvec,
	307	},
d1e462a7 XL	308	{
	309	.procname = "plpmtud_probe_interval",
	310	.data = &init_net.sctp.probe_interval,
	311	.maxlen = sizeof(int),
	312	.mode = 0644,
	313	.proc_handler = proc_sctp_do_probe_interval,
	314	},
046c052b XL	315	{
	316	.procname = "udp_port",
	317	.data = &init_net.sctp.udp_port,
	318	.maxlen = sizeof(int),
	319	.mode = 0644,
	320	.proc_handler = proc_sctp_do_udp_port,
	321	.extra1 = SYSCTL_ZERO,
	322	.extra2 = &udp_port_max,
	323	},
e8a3001c XL	324	{
	325	.procname = "encap_port",
	326	.data = &init_net.sctp.encap_port,
	327	.maxlen = sizeof(int),
	328	.mode = 0644,
b2540cdc	329	.proc_handler = proc_dointvec_minmax,
e8a3001c XL	330	.extra1 = SYSCTL_ZERO,
	331	.extra2 = &udp_port_max,
	332	},
72388433	333	{
72388433	334	.procname = "addr_scope_policy",
e1fc3b14	335	.data = &init_net.sctp.scope_policy,
72388433 BD	336	.maxlen = sizeof(int),
72388433 BD	337	.mode = 0644,
6d456111	338	.proc_handler = proc_dointvec_minmax,
eec4844f	339	.extra1 = SYSCTL_ZERO,
72388433 BD	340	.extra2 = &addr_scope_max,
72388433 BD	341	},
90f2f531	342	{
90f2f531	343	.procname = "rwnd_update_shift",
e1fc3b14	344	.data = &init_net.sctp.rwnd_upd_shift,
90f2f531 VY	345	.maxlen = sizeof(int),
	346	.mode = 0644,
	347	.proc_handler = &proc_dointvec_minmax,
eec4844f	348	.extra1 = SYSCTL_ONE,
90f2f531 VY	349	.extra2 = &rwnd_scale_max,
90f2f531 VY	350	},
2692ba61 XW	351	{
2692ba61 XW	352	.procname = "max_autoclose",
e1fc3b14	353	.data = &init_net.sctp.max_autoclose,
2692ba61 XW	354	.maxlen = sizeof(unsigned long),
	355	.mode = 0644,
	356	.proc_handler = &proc_doulongvec_minmax,
	357	.extra1 = &max_autoclose_min,
	358	.extra2 = &max_autoclose_max,
	359	},
b712d032 XL	360	#ifdef CONFIG_NET_L3_MASTER_DEV
	361	{
	362	.procname = "l3mdev_accept",
	363	.data = &init_net.sctp.l3mdev_accept,
	364	.maxlen = sizeof(int),
	365	.mode = 0644,
	366	.proc_handler = proc_dointvec_minmax,
	367	.extra1 = SYSCTL_ZERO,
	368	.extra2 = SYSCTL_ONE,
	369	},
	370	#endif
566178f8 ZY	371	{
	372	.procname = "pf_enable",
	373	.data = &init_net.sctp.pf_enable,
	374	.maxlen = sizeof(int),
	375	.mode = 0644,
	376	.proc_handler = proc_dointvec,
	377	},
aef587be XL	378	{
	379	.procname = "pf_expose",
	380	.data = &init_net.sctp.pf_expose,
	381	.maxlen = sizeof(int),
	382	.mode = 0644,
	383	.proc_handler = proc_dointvec_minmax,
	384	.extra1 = SYSCTL_ZERO,
	385	.extra2 = &pf_expose_max,
	386	},
71acc0dd	387
d7fc02c7	388	{ /* sentinel */ }
1da177e4 LT	389	};
1da177e4 LT	390
b486b228	391	static int proc_sctp_do_hmac_alg(struct ctl_table *ctl, int write,
32927393	392	void buffer, size_t lenp, loff_t *ppos)
3c68198e NH	393	{
3c68198e NH	394	struct net *net = current->nsproxy->net_ns;
fe2c6338	395	struct ctl_table tbl;
ff5e92c1	396	bool changed = false;
3c68198e	397	char *none = "none";
320f1a4a	398	char tmp[8] = {0};
ff5e92c1	399	int ret;
3c68198e NH	400
	401	memset(&tbl, 0, sizeof(struct ctl_table));
	402
	403	if (write) {
	404	tbl.data = tmp;
ff5e92c1	405	tbl.maxlen = sizeof(tmp);
3c68198e NH	406	} else {
	407	tbl.data = net->sctp.sctp_hmac_alg ? : none;
	408	tbl.maxlen = strlen(tbl.data);
	409	}
3c68198e	410
ff5e92c1 DB	411	ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
ff5e92c1 DB	412	if (write && ret == 0) {
3c68198e NH	413	#ifdef CONFIG_CRYPTO_MD5
	414	if (!strncmp(tmp, "md5", 3)) {
	415	net->sctp.sctp_hmac_alg = "md5";
ff5e92c1	416	changed = true;
3c68198e NH	417	}
	418	#endif
	419	#ifdef CONFIG_CRYPTO_SHA1
	420	if (!strncmp(tmp, "sha1", 4)) {
	421	net->sctp.sctp_hmac_alg = "sha1";
ff5e92c1	422	changed = true;
3c68198e NH	423	}
	424	#endif
	425	if (!strncmp(tmp, "none", 4)) {
	426	net->sctp.sctp_hmac_alg = NULL;
ff5e92c1	427	changed = true;
3c68198e	428	}
3c68198e NH	429	if (!changed)
	430	ret = -EINVAL;
	431	}
	432
	433	return ret;
	434	}
	435
4f3fdf3b	436	static int proc_sctp_do_rto_min(struct ctl_table *ctl, int write,
32927393	437	void buffer, size_t lenp, loff_t *ppos)
4f3fdf3b	438	{
4f3fdf3b	439	struct net *net = current->nsproxy->net_ns;
4f3fdf3b	440	unsigned int min = (unsigned int ) ctl->extra1;
4f3fdf3b	441	unsigned int max = (unsigned int ) ctl->extra2;
ff5e92c1 DB	442	struct ctl_table tbl;
ff5e92c1 DB	443	int ret, new_value;
4f3fdf3b	444
	445	memset(&tbl, 0, sizeof(struct ctl_table));
	446	tbl.maxlen = sizeof(unsigned int);
	447
	448	if (write)
	449	tbl.data = &new_value;
	450	else
	451	tbl.data = &net->sctp.rto_min;
ff5e92c1	452
4f3fdf3b	453	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
ff5e92c1 DB	454	if (write && ret == 0) {
ff5e92c1 DB	455	if (new_value > max \|\| new_value < min)
4f3fdf3b	456	return -EINVAL;
ff5e92c1	457
4f3fdf3b	458	net->sctp.rto_min = new_value;
4f3fdf3b	459	}
ff5e92c1	460
4f3fdf3b	461	return ret;
	462	}
	463
	464	static int proc_sctp_do_rto_max(struct ctl_table *ctl, int write,
32927393	465	void buffer, size_t lenp, loff_t *ppos)
4f3fdf3b	466	{
4f3fdf3b	467	struct net *net = current->nsproxy->net_ns;
4f3fdf3b	468	unsigned int min = (unsigned int ) ctl->extra1;
4f3fdf3b	469	unsigned int max = (unsigned int ) ctl->extra2;
ff5e92c1 DB	470	struct ctl_table tbl;
ff5e92c1 DB	471	int ret, new_value;
4f3fdf3b	472
	473	memset(&tbl, 0, sizeof(struct ctl_table));
	474	tbl.maxlen = sizeof(unsigned int);
	475
	476	if (write)
	477	tbl.data = &new_value;
	478	else
	479	tbl.data = &net->sctp.rto_max;
ff5e92c1	480
4f3fdf3b	481	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
ff5e92c1 DB	482	if (write && ret == 0) {
ff5e92c1 DB	483	if (new_value > max \|\| new_value < min)
4f3fdf3b	484	return -EINVAL;
ff5e92c1	485
4f3fdf3b	486	net->sctp.rto_max = new_value;
4f3fdf3b	487	}
ff5e92c1	488
4f3fdf3b	489	return ret;
	490	}
	491
b58537a1	492	static int proc_sctp_do_alpha_beta(struct ctl_table *ctl, int write,
32927393	493	void buffer, size_t lenp, loff_t *ppos)
b58537a1	494	{
eaea2da7 DB	495	if (write)
	496	pr_warn_once("Changing rto_alpha or rto_beta may lead to "
	497	"suboptimal rtt/srtt estimations!\n");
b58537a1 DB	498
	499	return proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
	500	}
	501
b14878cc	502	static int proc_sctp_do_auth(struct ctl_table *ctl, int write,
32927393	503	void buffer, size_t lenp, loff_t *ppos)
b14878cc VY	504	{
	505	struct net *net = current->nsproxy->net_ns;
	506	struct ctl_table tbl;
	507	int new_value, ret;
	508
	509	memset(&tbl, 0, sizeof(struct ctl_table));
	510	tbl.maxlen = sizeof(unsigned int);
	511
	512	if (write)
	513	tbl.data = &new_value;
	514	else
	515	tbl.data = &net->sctp.auth_enable;
	516
	517	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
24599e61	518	if (write && ret == 0) {
b14878cc VY	519	struct sock *sk = net->sctp.ctl_sock;
	520
	521	net->sctp.auth_enable = new_value;
	522	/* Update the value in the control socket */
	523	lock_sock(sk);
	524	sctp_sk(sk)->ep->auth_enable = new_value;
	525	release_sock(sk);
	526	}
	527
	528	return ret;
	529	}
	530
046c052b XL	531	static int proc_sctp_do_udp_port(struct ctl_table *ctl, int write,
	532	void buffer, size_t lenp, loff_t *ppos)
	533	{
	534	struct net *net = current->nsproxy->net_ns;
	535	unsigned int min = (unsigned int )ctl->extra1;
	536	unsigned int max = (unsigned int )ctl->extra2;
	537	struct ctl_table tbl;
	538	int ret, new_value;
	539
	540	memset(&tbl, 0, sizeof(struct ctl_table));
	541	tbl.maxlen = sizeof(unsigned int);
	542
	543	if (write)
	544	tbl.data = &new_value;
	545	else
	546	tbl.data = &net->sctp.udp_port;
	547
	548	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
	549	if (write && ret == 0) {
	550	struct sock *sk = net->sctp.ctl_sock;
	551
	552	if (new_value > max \|\| new_value < min)
	553	return -EINVAL;
	554
	555	net->sctp.udp_port = new_value;
	556	sctp_udp_sock_stop(net);
	557	if (new_value) {
	558	ret = sctp_udp_sock_start(net);
	559	if (ret)
	560	net->sctp.udp_port = 0;
	561	}
	562
	563	/* Update the value in the control socket */
	564	lock_sock(sk);
	565	sctp_sk(sk)->udp_port = htons(net->sctp.udp_port);
	566	release_sock(sk);
	567	}
	568
	569	return ret;
	570	}
	571
d1e462a7 XL	572	static int proc_sctp_do_probe_interval(struct ctl_table *ctl, int write,
	573	void buffer, size_t lenp, loff_t *ppos)
	574	{
	575	struct net *net = current->nsproxy->net_ns;
	576	struct ctl_table tbl;
	577	int ret, new_value;
	578
	579	memset(&tbl, 0, sizeof(struct ctl_table));
	580	tbl.maxlen = sizeof(unsigned int);
	581
	582	if (write)
	583	tbl.data = &new_value;
	584	else
	585	tbl.data = &net->sctp.probe_interval;
	586
	587	ret = proc_dointvec(&tbl, write, buffer, lenp, ppos);
	588	if (write && ret == 0) {
	589	if (new_value && new_value < SCTP_PROBE_TIMER_MIN)
	590	return -EINVAL;
	591
	592	net->sctp.probe_interval = new_value;
	593	}
	594
	595	return ret;
	596	}
	597
ebb7e95d EB	598	int sctp_sysctl_net_register(struct net *net)
ebb7e95d EB	599	{
eb9f3705	600	struct ctl_table *table;
eb9f3705	601	int i;
ebb7e95d	602
eb9f3705	603	table = kmemdup(sctp_net_table, sizeof(sctp_net_table), GFP_KERNEL);
	604	if (!table)
	605	return -ENOMEM;
ebb7e95d	606
eb9f3705	607	for (i = 0; table[i].data; i++)
eb9f3705	608	table[i].data += (char )(&net->sctp) - (char )&init_net.sctp;
e1fc3b14	609
da05cecc FY	610	table[SCTP_RTO_MIN_IDX].extra2 = &net->sctp.rto_max;
	611	table[SCTP_RTO_MAX_IDX].extra1 = &net->sctp.rto_min;
	612	table[SCTP_PF_RETRANS_IDX].extra2 = &net->sctp.ps_retrans;
	613	table[SCTP_PS_RETRANS_IDX].extra1 = &net->sctp.pf_retrans;
	614
ebb7e95d	615	net->sctp.sysctl_header = register_net_sysctl(net, "net/sctp", table);
f66138c8	616	if (net->sctp.sysctl_header == NULL) {
	617	kfree(table);
	618	return -ENOMEM;
	619	}
ebb7e95d EB	620	return 0;
	621	}
	622
	623	void sctp_sysctl_net_unregister(struct net *net)
	624	{
5f19d121 VY	625	struct ctl_table *table;
	626
	627	table = net->sctp.sysctl_header->ctl_table_arg;
ebb7e95d	628	unregister_net_sysctl_table(net->sctp.sysctl_header);
5f19d121	629	kfree(table);
ebb7e95d EB	630	}
ebb7e95d EB	631
26ac8e5f	632	static struct ctl_table_header *sctp_sysctl_header;
1da177e4 LT	633
	634	/* Sysctl registration. */
	635	void sctp_sysctl_register(void)
	636	{
ec8f23ce	637	sctp_sysctl_header = register_net_sysctl(&init_net, "net/sctp", sctp_table);
1da177e4 LT	638	}
	639
	640	/* Sysctl deregistration. */
	641	void sctp_sysctl_unregister(void)
	642	{
5dd3df10	643	unregister_net_sysctl_table(sctp_sysctl_header);
1da177e4	644	}