2 * sysctl_net_core.c: sysctl interface to net core subsystem.
4 * Begun April 1, 1996, Mike Shaver.
5 * Added /proc/sys/net/core directory entry (empty =) ). [MS]
9 #include <linux/sysctl.h>
10 #include <linux/module.h>
11 #include <linux/socket.h>
12 #include <linux/netdevice.h>
13 #include <linux/ratelimit.h>
14 #include <linux/vmalloc.h>
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <linux/kmemleak.h>
21 #include <net/net_ratelimit.h>
26 static int rps_sock_flow_sysctl(ctl_table *table, int write,
27 void __user *buffer, size_t *lenp, loff_t *ppos)
29 unsigned int orig_size, size;
33 .maxlen = sizeof(size),
36 struct rps_sock_flow_table *orig_sock_table, *sock_table;
37 static DEFINE_MUTEX(sock_flow_mutex);
39 mutex_lock(&sock_flow_mutex);
41 orig_sock_table = rcu_dereference_protected(rps_sock_flow_table,
42 lockdep_is_held(&sock_flow_mutex));
43 size = orig_size = orig_sock_table ? orig_sock_table->mask + 1 : 0;
45 ret = proc_dointvec(&tmp, write, buffer, lenp, ppos);
50 /* Enforce limit to prevent overflow */
51 mutex_unlock(&sock_flow_mutex);
54 size = roundup_pow_of_two(size);
55 if (size != orig_size) {
57 vmalloc(RPS_SOCK_FLOW_TABLE_SIZE(size));
59 mutex_unlock(&sock_flow_mutex);
63 sock_table->mask = size - 1;
65 sock_table = orig_sock_table;
67 for (i = 0; i < size; i++)
68 sock_table->ents[i] = RPS_NO_CPU;
72 if (sock_table != orig_sock_table) {
73 rcu_assign_pointer(rps_sock_flow_table, sock_table);
75 static_key_slow_inc(&rps_needed);
76 if (orig_sock_table) {
77 static_key_slow_dec(&rps_needed);
79 vfree(orig_sock_table);
84 mutex_unlock(&sock_flow_mutex);
88 #endif /* CONFIG_RPS */
90 #ifdef CONFIG_NET_FLOW_LIMIT
91 static DEFINE_MUTEX(flow_limit_update_mutex);
93 static int flow_limit_cpu_sysctl(ctl_table *table, int write,
94 void __user *buffer, size_t *lenp,
97 struct sd_flow_limit *cur;
98 struct softnet_data *sd;
102 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
106 ret = cpumask_parse_user(buffer, *lenp, mask);
110 mutex_lock(&flow_limit_update_mutex);
111 len = sizeof(*cur) + netdev_flow_limit_table_len;
112 for_each_possible_cpu(i) {
113 sd = &per_cpu(softnet_data, i);
114 cur = rcu_dereference_protected(sd->flow_limit,
115 lockdep_is_held(&flow_limit_update_mutex));
116 if (cur && !cpumask_test_cpu(i, mask)) {
117 RCU_INIT_POINTER(sd->flow_limit, NULL);
120 } else if (!cur && cpumask_test_cpu(i, mask)) {
121 cur = kzalloc(len, GFP_KERNEL);
123 /* not unwinding previous changes */
127 cur->num_buckets = netdev_flow_limit_table_len;
128 rcu_assign_pointer(sd->flow_limit, cur);
132 mutex_unlock(&flow_limit_update_mutex);
134 if (*ppos || !*lenp) {
141 for_each_possible_cpu(i) {
142 sd = &per_cpu(softnet_data, i);
143 if (rcu_dereference(sd->flow_limit))
144 cpumask_set_cpu(i, mask);
148 len = cpumask_scnprintf(buffer, *lenp, mask);
154 free_cpumask_var(mask);
158 static int flow_limit_table_len_sysctl(ctl_table *table, int write,
159 void __user *buffer, size_t *lenp,
162 unsigned int old, *ptr;
165 mutex_lock(&flow_limit_update_mutex);
169 ret = proc_dointvec(table, write, buffer, lenp, ppos);
170 if (!ret && write && !is_power_of_2(*ptr)) {
175 mutex_unlock(&flow_limit_update_mutex);
178 #endif /* CONFIG_NET_FLOW_LIMIT */
180 static struct ctl_table net_core_table[] = {
183 .procname = "wmem_max",
184 .data = &sysctl_wmem_max,
185 .maxlen = sizeof(int),
187 .proc_handler = proc_dointvec_minmax,
191 .procname = "rmem_max",
192 .data = &sysctl_rmem_max,
193 .maxlen = sizeof(int),
195 .proc_handler = proc_dointvec_minmax,
199 .procname = "wmem_default",
200 .data = &sysctl_wmem_default,
201 .maxlen = sizeof(int),
203 .proc_handler = proc_dointvec_minmax,
207 .procname = "rmem_default",
208 .data = &sysctl_rmem_default,
209 .maxlen = sizeof(int),
211 .proc_handler = proc_dointvec_minmax,
215 .procname = "dev_weight",
217 .maxlen = sizeof(int),
219 .proc_handler = proc_dointvec
222 .procname = "netdev_max_backlog",
223 .data = &netdev_max_backlog,
224 .maxlen = sizeof(int),
226 .proc_handler = proc_dointvec
228 #ifdef CONFIG_BPF_JIT
230 .procname = "bpf_jit_enable",
231 .data = &bpf_jit_enable,
232 .maxlen = sizeof(int),
234 .proc_handler = proc_dointvec
238 .procname = "netdev_tstamp_prequeue",
239 .data = &netdev_tstamp_prequeue,
240 .maxlen = sizeof(int),
242 .proc_handler = proc_dointvec
245 .procname = "message_cost",
246 .data = &net_ratelimit_state.interval,
247 .maxlen = sizeof(int),
249 .proc_handler = proc_dointvec_jiffies,
252 .procname = "message_burst",
253 .data = &net_ratelimit_state.burst,
254 .maxlen = sizeof(int),
256 .proc_handler = proc_dointvec,
259 .procname = "optmem_max",
260 .data = &sysctl_optmem_max,
261 .maxlen = sizeof(int),
263 .proc_handler = proc_dointvec
267 .procname = "rps_sock_flow_entries",
268 .maxlen = sizeof(int),
270 .proc_handler = rps_sock_flow_sysctl
273 #ifdef CONFIG_NET_FLOW_LIMIT
275 .procname = "flow_limit_cpu_bitmap",
277 .proc_handler = flow_limit_cpu_sysctl
280 .procname = "flow_limit_table_len",
281 .data = &netdev_flow_limit_table_len,
282 .maxlen = sizeof(int),
284 .proc_handler = flow_limit_table_len_sysctl
286 #endif /* CONFIG_NET_FLOW_LIMIT */
287 #endif /* CONFIG_NET */
289 .procname = "netdev_budget",
290 .data = &netdev_budget,
291 .maxlen = sizeof(int),
293 .proc_handler = proc_dointvec
296 .procname = "warnings",
297 .data = &net_msg_warn,
298 .maxlen = sizeof(int),
300 .proc_handler = proc_dointvec
305 static struct ctl_table netns_core_table[] = {
307 .procname = "somaxconn",
308 .data = &init_net.core.sysctl_somaxconn,
309 .maxlen = sizeof(int),
311 .proc_handler = proc_dointvec
316 static __net_init int sysctl_core_net_init(struct net *net)
318 struct ctl_table *tbl;
320 net->core.sysctl_somaxconn = SOMAXCONN;
322 tbl = netns_core_table;
323 if (!net_eq(net, &init_net)) {
324 tbl = kmemdup(tbl, sizeof(netns_core_table), GFP_KERNEL);
328 tbl[0].data = &net->core.sysctl_somaxconn;
330 /* Don't export any sysctls to unprivileged users */
331 if (net->user_ns != &init_user_ns) {
332 tbl[0].procname = NULL;
336 net->core.sysctl_hdr = register_net_sysctl(net, "net/core", tbl);
337 if (net->core.sysctl_hdr == NULL)
343 if (tbl != netns_core_table)
349 static __net_exit void sysctl_core_net_exit(struct net *net)
351 struct ctl_table *tbl;
353 tbl = net->core.sysctl_hdr->ctl_table_arg;
354 unregister_net_sysctl_table(net->core.sysctl_hdr);
355 BUG_ON(tbl == netns_core_table);
359 static __net_initdata struct pernet_operations sysctl_core_ops = {
360 .init = sysctl_core_net_init,
361 .exit = sysctl_core_net_exit,
364 static __init int sysctl_core_init(void)
366 register_net_sysctl(&init_net, "net/core", net_core_table);
367 return register_pernet_subsys(&sysctl_core_ops);
370 fs_initcall(sysctl_core_init);