?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: usb-audio: Fix an out-of-bound read in create_composite_quirks
[linux/fpc-iii.git] / net / ipv4 / sysctl_net_ipv4.c
blobda90c74d12ef25e9bc686e5b5d0a7e7f44217204
1 /*
2 * sysctl_net_ipv4.c: sysctl interface to net IPV4 subsystem.
3 *
4 * Begun April 1, 1996, Mike Shaver.
5 * Added /proc/sys/net/ipv4 directory entry (empty =) ). [MS]
6 */
7
8 #include <linux/mm.h>
9 #include <linux/module.h>
10 #include <linux/sysctl.h>
11 #include <linux/igmp.h>
12 #include <linux/inetdevice.h>
13 #include <linux/seqlock.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/nsproxy.h>
17 #include <linux/swap.h>
18 #include <net/snmp.h>
19 #include <net/icmp.h>
20 #include <net/ip.h>
21 #include <net/route.h>
22 #include <net/tcp.h>
23 #include <net/udp.h>
24 #include <net/cipso_ipv4.h>
25 #include <net/inet_frag.h>
26 #include <net/ping.h>
27 #include <net/tcp_memcontrol.h>
28
29 static int zero;
30 static int one = 1;
31 static int four = 4;
32 static int thousand = 1000;
33 static int gso_max_segs = GSO_MAX_SEGS;
34 static int tcp_retr1_max = 255;
35 static int ip_local_port_range_min[] = { 1, 1 };
36 static int ip_local_port_range_max[] = { 65535, 65535 };
37 static int tcp_adv_win_scale_min = -31;
38 static int tcp_adv_win_scale_max = 31;
39 static int ip_ttl_min = 1;
40 static int ip_ttl_max = 255;
41 static int tcp_syn_retries_min = 1;
42 static int tcp_syn_retries_max = MAX_TCP_SYNCNT;
43 static int ip_ping_group_range_min[] = { 0, 0 };
44 static int ip_ping_group_range_max[] = { GID_T_MAX, GID_T_MAX };
45
46 /* Update system visible IP port range */
47 static void set_local_port_range(struct net *net, int range[2])
48 {
49 bool same_parity = !((range[0] ^ range[1]) & 1);
50
51 write_seqlock_bh(&net->ipv4.ip_local_ports.lock);
52 if (same_parity && !net->ipv4.ip_local_ports.warned) {
53 net->ipv4.ip_local_ports.warned = true;
54 pr_err_ratelimited("ip_local_port_range: prefer different parity for start/end values.\n");
55 }
56 net->ipv4.ip_local_ports.range[0] = range[0];
57 net->ipv4.ip_local_ports.range[1] = range[1];
58 write_sequnlock_bh(&net->ipv4.ip_local_ports.lock);
59 }
60
61 /* Validate changes from /proc interface. */
62 static int ipv4_local_port_range(struct ctl_table *table, int write,
63 void __user *buffer,
64 size_t *lenp, loff_t *ppos)
65 {
66 struct net *net =
67 container_of(table->data, struct net, ipv4.ip_local_ports.range);
68 int ret;
69 int range[2];
70 struct ctl_table tmp = {
71 .data = &range,
72 .maxlen = sizeof(range),
73 .mode = table->mode,
74 .extra1 = &ip_local_port_range_min,
75 .extra2 = &ip_local_port_range_max,
76 };
77
78 inet_get_local_port_range(net, &range[0], &range[1]);
79
80 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
81
82 if (write && ret == 0) {
83 if (range[1] < range[0])
84 ret = -EINVAL;
85 else
86 set_local_port_range(net, range);
87 }
88
89 return ret;
90 }
91
92
93 static void inet_get_ping_group_range_table(struct ctl_table *table, kgid_t *low, kgid_t *high)
94 {
95 kgid_t *data = table->data;
96 struct net *net =
97 container_of(table->data, struct net, ipv4.ping_group_range.range);
98 unsigned int seq;
99 do {
100 seq = read_seqbegin(&net->ipv4.ping_group_range.lock);
101
102 *low = data[0];
103 *high = data[1];
104 } while (read_seqretry(&net->ipv4.ping_group_range.lock, seq));
105 }
106
107 /* Update system visible IP port range */
108 static void set_ping_group_range(struct ctl_table *table, kgid_t low, kgid_t high)
109 {
110 kgid_t *data = table->data;
111 struct net *net =
112 container_of(table->data, struct net, ipv4.ping_group_range.range);
113 write_seqlock(&net->ipv4.ping_group_range.lock);
114 data[0] = low;
115 data[1] = high;
116 write_sequnlock(&net->ipv4.ping_group_range.lock);
117 }
118
119 /* Validate changes from /proc interface. */
120 static int ipv4_ping_group_range(struct ctl_table *table, int write,
121 void __user *buffer,
122 size_t *lenp, loff_t *ppos)
123 {
124 struct user_namespace *user_ns = current_user_ns();
125 int ret;
126 gid_t urange[2];
127 kgid_t low, high;
128 struct ctl_table tmp = {
129 .data = &urange,
130 .maxlen = sizeof(urange),
131 .mode = table->mode,
132 .extra1 = &ip_ping_group_range_min,
133 .extra2 = &ip_ping_group_range_max,
134 };
135
136 inet_get_ping_group_range_table(table, &low, &high);
137 urange[0] = from_kgid_munged(user_ns, low);
138 urange[1] = from_kgid_munged(user_ns, high);
139 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
140
141 if (write && ret == 0) {
142 low = make_kgid(user_ns, urange[0]);
143 high = make_kgid(user_ns, urange[1]);
144 if (!gid_valid(low) || !gid_valid(high))
145 return -EINVAL;
146 if (urange[1] < urange[0] || gid_lt(high, low)) {
147 low = make_kgid(&init_user_ns, 1);
148 high = make_kgid(&init_user_ns, 0);
149 }
150 set_ping_group_range(table, low, high);
151 }
152
153 return ret;
154 }
155
156 static int proc_tcp_congestion_control(struct ctl_table *ctl, int write,
157 void __user *buffer, size_t *lenp, loff_t *ppos)
158 {
159 char val[TCP_CA_NAME_MAX];
160 struct ctl_table tbl = {
161 .data = val,
162 .maxlen = TCP_CA_NAME_MAX,
163 };
164 int ret;
165
166 tcp_get_default_congestion_control(val);
167
168 ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
169 if (write && ret == 0)
170 ret = tcp_set_default_congestion_control(val);
171 return ret;
172 }
173
174 static int proc_tcp_available_congestion_control(struct ctl_table *ctl,
175 int write,
176 void __user *buffer, size_t *lenp,
177 loff_t *ppos)
178 {
179 struct ctl_table tbl = { .maxlen = TCP_CA_BUF_MAX, };
180 int ret;
181
182 tbl.data = kmalloc(tbl.maxlen, GFP_USER);
183 if (!tbl.data)
184 return -ENOMEM;
185 tcp_get_available_congestion_control(tbl.data, TCP_CA_BUF_MAX);
186 ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
187 kfree(tbl.data);
188 return ret;
189 }
190
191 static int proc_allowed_congestion_control(struct ctl_table *ctl,
192 int write,
193 void __user *buffer, size_t *lenp,
194 loff_t *ppos)
195 {
196 struct ctl_table tbl = { .maxlen = TCP_CA_BUF_MAX };
197 int ret;
198
199 tbl.data = kmalloc(tbl.maxlen, GFP_USER);
200 if (!tbl.data)
201 return -ENOMEM;
202
203 tcp_get_allowed_congestion_control(tbl.data, tbl.maxlen);
204 ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
205 if (write && ret == 0)
206 ret = tcp_set_allowed_congestion_control(tbl.data);
207 kfree(tbl.data);
208 return ret;
209 }
210
211 static int proc_tcp_fastopen_key(struct ctl_table *ctl, int write,
212 void __user *buffer, size_t *lenp,
213 loff_t *ppos)
214 {
215 struct ctl_table tbl = { .maxlen = (TCP_FASTOPEN_KEY_LENGTH * 2 + 10) };
216 struct tcp_fastopen_context *ctxt;
217 u32 user_key[4]; /* 16 bytes, matching TCP_FASTOPEN_KEY_LENGTH */
218 __le32 key[4];
219 int ret, i;
220
221 tbl.data = kmalloc(tbl.maxlen, GFP_KERNEL);
222 if (!tbl.data)
223 return -ENOMEM;
224
225 rcu_read_lock();
226 ctxt = rcu_dereference(tcp_fastopen_ctx);
227 if (ctxt)
228 memcpy(key, ctxt->key, TCP_FASTOPEN_KEY_LENGTH);
229 else
230 memset(key, 0, sizeof(key));
231 rcu_read_unlock();
232
233 for (i = 0; i < ARRAY_SIZE(key); i++)
234 user_key[i] = le32_to_cpu(key[i]);
235
236 snprintf(tbl.data, tbl.maxlen, "%08x-%08x-%08x-%08x",
237 user_key[0], user_key[1], user_key[2], user_key[3]);
238 ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
239
240 if (write && ret == 0) {
241 if (sscanf(tbl.data, "%x-%x-%x-%x", user_key, user_key + 1,
242 user_key + 2, user_key + 3) != 4) {
243 ret = -EINVAL;
244 goto bad_key;
245 }
246 /* Generate a dummy secret but don't publish it. This
247 * is needed so we don't regenerate a new key on the
248 * first invocation of tcp_fastopen_cookie_gen
249 */
250 tcp_fastopen_init_key_once(false);
251
252 for (i = 0; i < ARRAY_SIZE(user_key); i++)
253 key[i] = cpu_to_le32(user_key[i]);
254
255 tcp_fastopen_reset_cipher(key, TCP_FASTOPEN_KEY_LENGTH);
256 }
257
258 bad_key:
259 pr_debug("proc FO key set 0x%x-%x-%x-%x <- 0x%s: %u\n",
260 user_key[0], user_key[1], user_key[2], user_key[3],
261 (char *)tbl.data, ret);
262 kfree(tbl.data);
263 return ret;
264 }
265
266 static struct ctl_table ipv4_table[] = {
267 {
268 .procname = "tcp_timestamps",
269 .data = &sysctl_tcp_timestamps,
270 .maxlen = sizeof(int),
271 .mode = 0644,
272 .proc_handler = proc_dointvec
273 },
274 {
275 .procname = "tcp_window_scaling",
276 .data = &sysctl_tcp_window_scaling,
277 .maxlen = sizeof(int),
278 .mode = 0644,
279 .proc_handler = proc_dointvec
280 },
281 {
282 .procname = "tcp_sack",
283 .data = &sysctl_tcp_sack,
284 .maxlen = sizeof(int),
285 .mode = 0644,
286 .proc_handler = proc_dointvec
287 },
288 {
289 .procname = "tcp_retrans_collapse",
290 .data = &sysctl_tcp_retrans_collapse,
291 .maxlen = sizeof(int),
292 .mode = 0644,
293 .proc_handler = proc_dointvec
294 },
295 {
296 .procname = "ip_default_ttl",
297 .data = &sysctl_ip_default_ttl,
298 .maxlen = sizeof(int),
299 .mode = 0644,
300 .proc_handler = proc_dointvec_minmax,
301 .extra1 = &ip_ttl_min,
302 .extra2 = &ip_ttl_max,
303 },
304 {
305 .procname = "tcp_syn_retries",
306 .data = &sysctl_tcp_syn_retries,
307 .maxlen = sizeof(int),
308 .mode = 0644,
309 .proc_handler = proc_dointvec_minmax,
310 .extra1 = &tcp_syn_retries_min,
311 .extra2 = &tcp_syn_retries_max
312 },
313 {
314 .procname = "tcp_synack_retries",
315 .data = &sysctl_tcp_synack_retries,
316 .maxlen = sizeof(int),
317 .mode = 0644,
318 .proc_handler = proc_dointvec
319 },
320 {
321 .procname = "tcp_max_orphans",
322 .data = &sysctl_tcp_max_orphans,
323 .maxlen = sizeof(int),
324 .mode = 0644,
325 .proc_handler = proc_dointvec
326 },
327 {
328 .procname = "tcp_max_tw_buckets",
329 .data = &tcp_death_row.sysctl_max_tw_buckets,
330 .maxlen = sizeof(int),
331 .mode = 0644,
332 .proc_handler = proc_dointvec
333 },
334 {
335 .procname = "ip_early_demux",
336 .data = &sysctl_ip_early_demux,
337 .maxlen = sizeof(int),
338 .mode = 0644,
339 .proc_handler = proc_dointvec
340 },
341 {
342 .procname = "ip_dynaddr",
343 .data = &sysctl_ip_dynaddr,
344 .maxlen = sizeof(int),
345 .mode = 0644,
346 .proc_handler = proc_dointvec
347 },
348 {
349 .procname = "tcp_keepalive_time",
350 .data = &sysctl_tcp_keepalive_time,
351 .maxlen = sizeof(int),
352 .mode = 0644,
353 .proc_handler = proc_dointvec_jiffies,
354 },
355 {
356 .procname = "tcp_keepalive_probes",
357 .data = &sysctl_tcp_keepalive_probes,
358 .maxlen = sizeof(int),
359 .mode = 0644,
360 .proc_handler = proc_dointvec
361 },
362 {
363 .procname = "tcp_keepalive_intvl",
364 .data = &sysctl_tcp_keepalive_intvl,
365 .maxlen = sizeof(int),
366 .mode = 0644,
367 .proc_handler = proc_dointvec_jiffies,
368 },
369 {
370 .procname = "tcp_retries1",
371 .data = &sysctl_tcp_retries1,
372 .maxlen = sizeof(int),
373 .mode = 0644,
374 .proc_handler = proc_dointvec_minmax,
375 .extra2 = &tcp_retr1_max
376 },
377 {
378 .procname = "tcp_retries2",
379 .data = &sysctl_tcp_retries2,
380 .maxlen = sizeof(int),
381 .mode = 0644,
382 .proc_handler = proc_dointvec
383 },
384 {
385 .procname = "tcp_fin_timeout",
386 .data = &sysctl_tcp_fin_timeout,
387 .maxlen = sizeof(int),
388 .mode = 0644,
389 .proc_handler = proc_dointvec_jiffies,
390 },
391 #ifdef CONFIG_SYN_COOKIES
392 {
393 .procname = "tcp_syncookies",
394 .data = &sysctl_tcp_syncookies,
395 .maxlen = sizeof(int),
396 .mode = 0644,
397 .proc_handler = proc_dointvec
398 },
399 #endif
400 {
401 .procname = "tcp_fastopen",
402 .data = &sysctl_tcp_fastopen,
403 .maxlen = sizeof(int),
404 .mode = 0644,
405 .proc_handler = proc_dointvec,
406 },
407 {
408 .procname = "tcp_fastopen_key",
409 .mode = 0600,
410 .maxlen = ((TCP_FASTOPEN_KEY_LENGTH * 2) + 10),
411 .proc_handler = proc_tcp_fastopen_key,
412 },
413 {
414 .procname = "tcp_tw_recycle",
415 .data = &tcp_death_row.sysctl_tw_recycle,
416 .maxlen = sizeof(int),
417 .mode = 0644,
418 .proc_handler = proc_dointvec
419 },
420 {
421 .procname = "tcp_abort_on_overflow",
422 .data = &sysctl_tcp_abort_on_overflow,
423 .maxlen = sizeof(int),
424 .mode = 0644,
425 .proc_handler = proc_dointvec
426 },
427 {
428 .procname = "tcp_stdurg",
429 .data = &sysctl_tcp_stdurg,
430 .maxlen = sizeof(int),
431 .mode = 0644,
432 .proc_handler = proc_dointvec
433 },
434 {
435 .procname = "tcp_rfc1337",
436 .data = &sysctl_tcp_rfc1337,
437 .maxlen = sizeof(int),
438 .mode = 0644,
439 .proc_handler = proc_dointvec
440 },
441 {
442 .procname = "tcp_max_syn_backlog",
443 .data = &sysctl_max_syn_backlog,
444 .maxlen = sizeof(int),
445 .mode = 0644,
446 .proc_handler = proc_dointvec
447 },
448 {
449 .procname = "igmp_max_memberships",
450 .data = &sysctl_igmp_max_memberships,
451 .maxlen = sizeof(int),
452 .mode = 0644,
453 .proc_handler = proc_dointvec
454 },
455 {
456 .procname = "igmp_max_msf",
457 .data = &sysctl_igmp_max_msf,
458 .maxlen = sizeof(int),
459 .mode = 0644,
460 .proc_handler = proc_dointvec
461 },
462 #ifdef CONFIG_IP_MULTICAST
463 {
464 .procname = "igmp_qrv",
465 .data = &sysctl_igmp_qrv,
466 .maxlen = sizeof(int),
467 .mode = 0644,
468 .proc_handler = proc_dointvec_minmax,
469 .extra1 = &one
470 },
471 #endif
472 {
473 .procname = "inet_peer_threshold",
474 .data = &inet_peer_threshold,
475 .maxlen = sizeof(int),
476 .mode = 0644,
477 .proc_handler = proc_dointvec
478 },
479 {
480 .procname = "inet_peer_minttl",
481 .data = &inet_peer_minttl,
482 .maxlen = sizeof(int),
483 .mode = 0644,
484 .proc_handler = proc_dointvec_jiffies,
485 },
486 {
487 .procname = "inet_peer_maxttl",
488 .data = &inet_peer_maxttl,
489 .maxlen = sizeof(int),
490 .mode = 0644,
491 .proc_handler = proc_dointvec_jiffies,
492 },
493 {
494 .procname = "tcp_orphan_retries",
495 .data = &sysctl_tcp_orphan_retries,
496 .maxlen = sizeof(int),
497 .mode = 0644,
498 .proc_handler = proc_dointvec
499 },
500 {
501 .procname = "tcp_fack",
502 .data = &sysctl_tcp_fack,
503 .maxlen = sizeof(int),
504 .mode = 0644,
505 .proc_handler = proc_dointvec
506 },
507 {
508 .procname = "tcp_recovery",
509 .data = &sysctl_tcp_recovery,
510 .maxlen = sizeof(int),
511 .mode = 0644,
512 .proc_handler = proc_dointvec,
513 },
514 {
515 .procname = "tcp_reordering",
516 .data = &sysctl_tcp_reordering,
517 .maxlen = sizeof(int),
518 .mode = 0644,
519 .proc_handler = proc_dointvec
520 },
521 {
522 .procname = "tcp_max_reordering",
523 .data = &sysctl_tcp_max_reordering,
524 .maxlen = sizeof(int),
525 .mode = 0644,
526 .proc_handler = proc_dointvec
527 },
528 {
529 .procname = "tcp_dsack",
530 .data = &sysctl_tcp_dsack,
531 .maxlen = sizeof(int),
532 .mode = 0644,
533 .proc_handler = proc_dointvec
534 },
535 {
536 .procname = "tcp_mem",
537 .maxlen = sizeof(sysctl_tcp_mem),
538 .data = &sysctl_tcp_mem,
539 .mode = 0644,
540 .proc_handler = proc_doulongvec_minmax,
541 },
542 {
543 .procname = "tcp_wmem",
544 .data = &sysctl_tcp_wmem,
545 .maxlen = sizeof(sysctl_tcp_wmem),
546 .mode = 0644,
547 .proc_handler = proc_dointvec_minmax,
548 .extra1 = &one,
549 },
550 {
551 .procname = "tcp_notsent_lowat",
552 .data = &sysctl_tcp_notsent_lowat,
553 .maxlen = sizeof(sysctl_tcp_notsent_lowat),
554 .mode = 0644,
555 .proc_handler = proc_dointvec,
556 },
557 {
558 .procname = "tcp_rmem",
559 .data = &sysctl_tcp_rmem,
560 .maxlen = sizeof(sysctl_tcp_rmem),
561 .mode = 0644,
562 .proc_handler = proc_dointvec_minmax,
563 .extra1 = &one,
564 },
565 {
566 .procname = "tcp_app_win",
567 .data = &sysctl_tcp_app_win,
568 .maxlen = sizeof(int),
569 .mode = 0644,
570 .proc_handler = proc_dointvec
571 },
572 {
573 .procname = "tcp_adv_win_scale",
574 .data = &sysctl_tcp_adv_win_scale,
575 .maxlen = sizeof(int),
576 .mode = 0644,
577 .proc_handler = proc_dointvec_minmax,
578 .extra1 = &tcp_adv_win_scale_min,
579 .extra2 = &tcp_adv_win_scale_max,
580 },
581 {
582 .procname = "tcp_tw_reuse",
583 .data = &sysctl_tcp_tw_reuse,
584 .maxlen = sizeof(int),
585 .mode = 0644,
586 .proc_handler = proc_dointvec
587 },
588 {
589 .procname = "tcp_frto",
590 .data = &sysctl_tcp_frto,
591 .maxlen = sizeof(int),
592 .mode = 0644,
593 .proc_handler = proc_dointvec
594 },
595 {
596 .procname = "tcp_min_rtt_wlen",
597 .data = &sysctl_tcp_min_rtt_wlen,
598 .maxlen = sizeof(int),
599 .mode = 0644,
600 .proc_handler = proc_dointvec
601 },
602 {
603 .procname = "tcp_low_latency",
604 .data = &sysctl_tcp_low_latency,
605 .maxlen = sizeof(int),
606 .mode = 0644,
607 .proc_handler = proc_dointvec
608 },
609 {
610 .procname = "tcp_no_metrics_save",
611 .data = &sysctl_tcp_nometrics_save,
612 .maxlen = sizeof(int),
613 .mode = 0644,
614 .proc_handler = proc_dointvec,
615 },
616 {
617 .procname = "tcp_moderate_rcvbuf",
618 .data = &sysctl_tcp_moderate_rcvbuf,
619 .maxlen = sizeof(int),
620 .mode = 0644,
621 .proc_handler = proc_dointvec,
622 },
623 {
624 .procname = "tcp_tso_win_divisor",
625 .data = &sysctl_tcp_tso_win_divisor,
626 .maxlen = sizeof(int),
627 .mode = 0644,
628 .proc_handler = proc_dointvec,
629 },
630 {
631 .procname = "tcp_congestion_control",
632 .mode = 0644,
633 .maxlen = TCP_CA_NAME_MAX,
634 .proc_handler = proc_tcp_congestion_control,
635 },
636 {
637 .procname = "tcp_workaround_signed_windows",
638 .data = &sysctl_tcp_workaround_signed_windows,
639 .maxlen = sizeof(int),
640 .mode = 0644,
641 .proc_handler = proc_dointvec
642 },
643 {
644 .procname = "tcp_limit_output_bytes",
645 .data = &sysctl_tcp_limit_output_bytes,
646 .maxlen = sizeof(int),
647 .mode = 0644,
648 .proc_handler = proc_dointvec
649 },
650 {
651 .procname = "tcp_challenge_ack_limit",
652 .data = &sysctl_tcp_challenge_ack_limit,
653 .maxlen = sizeof(int),
654 .mode = 0644,
655 .proc_handler = proc_dointvec
656 },
657 {
658 .procname = "tcp_slow_start_after_idle",
659 .data = &sysctl_tcp_slow_start_after_idle,
660 .maxlen = sizeof(int),
661 .mode = 0644,
662 .proc_handler = proc_dointvec
663 },
664 #ifdef CONFIG_NETLABEL
665 {
666 .procname = "cipso_cache_enable",
667 .data = &cipso_v4_cache_enabled,
668 .maxlen = sizeof(int),
669 .mode = 0644,
670 .proc_handler = proc_dointvec,
671 },
672 {
673 .procname = "cipso_cache_bucket_size",
674 .data = &cipso_v4_cache_bucketsize,
675 .maxlen = sizeof(int),
676 .mode = 0644,
677 .proc_handler = proc_dointvec,
678 },
679 {
680 .procname = "cipso_rbm_optfmt",
681 .data = &cipso_v4_rbm_optfmt,
682 .maxlen = sizeof(int),
683 .mode = 0644,
684 .proc_handler = proc_dointvec,
685 },
686 {
687 .procname = "cipso_rbm_strictvalid",
688 .data = &cipso_v4_rbm_strictvalid,
689 .maxlen = sizeof(int),
690 .mode = 0644,
691 .proc_handler = proc_dointvec,
692 },
693 #endif /* CONFIG_NETLABEL */
694 {
695 .procname = "tcp_available_congestion_control",
696 .maxlen = TCP_CA_BUF_MAX,
697 .mode = 0444,
698 .proc_handler = proc_tcp_available_congestion_control,
699 },
700 {
701 .procname = "tcp_allowed_congestion_control",
702 .maxlen = TCP_CA_BUF_MAX,
703 .mode = 0644,
704 .proc_handler = proc_allowed_congestion_control,
705 },
706 {
707 .procname = "tcp_thin_linear_timeouts",
708 .data = &sysctl_tcp_thin_linear_timeouts,
709 .maxlen = sizeof(int),
710 .mode = 0644,
711 .proc_handler = proc_dointvec
712 },
713 {
714 .procname = "tcp_thin_dupack",
715 .data = &sysctl_tcp_thin_dupack,
716 .maxlen = sizeof(int),
717 .mode = 0644,
718 .proc_handler = proc_dointvec
719 },
720 {
721 .procname = "tcp_early_retrans",
722 .data = &sysctl_tcp_early_retrans,
723 .maxlen = sizeof(int),
724 .mode = 0644,
725 .proc_handler = proc_dointvec_minmax,
726 .extra1 = &zero,
727 .extra2 = &four,
728 },
729 {
730 .procname = "tcp_min_tso_segs",
731 .data = &sysctl_tcp_min_tso_segs,
732 .maxlen = sizeof(int),
733 .mode = 0644,
734 .proc_handler = proc_dointvec_minmax,
735 .extra1 = &one,
736 .extra2 = &gso_max_segs,
737 },
738 {
739 .procname = "tcp_pacing_ss_ratio",
740 .data = &sysctl_tcp_pacing_ss_ratio,
741 .maxlen = sizeof(int),
742 .mode = 0644,
743 .proc_handler = proc_dointvec_minmax,
744 .extra1 = &zero,
745 .extra2 = &thousand,
746 },
747 {
748 .procname = "tcp_pacing_ca_ratio",
749 .data = &sysctl_tcp_pacing_ca_ratio,
750 .maxlen = sizeof(int),
751 .mode = 0644,
752 .proc_handler = proc_dointvec_minmax,
753 .extra1 = &zero,
754 .extra2 = &thousand,
755 },
756 {
757 .procname = "tcp_autocorking",
758 .data = &sysctl_tcp_autocorking,
759 .maxlen = sizeof(int),
760 .mode = 0644,
761 .proc_handler = proc_dointvec_minmax,
762 .extra1 = &zero,
763 .extra2 = &one,
764 },
765 {
766 .procname = "tcp_invalid_ratelimit",
767 .data = &sysctl_tcp_invalid_ratelimit,
768 .maxlen = sizeof(int),
769 .mode = 0644,
770 .proc_handler = proc_dointvec_ms_jiffies,
771 },
772 {
773 .procname = "icmp_msgs_per_sec",
774 .data = &sysctl_icmp_msgs_per_sec,
775 .maxlen = sizeof(int),
776 .mode = 0644,
777 .proc_handler = proc_dointvec_minmax,
778 .extra1 = &zero,
779 },
780 {
781 .procname = "icmp_msgs_burst",
782 .data = &sysctl_icmp_msgs_burst,
783 .maxlen = sizeof(int),
784 .mode = 0644,
785 .proc_handler = proc_dointvec_minmax,
786 .extra1 = &zero,
787 },
788 {
789 .procname = "udp_mem",
790 .data = &sysctl_udp_mem,
791 .maxlen = sizeof(sysctl_udp_mem),
792 .mode = 0644,
793 .proc_handler = proc_doulongvec_minmax,
794 },
795 {
796 .procname = "udp_rmem_min",
797 .data = &sysctl_udp_rmem_min,
798 .maxlen = sizeof(sysctl_udp_rmem_min),
799 .mode = 0644,
800 .proc_handler = proc_dointvec_minmax,
801 .extra1 = &one
802 },
803 {
804 .procname = "udp_wmem_min",
805 .data = &sysctl_udp_wmem_min,
806 .maxlen = sizeof(sysctl_udp_wmem_min),
807 .mode = 0644,
808 .proc_handler = proc_dointvec_minmax,
809 .extra1 = &one
810 },
811 { }
812 };
813
814 static struct ctl_table ipv4_net_table[] = {
815 {
816 .procname = "icmp_echo_ignore_all",
817 .data = &init_net.ipv4.sysctl_icmp_echo_ignore_all,
818 .maxlen = sizeof(int),
819 .mode = 0644,
820 .proc_handler = proc_dointvec
821 },
822 {
823 .procname = "icmp_echo_ignore_broadcasts",
824 .data = &init_net.ipv4.sysctl_icmp_echo_ignore_broadcasts,
825 .maxlen = sizeof(int),
826 .mode = 0644,
827 .proc_handler = proc_dointvec
828 },
829 {
830 .procname = "icmp_ignore_bogus_error_responses",
831 .data = &init_net.ipv4.sysctl_icmp_ignore_bogus_error_responses,
832 .maxlen = sizeof(int),
833 .mode = 0644,
834 .proc_handler = proc_dointvec
835 },
836 {
837 .procname = "icmp_errors_use_inbound_ifaddr",
838 .data = &init_net.ipv4.sysctl_icmp_errors_use_inbound_ifaddr,
839 .maxlen = sizeof(int),
840 .mode = 0644,
841 .proc_handler = proc_dointvec
842 },
843 {
844 .procname = "icmp_ratelimit",
845 .data = &init_net.ipv4.sysctl_icmp_ratelimit,
846 .maxlen = sizeof(int),
847 .mode = 0644,
848 .proc_handler = proc_dointvec_ms_jiffies,
849 },
850 {
851 .procname = "icmp_ratemask",
852 .data = &init_net.ipv4.sysctl_icmp_ratemask,
853 .maxlen = sizeof(int),
854 .mode = 0644,
855 .proc_handler = proc_dointvec
856 },
857 {
858 .procname = "ping_group_range",
859 .data = &init_net.ipv4.ping_group_range.range,
860 .maxlen = sizeof(gid_t)*2,
861 .mode = 0644,
862 .proc_handler = ipv4_ping_group_range,
863 },
864 {
865 .procname = "tcp_ecn",
866 .data = &init_net.ipv4.sysctl_tcp_ecn,
867 .maxlen = sizeof(int),
868 .mode = 0644,
869 .proc_handler = proc_dointvec
870 },
871 {
872 .procname = "tcp_ecn_fallback",
873 .data = &init_net.ipv4.sysctl_tcp_ecn_fallback,
874 .maxlen = sizeof(int),
875 .mode = 0644,
876 .proc_handler = proc_dointvec
877 },
878 {
879 .procname = "ip_local_port_range",
880 .maxlen = sizeof(init_net.ipv4.ip_local_ports.range),
881 .data = &init_net.ipv4.ip_local_ports.range,
882 .mode = 0644,
883 .proc_handler = ipv4_local_port_range,
884 },
885 {
886 .procname = "ip_local_reserved_ports",
887 .data = &init_net.ipv4.sysctl_local_reserved_ports,
888 .maxlen = 65536,
889 .mode = 0644,
890 .proc_handler = proc_do_large_bitmap,
891 },
892 {
893 .procname = "ip_no_pmtu_disc",
894 .data = &init_net.ipv4.sysctl_ip_no_pmtu_disc,
895 .maxlen = sizeof(int),
896 .mode = 0644,
897 .proc_handler = proc_dointvec
898 },
899 {
900 .procname = "ip_forward_use_pmtu",
901 .data = &init_net.ipv4.sysctl_ip_fwd_use_pmtu,
902 .maxlen = sizeof(int),
903 .mode = 0644,
904 .proc_handler = proc_dointvec,
905 },
906 {
907 .procname = "ip_nonlocal_bind",
908 .data = &init_net.ipv4.sysctl_ip_nonlocal_bind,
909 .maxlen = sizeof(int),
910 .mode = 0644,
911 .proc_handler = proc_dointvec
912 },
913 {
914 .procname = "fwmark_reflect",
915 .data = &init_net.ipv4.sysctl_fwmark_reflect,
916 .maxlen = sizeof(int),
917 .mode = 0644,
918 .proc_handler = proc_dointvec,
919 },
920 {
921 .procname = "tcp_fwmark_accept",
922 .data = &init_net.ipv4.sysctl_tcp_fwmark_accept,
923 .maxlen = sizeof(int),
924 .mode = 0644,
925 .proc_handler = proc_dointvec,
926 },
927 {
928 .procname = "tcp_mtu_probing",
929 .data = &init_net.ipv4.sysctl_tcp_mtu_probing,
930 .maxlen = sizeof(int),
931 .mode = 0644,
932 .proc_handler = proc_dointvec,
933 },
934 {
935 .procname = "tcp_base_mss",
936 .data = &init_net.ipv4.sysctl_tcp_base_mss,
937 .maxlen = sizeof(int),
938 .mode = 0644,
939 .proc_handler = proc_dointvec,
940 },
941 {
942 .procname = "tcp_probe_threshold",
943 .data = &init_net.ipv4.sysctl_tcp_probe_threshold,
944 .maxlen = sizeof(int),
945 .mode = 0644,
946 .proc_handler = proc_dointvec,
947 },
948 {
949 .procname = "tcp_probe_interval",
950 .data = &init_net.ipv4.sysctl_tcp_probe_interval,
951 .maxlen = sizeof(int),
952 .mode = 0644,
953 .proc_handler = proc_dointvec,
954 },
955 {
956 .procname = "igmp_link_local_mcast_reports",
957 .data = &sysctl_igmp_llm_reports,
958 .maxlen = sizeof(int),
959 .mode = 0644,
960 .proc_handler = proc_dointvec
961 },
962 { }
963 };
964
965 static __net_init int ipv4_sysctl_init_net(struct net *net)
966 {
967 struct ctl_table *table;
968
969 table = ipv4_net_table;
970 if (!net_eq(net, &init_net)) {
971 int i;
972
973 table = kmemdup(table, sizeof(ipv4_net_table), GFP_KERNEL);
974 if (!table)
975 goto err_alloc;
976
977 /* Update the variables to point into the current struct net */
978 for (i = 0; i < ARRAY_SIZE(ipv4_net_table) - 1; i++)
979 table[i].data += (void *)net - (void *)&init_net;
980 }
981
982 net->ipv4.ipv4_hdr = register_net_sysctl(net, "net/ipv4", table);
983 if (!net->ipv4.ipv4_hdr)
984 goto err_reg;
985
986 net->ipv4.sysctl_local_reserved_ports = kzalloc(65536 / 8, GFP_KERNEL);
987 if (!net->ipv4.sysctl_local_reserved_ports)
988 goto err_ports;
989
990 return 0;
991
992 err_ports:
993 unregister_net_sysctl_table(net->ipv4.ipv4_hdr);
994 err_reg:
995 if (!net_eq(net, &init_net))
996 kfree(table);
997 err_alloc:
998 return -ENOMEM;
999 }
1000
1001 static __net_exit void ipv4_sysctl_exit_net(struct net *net)
1002 {
1003 struct ctl_table *table;
1004
1005 kfree(net->ipv4.sysctl_local_reserved_ports);
1006 table = net->ipv4.ipv4_hdr->ctl_table_arg;
1007 unregister_net_sysctl_table(net->ipv4.ipv4_hdr);
1008 kfree(table);
1009 }
1010
1011 static __net_initdata struct pernet_operations ipv4_sysctl_ops = {
1012 .init = ipv4_sysctl_init_net,
1013 .exit = ipv4_sysctl_exit_net,
1014 };
1015
1016 static __init int sysctl_ipv4_init(void)
1017 {
1018 struct ctl_table_header *hdr;
1019
1020 hdr = register_net_sysctl(&init_net, "net/ipv4", ipv4_table);
1021 if (!hdr)
1022 return -ENOMEM;
1023
1024 if (register_pernet_subsys(&ipv4_sysctl_ops)) {
1025 unregister_net_sysctl_table(hdr);
1026 return -ENOMEM;
1027 }
1028
1029 return 0;
1030 }
1031
1032 __initcall(sysctl_ipv4_init);
Linux with added FPC-III support