~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv4/sysctl_net_ipv4.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp