1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * sysctl_net_ipv4.c: sysctl interface to net IPV4 subsystem. 4 * 5 * Begun April 1, 1996, Mike Shaver. 6 * Added /proc/sys/net/ipv4 directory entry (empty =) ). [MS] 7 */ 8 9 #include <linux/sysctl.h> 10 #include <linux/seqlock.h> 11 #include <linux/init.h> 12 #include <linux/slab.h> 13 #include <net/icmp.h> 14 #include <net/ip.h> 15 #include <net/ip_fib.h> 16 #include <net/tcp.h> 17 #include <net/udp.h> 18 #include <net/cipso_ipv4.h> 19 #include <net/ping.h> 20 #include <net/protocol.h> 21 #include <net/netevent.h> 22 23 static int tcp_retr1_max = 255; 24 static int ip_local_port_range_min[] = { 1, 1 }; 25 static int ip_local_port_range_max[] = { 65535, 65535 }; 26 static int tcp_adv_win_scale_min = -31; 27 static int tcp_adv_win_scale_max = 31; 28 static int tcp_min_snd_mss_min = TCP_MIN_SND_MSS; 29 static int tcp_min_snd_mss_max = 65535; 30 static int ip_privileged_port_min; 31 static int ip_privileged_port_max = 65535; 32 static int ip_ttl_min = 1; 33 static int ip_ttl_max = 255; 34 static int tcp_syn_retries_min = 1; 35 static int tcp_syn_retries_max = MAX_TCP_SYNCNT; 36 static int ip_ping_group_range_min[] = { 0, 0 }; 37 static int ip_ping_group_range_max[] = { GID_T_MAX, GID_T_MAX }; 38 static u32 u32_max_div_HZ = UINT_MAX / HZ; 39 static int one_day_secs = 24 * 3600; 40 static u32 fib_multipath_hash_fields_all_mask __maybe_unused = 41 FIB_MULTIPATH_HASH_FIELD_ALL_MASK; 42 static unsigned int tcp_child_ehash_entries_max = 16 * 1024 * 1024; 43 static unsigned int udp_child_hash_entries_max = UDP_HTABLE_SIZE_MAX; 44 static int tcp_plb_max_rounds = 31; 45 static int tcp_plb_max_cong_thresh = 256; 46 47 /* obsolete */ 48 static int sysctl_tcp_low_latency __read_mostly; 49 50 /* Update system visible IP port range */ 51 static void set_local_port_range(struct net *net, int range[2]) 52 { 53 bool same_parity = !((range[0] ^ range[1]) & 1); 54 55 write_seqlock_bh(&net->ipv4.ip_local_ports.lock); 56 if (same_parity && !net->ipv4.ip_local_ports.warned) { 57 net->ipv4.ip_local_ports.warned = true; 58 pr_err_ratelimited("ip_local_port_range: prefer different parity for start/end values.\n"); 59 } 60 net->ipv4.ip_local_ports.range[0] = range[0]; 61 net->ipv4.ip_local_ports.range[1] = range[1]; 62 write_sequnlock_bh(&net->ipv4.ip_local_ports.lock); 63 } 64 65 /* Validate changes from /proc interface. */ 66 static int ipv4_local_port_range(struct ctl_table *table, int write, 67 void *buffer, size_t *lenp, loff_t *ppos) 68 { 69 struct net *net = 70 container_of(table->data, struct net, ipv4.ip_local_ports.range); 71 int ret; 72 int range[2]; 73 struct ctl_table tmp = { 74 .data = &range, 75 .maxlen = sizeof(range), 76 .mode = table->mode, 77 .extra1 = &ip_local_port_range_min, 78 .extra2 = &ip_local_port_range_max, 79 }; 80 81 inet_get_local_port_range(net, &range[0], &range[1]); 82 83 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 84 85 if (write && ret == 0) { 86 /* Ensure that the upper limit is not smaller than the lower, 87 * and that the lower does not encroach upon the privileged 88 * port limit. 89 */ 90 if ((range[1] < range[0]) || 91 (range[0] < READ_ONCE(net->ipv4.sysctl_ip_prot_sock))) 92 ret = -EINVAL; 93 else 94 set_local_port_range(net, range); 95 } 96 97 return ret; 98 } 99 100 /* Validate changes from /proc interface. */ 101 static int ipv4_privileged_ports(struct ctl_table *table, int write, 102 void *buffer, size_t *lenp, loff_t *ppos) 103 { 104 struct net *net = container_of(table->data, struct net, 105 ipv4.sysctl_ip_prot_sock); 106 int ret; 107 int pports; 108 int range[2]; 109 struct ctl_table tmp = { 110 .data = &pports, 111 .maxlen = sizeof(pports), 112 .mode = table->mode, 113 .extra1 = &ip_privileged_port_min, 114 .extra2 = &ip_privileged_port_max, 115 }; 116 117 pports = READ_ONCE(net->ipv4.sysctl_ip_prot_sock); 118 119 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 120 121 if (write && ret == 0) { 122 inet_get_local_port_range(net, &range[0], &range[1]); 123 /* Ensure that the local port range doesn't overlap with the 124 * privileged port range. 125 */ 126 if (range[0] < pports) 127 ret = -EINVAL; 128 else 129 WRITE_ONCE(net->ipv4.sysctl_ip_prot_sock, pports); 130 } 131 132 return ret; 133 } 134 135 static void inet_get_ping_group_range_table(struct ctl_table *table, kgid_t *low, kgid_t *high) 136 { 137 kgid_t *data = table->data; 138 struct net *net = 139 container_of(table->data, struct net, ipv4.ping_group_range.range); 140 unsigned int seq; 141 do { 142 seq = read_seqbegin(&net->ipv4.ping_group_range.lock); 143 144 *low = data[0]; 145 *high = data[1]; 146 } while (read_seqretry(&net->ipv4.ping_group_range.lock, seq)); 147 } 148 149 /* Update system visible IP port range */ 150 static void set_ping_group_range(struct ctl_table *table, kgid_t low, kgid_t high) 151 { 152 kgid_t *data = table->data; 153 struct net *net = 154 container_of(table->data, struct net, ipv4.ping_group_range.range); 155 write_seqlock(&net->ipv4.ping_group_range.lock); 156 data[0] = low; 157 data[1] = high; 158 write_sequnlock(&net->ipv4.ping_group_range.lock); 159 } 160 161 /* Validate changes from /proc interface. */ 162 static int ipv4_ping_group_range(struct ctl_table *table, int write, 163 void *buffer, size_t *lenp, loff_t *ppos) 164 { 165 struct user_namespace *user_ns = current_user_ns(); 166 int ret; 167 gid_t urange[2]; 168 kgid_t low, high; 169 struct ctl_table tmp = { 170 .data = &urange, 171 .maxlen = sizeof(urange), 172 .mode = table->mode, 173 .extra1 = &ip_ping_group_range_min, 174 .extra2 = &ip_ping_group_range_max, 175 }; 176 177 inet_get_ping_group_range_table(table, &low, &high); 178 urange[0] = from_kgid_munged(user_ns, low); 179 urange[1] = from_kgid_munged(user_ns, high); 180 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 181 182 if (write && ret == 0) { 183 low = make_kgid(user_ns, urange[0]); 184 high = make_kgid(user_ns, urange[1]); 185 if (!gid_valid(low) || !gid_valid(high)) 186 return -EINVAL; 187 if (urange[1] < urange[0] || gid_lt(high, low)) { 188 low = make_kgid(&init_user_ns, 1); 189 high = make_kgid(&init_user_ns, 0); 190 } 191 set_ping_group_range(table, low, high); 192 } 193 194 return ret; 195 } 196 197 static int ipv4_fwd_update_priority(struct ctl_table *table, int write, 198 void *buffer, size_t *lenp, loff_t *ppos) 199 { 200 struct net *net; 201 int ret; 202 203 net = container_of(table->data, struct net, 204 ipv4.sysctl_ip_fwd_update_priority); 205 ret = proc_dou8vec_minmax(table, write, buffer, lenp, ppos); 206 if (write && ret == 0) 207 call_netevent_notifiers(NETEVENT_IPV4_FWD_UPDATE_PRIORITY_UPDATE, 208 net); 209 210 return ret; 211 } 212 213 static int proc_tcp_congestion_control(struct ctl_table *ctl, int write, 214 void *buffer, size_t *lenp, loff_t *ppos) 215 { 216 struct net *net = container_of(ctl->data, struct net, 217 ipv4.tcp_congestion_control); 218 char val[TCP_CA_NAME_MAX]; 219 struct ctl_table tbl = { 220 .data = val, 221 .maxlen = TCP_CA_NAME_MAX, 222 }; 223 int ret; 224 225 tcp_get_default_congestion_control(net, val); 226 227 ret = proc_dostring(&tbl, write, buffer, lenp, ppos); 228 if (write && ret == 0) 229 ret = tcp_set_default_congestion_control(net, val); 230 return ret; 231 } 232 233 static int proc_tcp_available_congestion_control(struct ctl_table *ctl, 234 int write, void *buffer, 235 size_t *lenp, loff_t *ppos) 236 { 237 struct ctl_table tbl = { .maxlen = TCP_CA_BUF_MAX, }; 238 int ret; 239 240 tbl.data = kmalloc(tbl.maxlen, GFP_USER); 241 if (!tbl.data) 242 return -ENOMEM; 243 tcp_get_available_congestion_control(tbl.data, TCP_CA_BUF_MAX); 244 ret = proc_dostring(&tbl, write, buffer, lenp, ppos); 245 kfree(tbl.data); 246 return ret; 247 } 248 249 static int proc_allowed_congestion_control(struct ctl_table *ctl, 250 int write, void *buffer, 251 size_t *lenp, loff_t *ppos) 252 { 253 struct ctl_table tbl = { .maxlen = TCP_CA_BUF_MAX }; 254 int ret; 255 256 tbl.data = kmalloc(tbl.maxlen, GFP_USER); 257 if (!tbl.data) 258 return -ENOMEM; 259 260 tcp_get_allowed_congestion_control(tbl.data, tbl.maxlen); 261 ret = proc_dostring(&tbl, write, buffer, lenp, ppos); 262 if (write && ret == 0) 263 ret = tcp_set_allowed_congestion_control(tbl.data); 264 kfree(tbl.data); 265 return ret; 266 } 267 268 static int sscanf_key(char *buf, __le32 *key) 269 { 270 u32 user_key[4]; 271 int i, ret = 0; 272 273 if (sscanf(buf, "%x-%x-%x-%x", user_key, user_key + 1, 274 user_key + 2, user_key + 3) != 4) { 275 ret = -EINVAL; 276 } else { 277 for (i = 0; i < ARRAY_SIZE(user_key); i++) 278 key[i] = cpu_to_le32(user_key[i]); 279 } 280 pr_debug("proc TFO key set 0x%x-%x-%x-%x <- 0x%s: %u\n", 281 user_key[0], user_key[1], user_key[2], user_key[3], buf, ret); 282 283 return ret; 284 } 285 286 static int proc_tcp_fastopen_key(struct ctl_table *table, int write, 287 void *buffer, size_t *lenp, loff_t *ppos) 288 { 289 struct net *net = container_of(table->data, struct net, 290 ipv4.sysctl_tcp_fastopen); 291 /* maxlen to print the list of keys in hex (*2), with dashes 292 * separating doublewords and a comma in between keys. 293 */ 294 struct ctl_table tbl = { .maxlen = ((TCP_FASTOPEN_KEY_LENGTH * 295 2 * TCP_FASTOPEN_KEY_MAX) + 296 (TCP_FASTOPEN_KEY_MAX * 5)) }; 297 u32 user_key[TCP_FASTOPEN_KEY_BUF_LENGTH / sizeof(u32)]; 298 __le32 key[TCP_FASTOPEN_KEY_BUF_LENGTH / sizeof(__le32)]; 299 char *backup_data; 300 int ret, i = 0, off = 0, n_keys; 301 302 tbl.data = kmalloc(tbl.maxlen, GFP_KERNEL); 303 if (!tbl.data) 304 return -ENOMEM; 305 306 n_keys = tcp_fastopen_get_cipher(net, NULL, (u64 *)key); 307 if (!n_keys) { 308 memset(&key[0], 0, TCP_FASTOPEN_KEY_LENGTH); 309 n_keys = 1; 310 } 311 312 for (i = 0; i < n_keys * 4; i++) 313 user_key[i] = le32_to_cpu(key[i]); 314 315 for (i = 0; i < n_keys; i++) { 316 off += snprintf(tbl.data + off, tbl.maxlen - off, 317 "%08x-%08x-%08x-%08x", 318 user_key[i * 4], 319 user_key[i * 4 + 1], 320 user_key[i * 4 + 2], 321 user_key[i * 4 + 3]); 322 323 if (WARN_ON_ONCE(off >= tbl.maxlen - 1)) 324 break; 325 326 if (i + 1 < n_keys) 327 off += snprintf(tbl.data + off, tbl.maxlen - off, ","); 328 } 329 330 ret = proc_dostring(&tbl, write, buffer, lenp, ppos); 331 332 if (write && ret == 0) { 333 backup_data = strchr(tbl.data, ','); 334 if (backup_data) { 335 *backup_data = '\0'; 336 backup_data++; 337 } 338 if (sscanf_key(tbl.data, key)) { 339 ret = -EINVAL; 340 goto bad_key; 341 } 342 if (backup_data) { 343 if (sscanf_key(backup_data, key + 4)) { 344 ret = -EINVAL; 345 goto bad_key; 346 } 347 } 348 tcp_fastopen_reset_cipher(net, NULL, key, 349 backup_data ? key + 4 : NULL); 350 } 351 352 bad_key: 353 kfree(tbl.data); 354 return ret; 355 } 356 357 static int proc_tfo_blackhole_detect_timeout(struct ctl_table *table, 358 int write, void *buffer, 359 size_t *lenp, loff_t *ppos) 360 { 361 struct net *net = container_of(table->data, struct net, 362 ipv4.sysctl_tcp_fastopen_blackhole_timeout); 363 int ret; 364 365 ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 366 if (write && ret == 0) 367 atomic_set(&net->ipv4.tfo_active_disable_times, 0); 368 369 return ret; 370 } 371 372 static int proc_tcp_available_ulp(struct ctl_table *ctl, 373 int write, void *buffer, size_t *lenp, 374 loff_t *ppos) 375 { 376 struct ctl_table tbl = { .maxlen = TCP_ULP_BUF_MAX, }; 377 int ret; 378 379 tbl.data = kmalloc(tbl.maxlen, GFP_USER); 380 if (!tbl.data) 381 return -ENOMEM; 382 tcp_get_available_ulp(tbl.data, TCP_ULP_BUF_MAX); 383 ret = proc_dostring(&tbl, write, buffer, lenp, ppos); 384 kfree(tbl.data); 385 386 return ret; 387 } 388 389 static int proc_tcp_ehash_entries(struct ctl_table *table, int write, 390 void *buffer, size_t *lenp, loff_t *ppos) 391 { 392 struct net *net = container_of(table->data, struct net, 393 ipv4.sysctl_tcp_child_ehash_entries); 394 struct inet_hashinfo *hinfo = net->ipv4.tcp_death_row.hashinfo; 395 int tcp_ehash_entries; 396 struct ctl_table tbl; 397 398 tcp_ehash_entries = hinfo->ehash_mask + 1; 399 400 /* A negative number indicates that the child netns 401 * shares the global ehash. 402 */ 403 if (!net_eq(net, &init_net) && !hinfo->pernet) 404 tcp_ehash_entries *= -1; 405 406 memset(&tbl, 0, sizeof(tbl)); 407 tbl.data = &tcp_ehash_entries; 408 tbl.maxlen = sizeof(int); 409 410 return proc_dointvec(&tbl, write, buffer, lenp, ppos); 411 } 412 413 static int proc_udp_hash_entries(struct ctl_table *table, int write, 414 void *buffer, size_t *lenp, loff_t *ppos) 415 { 416 struct net *net = container_of(table->data, struct net, 417 ipv4.sysctl_udp_child_hash_entries); 418 int udp_hash_entries; 419 struct ctl_table tbl; 420 421 udp_hash_entries = net->ipv4.udp_table->mask + 1; 422 423 /* A negative number indicates that the child netns 424 * shares the global udp_table. 425 */ 426 if (!net_eq(net, &init_net) && net->ipv4.udp_table == &udp_table) 427 udp_hash_entries *= -1; 428 429 memset(&tbl, 0, sizeof(tbl)); 430 tbl.data = &udp_hash_entries; 431 tbl.maxlen = sizeof(int); 432 433 return proc_dointvec(&tbl, write, buffer, lenp, ppos); 434 } 435 436 #ifdef CONFIG_IP_ROUTE_MULTIPATH 437 static int proc_fib_multipath_hash_policy(struct ctl_table *table, int write, 438 void *buffer, size_t *lenp, 439 loff_t *ppos) 440 { 441 struct net *net = container_of(table->data, struct net, 442 ipv4.sysctl_fib_multipath_hash_policy); 443 int ret; 444 445 ret = proc_dou8vec_minmax(table, write, buffer, lenp, ppos); 446 if (write && ret == 0) 447 call_netevent_notifiers(NETEVENT_IPV4_MPATH_HASH_UPDATE, net); 448 449 return ret; 450 } 451 452 static int proc_fib_multipath_hash_fields(struct ctl_table *table, int write, 453 void *buffer, size_t *lenp, 454 loff_t *ppos) 455 { 456 struct net *net; 457 int ret; 458 459 net = container_of(table->data, struct net, 460 ipv4.sysctl_fib_multipath_hash_fields); 461 ret = proc_douintvec_minmax(table, write, buffer, lenp, ppos); 462 if (write && ret == 0) 463 call_netevent_notifiers(NETEVENT_IPV4_MPATH_HASH_UPDATE, net); 464 465 return ret; 466 } 467 #endif 468 469 static struct ctl_table ipv4_table[] = { 470 { 471 .procname = "tcp_max_orphans", 472 .data = &sysctl_tcp_max_orphans, 473 .maxlen = sizeof(int), 474 .mode = 0644, 475 .proc_handler = proc_dointvec 476 }, 477 { 478 .procname = "inet_peer_threshold", 479 .data = &inet_peer_threshold, 480 .maxlen = sizeof(int), 481 .mode = 0644, 482 .proc_handler = proc_dointvec 483 }, 484 { 485 .procname = "inet_peer_minttl", 486 .data = &inet_peer_minttl, 487 .maxlen = sizeof(int), 488 .mode = 0644, 489 .proc_handler = proc_dointvec_jiffies, 490 }, 491 { 492 .procname = "inet_peer_maxttl", 493 .data = &inet_peer_maxttl, 494 .maxlen = sizeof(int), 495 .mode = 0644, 496 .proc_handler = proc_dointvec_jiffies, 497 }, 498 { 499 .procname = "tcp_mem", 500 .maxlen = sizeof(sysctl_tcp_mem), 501 .data = &sysctl_tcp_mem, 502 .mode = 0644, 503 .proc_handler = proc_doulongvec_minmax, 504 }, 505 { 506 .procname = "tcp_low_latency", 507 .data = &sysctl_tcp_low_latency, 508 .maxlen = sizeof(int), 509 .mode = 0644, 510 .proc_handler = proc_dointvec 511 }, 512 #ifdef CONFIG_NETLABEL 513 { 514 .procname = "cipso_cache_enable", 515 .data = &cipso_v4_cache_enabled, 516 .maxlen = sizeof(int), 517 .mode = 0644, 518 .proc_handler = proc_dointvec, 519 }, 520 { 521 .procname = "cipso_cache_bucket_size", 522 .data = &cipso_v4_cache_bucketsize, 523 .maxlen = sizeof(int), 524 .mode = 0644, 525 .proc_handler = proc_dointvec, 526 }, 527 { 528 .procname = "cipso_rbm_optfmt", 529 .data = &cipso_v4_rbm_optfmt, 530 .maxlen = sizeof(int), 531 .mode = 0644, 532 .proc_handler = proc_dointvec, 533 }, 534 { 535 .procname = "cipso_rbm_strictvalid", 536 .data = &cipso_v4_rbm_strictvalid, 537 .maxlen = sizeof(int), 538 .mode = 0644, 539 .proc_handler = proc_dointvec, 540 }, 541 #endif /* CONFIG_NETLABEL */ 542 { 543 .procname = "tcp_available_ulp", 544 .maxlen = TCP_ULP_BUF_MAX, 545 .mode = 0444, 546 .proc_handler = proc_tcp_available_ulp, 547 }, 548 { 549 .procname = "icmp_msgs_per_sec", 550 .data = &sysctl_icmp_msgs_per_sec, 551 .maxlen = sizeof(int), 552 .mode = 0644, 553 .proc_handler = proc_dointvec_minmax, 554 .extra1 = SYSCTL_ZERO, 555 }, 556 { 557 .procname = "icmp_msgs_burst", 558 .data = &sysctl_icmp_msgs_burst, 559 .maxlen = sizeof(int), 560 .mode = 0644, 561 .proc_handler = proc_dointvec_minmax, 562 .extra1 = SYSCTL_ZERO, 563 }, 564 { 565 .procname = "udp_mem", 566 .data = &sysctl_udp_mem, 567 .maxlen = sizeof(sysctl_udp_mem), 568 .mode = 0644, 569 .proc_handler = proc_doulongvec_minmax, 570 }, 571 { 572 .procname = "fib_sync_mem", 573 .data = &sysctl_fib_sync_mem, 574 .maxlen = sizeof(sysctl_fib_sync_mem), 575 .mode = 0644, 576 .proc_handler = proc_douintvec_minmax, 577 .extra1 = &sysctl_fib_sync_mem_min, 578 .extra2 = &sysctl_fib_sync_mem_max, 579 }, 580 { } 581 }; 582 583 static struct ctl_table ipv4_net_table[] = { 584 { 585 .procname = "tcp_max_tw_buckets", 586 .data = &init_net.ipv4.tcp_death_row.sysctl_max_tw_buckets, 587 .maxlen = sizeof(int), 588 .mode = 0644, 589 .proc_handler = proc_dointvec 590 }, 591 { 592 .procname = "icmp_echo_ignore_all", 593 .data = &init_net.ipv4.sysctl_icmp_echo_ignore_all, 594 .maxlen = sizeof(u8), 595 .mode = 0644, 596 .proc_handler = proc_dou8vec_minmax, 597 .extra1 = SYSCTL_ZERO, 598 .extra2 = SYSCTL_ONE 599 }, 600 { 601 .procname = "icmp_echo_enable_probe", 602 .data = &init_net.ipv4.sysctl_icmp_echo_enable_probe, 603 .maxlen = sizeof(u8), 604 .mode = 0644, 605 .proc_handler = proc_dou8vec_minmax, 606 .extra1 = SYSCTL_ZERO, 607 .extra2 = SYSCTL_ONE 608 }, 609 { 610 .procname = "icmp_echo_ignore_broadcasts", 611 .data = &init_net.ipv4.sysctl_icmp_echo_ignore_broadcasts, 612 .maxlen = sizeof(u8), 613 .mode = 0644, 614 .proc_handler = proc_dou8vec_minmax, 615 .extra1 = SYSCTL_ZERO, 616 .extra2 = SYSCTL_ONE 617 }, 618 { 619 .procname = "icmp_ignore_bogus_error_responses", 620 .data = &init_net.ipv4.sysctl_icmp_ignore_bogus_error_responses, 621 .maxlen = sizeof(u8), 622 .mode = 0644, 623 .proc_handler = proc_dou8vec_minmax, 624 .extra1 = SYSCTL_ZERO, 625 .extra2 = SYSCTL_ONE 626 }, 627 { 628 .procname = "icmp_errors_use_inbound_ifaddr", 629 .data = &init_net.ipv4.sysctl_icmp_errors_use_inbound_ifaddr, 630 .maxlen = sizeof(u8), 631 .mode = 0644, 632 .proc_handler = proc_dou8vec_minmax, 633 .extra1 = SYSCTL_ZERO, 634 .extra2 = SYSCTL_ONE 635 }, 636 { 637 .procname = "icmp_ratelimit", 638 .data = &init_net.ipv4.sysctl_icmp_ratelimit, 639 .maxlen = sizeof(int), 640 .mode = 0644, 641 .proc_handler = proc_dointvec_ms_jiffies, 642 }, 643 { 644 .procname = "icmp_ratemask", 645 .data = &init_net.ipv4.sysctl_icmp_ratemask, 646 .maxlen = sizeof(int), 647 .mode = 0644, 648 .proc_handler = proc_dointvec 649 }, 650 { 651 .procname = "ping_group_range", 652 .data = &init_net.ipv4.ping_group_range.range, 653 .maxlen = sizeof(gid_t)*2, 654 .mode = 0644, 655 .proc_handler = ipv4_ping_group_range, 656 }, 657 #ifdef CONFIG_NET_L3_MASTER_DEV 658 { 659 .procname = "raw_l3mdev_accept", 660 .data = &init_net.ipv4.sysctl_raw_l3mdev_accept, 661 .maxlen = sizeof(u8), 662 .mode = 0644, 663 .proc_handler = proc_dou8vec_minmax, 664 .extra1 = SYSCTL_ZERO, 665 .extra2 = SYSCTL_ONE, 666 }, 667 #endif 668 { 669 .procname = "tcp_ecn", 670 .data = &init_net.ipv4.sysctl_tcp_ecn, 671 .maxlen = sizeof(u8), 672 .mode = 0644, 673 .proc_handler = proc_dou8vec_minmax, 674 .extra1 = SYSCTL_ZERO, 675 .extra2 = SYSCTL_TWO, 676 }, 677 { 678 .procname = "tcp_ecn_fallback", 679 .data = &init_net.ipv4.sysctl_tcp_ecn_fallback, 680 .maxlen = sizeof(u8), 681 .mode = 0644, 682 .proc_handler = proc_dou8vec_minmax, 683 .extra1 = SYSCTL_ZERO, 684 .extra2 = SYSCTL_ONE, 685 }, 686 { 687 .procname = "ip_dynaddr", 688 .data = &init_net.ipv4.sysctl_ip_dynaddr, 689 .maxlen = sizeof(u8), 690 .mode = 0644, 691 .proc_handler = proc_dou8vec_minmax, 692 }, 693 { 694 .procname = "ip_early_demux", 695 .data = &init_net.ipv4.sysctl_ip_early_demux, 696 .maxlen = sizeof(u8), 697 .mode = 0644, 698 .proc_handler = proc_dou8vec_minmax, 699 }, 700 { 701 .procname = "udp_early_demux", 702 .data = &init_net.ipv4.sysctl_udp_early_demux, 703 .maxlen = sizeof(u8), 704 .mode = 0644, 705 .proc_handler = proc_dou8vec_minmax, 706 }, 707 { 708 .procname = "tcp_early_demux", 709 .data = &init_net.ipv4.sysctl_tcp_early_demux, 710 .maxlen = sizeof(u8), 711 .mode = 0644, 712 .proc_handler = proc_dou8vec_minmax, 713 }, 714 { 715 .procname = "nexthop_compat_mode", 716 .data = &init_net.ipv4.sysctl_nexthop_compat_mode, 717 .maxlen = sizeof(u8), 718 .mode = 0644, 719 .proc_handler = proc_dou8vec_minmax, 720 .extra1 = SYSCTL_ZERO, 721 .extra2 = SYSCTL_ONE, 722 }, 723 { 724 .procname = "ip_default_ttl", 725 .data = &init_net.ipv4.sysctl_ip_default_ttl, 726 .maxlen = sizeof(u8), 727 .mode = 0644, 728 .proc_handler = proc_dou8vec_minmax, 729 .extra1 = &ip_ttl_min, 730 .extra2 = &ip_ttl_max, 731 }, 732 { 733 .procname = "ip_local_port_range", 734 .maxlen = sizeof(init_net.ipv4.ip_local_ports.range), 735 .data = &init_net.ipv4.ip_local_ports.range, 736 .mode = 0644, 737 .proc_handler = ipv4_local_port_range, 738 }, 739 { 740 .procname = "ip_local_reserved_ports", 741 .data = &init_net.ipv4.sysctl_local_reserved_ports, 742 .maxlen = 65536, 743 .mode = 0644, 744 .proc_handler = proc_do_large_bitmap, 745 }, 746 { 747 .procname = "ip_no_pmtu_disc", 748 .data = &init_net.ipv4.sysctl_ip_no_pmtu_disc, 749 .maxlen = sizeof(u8), 750 .mode = 0644, 751 .proc_handler = proc_dou8vec_minmax, 752 }, 753 { 754 .procname = "ip_forward_use_pmtu", 755 .data = &init_net.ipv4.sysctl_ip_fwd_use_pmtu, 756 .maxlen = sizeof(u8), 757 .mode = 0644, 758 .proc_handler = proc_dou8vec_minmax, 759 }, 760 { 761 .procname = "ip_forward_update_priority", 762 .data = &init_net.ipv4.sysctl_ip_fwd_update_priority, 763 .maxlen = sizeof(u8), 764 .mode = 0644, 765 .proc_handler = ipv4_fwd_update_priority, 766 .extra1 = SYSCTL_ZERO, 767 .extra2 = SYSCTL_ONE, 768 }, 769 { 770 .procname = "ip_nonlocal_bind", 771 .data = &init_net.ipv4.sysctl_ip_nonlocal_bind, 772 .maxlen = sizeof(u8), 773 .mode = 0644, 774 .proc_handler = proc_dou8vec_minmax, 775 }, 776 { 777 .procname = "ip_autobind_reuse", 778 .data = &init_net.ipv4.sysctl_ip_autobind_reuse, 779 .maxlen = sizeof(u8), 780 .mode = 0644, 781 .proc_handler = proc_dou8vec_minmax, 782 .extra1 = SYSCTL_ZERO, 783 .extra2 = SYSCTL_ONE, 784 }, 785 { 786 .procname = "fwmark_reflect", 787 .data = &init_net.ipv4.sysctl_fwmark_reflect, 788 .maxlen = sizeof(u8), 789 .mode = 0644, 790 .proc_handler = proc_dou8vec_minmax, 791 }, 792 { 793 .procname = "tcp_fwmark_accept", 794 .data = &init_net.ipv4.sysctl_tcp_fwmark_accept, 795 .maxlen = sizeof(u8), 796 .mode = 0644, 797 .proc_handler = proc_dou8vec_minmax, 798 }, 799 #ifdef CONFIG_NET_L3_MASTER_DEV 800 { 801 .procname = "tcp_l3mdev_accept", 802 .data = &init_net.ipv4.sysctl_tcp_l3mdev_accept, 803 .maxlen = sizeof(u8), 804 .mode = 0644, 805 .proc_handler = proc_dou8vec_minmax, 806 .extra1 = SYSCTL_ZERO, 807 .extra2 = SYSCTL_ONE, 808 }, 809 #endif 810 { 811 .procname = "tcp_mtu_probing", 812 .data = &init_net.ipv4.sysctl_tcp_mtu_probing, 813 .maxlen = sizeof(u8), 814 .mode = 0644, 815 .proc_handler = proc_dou8vec_minmax, 816 }, 817 { 818 .procname = "tcp_base_mss", 819 .data = &init_net.ipv4.sysctl_tcp_base_mss, 820 .maxlen = sizeof(int), 821 .mode = 0644, 822 .proc_handler = proc_dointvec, 823 }, 824 { 825 .procname = "tcp_min_snd_mss", 826 .data = &init_net.ipv4.sysctl_tcp_min_snd_mss, 827 .maxlen = sizeof(int), 828 .mode = 0644, 829 .proc_handler = proc_dointvec_minmax, 830 .extra1 = &tcp_min_snd_mss_min, 831 .extra2 = &tcp_min_snd_mss_max, 832 }, 833 { 834 .procname = "tcp_mtu_probe_floor", 835 .data = &init_net.ipv4.sysctl_tcp_mtu_probe_floor, 836 .maxlen = sizeof(int), 837 .mode = 0644, 838 .proc_handler = proc_dointvec_minmax, 839 .extra1 = &tcp_min_snd_mss_min, 840 .extra2 = &tcp_min_snd_mss_max, 841 }, 842 { 843 .procname = "tcp_probe_threshold", 844 .data = &init_net.ipv4.sysctl_tcp_probe_threshold, 845 .maxlen = sizeof(int), 846 .mode = 0644, 847 .proc_handler = proc_dointvec, 848 }, 849 { 850 .procname = "tcp_probe_interval", 851 .data = &init_net.ipv4.sysctl_tcp_probe_interval, 852 .maxlen = sizeof(u32), 853 .mode = 0644, 854 .proc_handler = proc_douintvec_minmax, 855 .extra2 = &u32_max_div_HZ, 856 }, 857 { 858 .procname = "igmp_link_local_mcast_reports", 859 .data = &init_net.ipv4.sysctl_igmp_llm_reports, 860 .maxlen = sizeof(u8), 861 .mode = 0644, 862 .proc_handler = proc_dou8vec_minmax, 863 }, 864 { 865 .procname = "igmp_max_memberships", 866 .data = &init_net.ipv4.sysctl_igmp_max_memberships, 867 .maxlen = sizeof(int), 868 .mode = 0644, 869 .proc_handler = proc_dointvec 870 }, 871 { 872 .procname = "igmp_max_msf", 873 .data = &init_net.ipv4.sysctl_igmp_max_msf, 874 .maxlen = sizeof(int), 875 .mode = 0644, 876 .proc_handler = proc_dointvec 877 }, 878 #ifdef CONFIG_IP_MULTICAST 879 { 880 .procname = "igmp_qrv", 881 .data = &init_net.ipv4.sysctl_igmp_qrv, 882 .maxlen = sizeof(int), 883 .mode = 0644, 884 .proc_handler = proc_dointvec_minmax, 885 .extra1 = SYSCTL_ONE 886 }, 887 #endif 888 { 889 .procname = "tcp_congestion_control", 890 .data = &init_net.ipv4.tcp_congestion_control, 891 .mode = 0644, 892 .maxlen = TCP_CA_NAME_MAX, 893 .proc_handler = proc_tcp_congestion_control, 894 }, 895 { 896 .procname = "tcp_available_congestion_control", 897 .maxlen = TCP_CA_BUF_MAX, 898 .mode = 0444, 899 .proc_handler = proc_tcp_available_congestion_control, 900 }, 901 { 902 .procname = "tcp_allowed_congestion_control", 903 .maxlen = TCP_CA_BUF_MAX, 904 .mode = 0644, 905 .proc_handler = proc_allowed_congestion_control, 906 }, 907 { 908 .procname = "tcp_keepalive_time", 909 .data = &init_net.ipv4.sysctl_tcp_keepalive_time, 910 .maxlen = sizeof(int), 911 .mode = 0644, 912 .proc_handler = proc_dointvec_jiffies, 913 }, 914 { 915 .procname = "tcp_keepalive_probes", 916 .data = &init_net.ipv4.sysctl_tcp_keepalive_probes, 917 .maxlen = sizeof(u8), 918 .mode = 0644, 919 .proc_handler = proc_dou8vec_minmax, 920 }, 921 { 922 .procname = "tcp_keepalive_intvl", 923 .data = &init_net.ipv4.sysctl_tcp_keepalive_intvl, 924 .maxlen = sizeof(int), 925 .mode = 0644, 926 .proc_handler = proc_dointvec_jiffies, 927 }, 928 { 929 .procname = "tcp_syn_retries", 930 .data = &init_net.ipv4.sysctl_tcp_syn_retries, 931 .maxlen = sizeof(u8), 932 .mode = 0644, 933 .proc_handler = proc_dou8vec_minmax, 934 .extra1 = &tcp_syn_retries_min, 935 .extra2 = &tcp_syn_retries_max 936 }, 937 { 938 .procname = "tcp_synack_retries", 939 .data = &init_net.ipv4.sysctl_tcp_synack_retries, 940 .maxlen = sizeof(u8), 941 .mode = 0644, 942 .proc_handler = proc_dou8vec_minmax, 943 }, 944 #ifdef CONFIG_SYN_COOKIES 945 { 946 .procname = "tcp_syncookies", 947 .data = &init_net.ipv4.sysctl_tcp_syncookies, 948 .maxlen = sizeof(u8), 949 .mode = 0644, 950 .proc_handler = proc_dou8vec_minmax, 951 }, 952 #endif 953 { 954 .procname = "tcp_migrate_req", 955 .data = &init_net.ipv4.sysctl_tcp_migrate_req, 956 .maxlen = sizeof(u8), 957 .mode = 0644, 958 .proc_handler = proc_dou8vec_minmax, 959 .extra1 = SYSCTL_ZERO, 960 .extra2 = SYSCTL_ONE 961 }, 962 { 963 .procname = "tcp_reordering", 964 .data = &init_net.ipv4.sysctl_tcp_reordering, 965 .maxlen = sizeof(int), 966 .mode = 0644, 967 .proc_handler = proc_dointvec 968 }, 969 { 970 .procname = "tcp_retries1", 971 .data = &init_net.ipv4.sysctl_tcp_retries1, 972 .maxlen = sizeof(u8), 973 .mode = 0644, 974 .proc_handler = proc_dou8vec_minmax, 975 .extra2 = &tcp_retr1_max 976 }, 977 { 978 .procname = "tcp_retries2", 979 .data = &init_net.ipv4.sysctl_tcp_retries2, 980 .maxlen = sizeof(u8), 981 .mode = 0644, 982 .proc_handler = proc_dou8vec_minmax, 983 }, 984 { 985 .procname = "tcp_orphan_retries", 986 .data = &init_net.ipv4.sysctl_tcp_orphan_retries, 987 .maxlen = sizeof(u8), 988 .mode = 0644, 989 .proc_handler = proc_dou8vec_minmax, 990 }, 991 { 992 .procname = "tcp_fin_timeout", 993 .data = &init_net.ipv4.sysctl_tcp_fin_timeout, 994 .maxlen = sizeof(int), 995 .mode = 0644, 996 .proc_handler = proc_dointvec_jiffies, 997 }, 998 { 999 .procname = "tcp_notsent_lowat", 1000 .data = &init_net.ipv4.sysctl_tcp_notsent_lowat, 1001 .maxlen = sizeof(unsigned int), 1002 .mode = 0644, 1003 .proc_handler = proc_douintvec, 1004 }, 1005 { 1006 .procname = "tcp_tw_reuse", 1007 .data = &init_net.ipv4.sysctl_tcp_tw_reuse, 1008 .maxlen = sizeof(u8), 1009 .mode = 0644, 1010 .proc_handler = proc_dou8vec_minmax, 1011 .extra1 = SYSCTL_ZERO, 1012 .extra2 = SYSCTL_TWO, 1013 }, 1014 { 1015 .procname = "tcp_max_syn_backlog", 1016 .data = &init_net.ipv4.sysctl_max_syn_backlog, 1017 .maxlen = sizeof(int), 1018 .mode = 0644, 1019 .proc_handler = proc_dointvec 1020 }, 1021 { 1022 .procname = "tcp_fastopen", 1023 .data = &init_net.ipv4.sysctl_tcp_fastopen, 1024 .maxlen = sizeof(int), 1025 .mode = 0644, 1026 .proc_handler = proc_dointvec, 1027 }, 1028 { 1029 .procname = "tcp_fastopen_key", 1030 .mode = 0600, 1031 .data = &init_net.ipv4.sysctl_tcp_fastopen, 1032 /* maxlen to print the list of keys in hex (*2), with dashes 1033 * separating doublewords and a comma in between keys. 1034 */ 1035 .maxlen = ((TCP_FASTOPEN_KEY_LENGTH * 1036 2 * TCP_FASTOPEN_KEY_MAX) + 1037 (TCP_FASTOPEN_KEY_MAX * 5)), 1038 .proc_handler = proc_tcp_fastopen_key, 1039 }, 1040 { 1041 .procname = "tcp_fastopen_blackhole_timeout_sec", 1042 .data = &init_net.ipv4.sysctl_tcp_fastopen_blackhole_timeout, 1043 .maxlen = sizeof(int), 1044 .mode = 0644, 1045 .proc_handler = proc_tfo_blackhole_detect_timeout, 1046 .extra1 = SYSCTL_ZERO, 1047 }, 1048 #ifdef CONFIG_IP_ROUTE_MULTIPATH 1049 { 1050 .procname = "fib_multipath_use_neigh", 1051 .data = &init_net.ipv4.sysctl_fib_multipath_use_neigh, 1052 .maxlen = sizeof(u8), 1053 .mode = 0644, 1054 .proc_handler = proc_dou8vec_minmax, 1055 .extra1 = SYSCTL_ZERO, 1056 .extra2 = SYSCTL_ONE, 1057 }, 1058 { 1059 .procname = "fib_multipath_hash_policy", 1060 .data = &init_net.ipv4.sysctl_fib_multipath_hash_policy, 1061 .maxlen = sizeof(u8), 1062 .mode = 0644, 1063 .proc_handler = proc_fib_multipath_hash_policy, 1064 .extra1 = SYSCTL_ZERO, 1065 .extra2 = SYSCTL_THREE, 1066 }, 1067 { 1068 .procname = "fib_multipath_hash_fields", 1069 .data = &init_net.ipv4.sysctl_fib_multipath_hash_fields, 1070 .maxlen = sizeof(u32), 1071 .mode = 0644, 1072 .proc_handler = proc_fib_multipath_hash_fields, 1073 .extra1 = SYSCTL_ONE, 1074 .extra2 = &fib_multipath_hash_fields_all_mask, 1075 }, 1076 #endif 1077 { 1078 .procname = "ip_unprivileged_port_start", 1079 .maxlen = sizeof(int), 1080 .data = &init_net.ipv4.sysctl_ip_prot_sock, 1081 .mode = 0644, 1082 .proc_handler = ipv4_privileged_ports, 1083 }, 1084 #ifdef CONFIG_NET_L3_MASTER_DEV 1085 { 1086 .procname = "udp_l3mdev_accept", 1087 .data = &init_net.ipv4.sysctl_udp_l3mdev_accept, 1088 .maxlen = sizeof(u8), 1089 .mode = 0644, 1090 .proc_handler = proc_dou8vec_minmax, 1091 .extra1 = SYSCTL_ZERO, 1092 .extra2 = SYSCTL_ONE, 1093 }, 1094 #endif 1095 { 1096 .procname = "tcp_sack", 1097 .data = &init_net.ipv4.sysctl_tcp_sack, 1098 .maxlen = sizeof(u8), 1099 .mode = 0644, 1100 .proc_handler = proc_dou8vec_minmax, 1101 }, 1102 { 1103 .procname = "tcp_window_scaling", 1104 .data = &init_net.ipv4.sysctl_tcp_window_scaling, 1105 .maxlen = sizeof(u8), 1106 .mode = 0644, 1107 .proc_handler = proc_dou8vec_minmax, 1108 }, 1109 { 1110 .procname = "tcp_timestamps", 1111 .data = &init_net.ipv4.sysctl_tcp_timestamps, 1112 .maxlen = sizeof(u8), 1113 .mode = 0644, 1114 .proc_handler = proc_dou8vec_minmax, 1115 }, 1116 { 1117 .procname = "tcp_early_retrans", 1118 .data = &init_net.ipv4.sysctl_tcp_early_retrans, 1119 .maxlen = sizeof(u8), 1120 .mode = 0644, 1121 .proc_handler = proc_dou8vec_minmax, 1122 .extra1 = SYSCTL_ZERO, 1123 .extra2 = SYSCTL_FOUR, 1124 }, 1125 { 1126 .procname = "tcp_recovery", 1127 .data = &init_net.ipv4.sysctl_tcp_recovery, 1128 .maxlen = sizeof(u8), 1129 .mode = 0644, 1130 .proc_handler = proc_dou8vec_minmax, 1131 }, 1132 { 1133 .procname = "tcp_thin_linear_timeouts", 1134 .data = &init_net.ipv4.sysctl_tcp_thin_linear_timeouts, 1135 .maxlen = sizeof(u8), 1136 .mode = 0644, 1137 .proc_handler = proc_dou8vec_minmax, 1138 }, 1139 { 1140 .procname = "tcp_slow_start_after_idle", 1141 .data = &init_net.ipv4.sysctl_tcp_slow_start_after_idle, 1142 .maxlen = sizeof(u8), 1143 .mode = 0644, 1144 .proc_handler = proc_dou8vec_minmax, 1145 }, 1146 { 1147 .procname = "tcp_retrans_collapse", 1148 .data = &init_net.ipv4.sysctl_tcp_retrans_collapse, 1149 .maxlen = sizeof(u8), 1150 .mode = 0644, 1151 .proc_handler = proc_dou8vec_minmax, 1152 }, 1153 { 1154 .procname = "tcp_stdurg", 1155 .data = &init_net.ipv4.sysctl_tcp_stdurg, 1156 .maxlen = sizeof(u8), 1157 .mode = 0644, 1158 .proc_handler = proc_dou8vec_minmax, 1159 }, 1160 { 1161 .procname = "tcp_rfc1337", 1162 .data = &init_net.ipv4.sysctl_tcp_rfc1337, 1163 .maxlen = sizeof(u8), 1164 .mode = 0644, 1165 .proc_handler = proc_dou8vec_minmax, 1166 }, 1167 { 1168 .procname = "tcp_abort_on_overflow", 1169 .data = &init_net.ipv4.sysctl_tcp_abort_on_overflow, 1170 .maxlen = sizeof(u8), 1171 .mode = 0644, 1172 .proc_handler = proc_dou8vec_minmax, 1173 }, 1174 { 1175 .procname = "tcp_fack", 1176 .data = &init_net.ipv4.sysctl_tcp_fack, 1177 .maxlen = sizeof(u8), 1178 .mode = 0644, 1179 .proc_handler = proc_dou8vec_minmax, 1180 }, 1181 { 1182 .procname = "tcp_max_reordering", 1183 .data = &init_net.ipv4.sysctl_tcp_max_reordering, 1184 .maxlen = sizeof(int), 1185 .mode = 0644, 1186 .proc_handler = proc_dointvec 1187 }, 1188 { 1189 .procname = "tcp_dsack", 1190 .data = &init_net.ipv4.sysctl_tcp_dsack, 1191 .maxlen = sizeof(u8), 1192 .mode = 0644, 1193 .proc_handler = proc_dou8vec_minmax, 1194 }, 1195 { 1196 .procname = "tcp_app_win", 1197 .data = &init_net.ipv4.sysctl_tcp_app_win, 1198 .maxlen = sizeof(u8), 1199 .mode = 0644, 1200 .proc_handler = proc_dou8vec_minmax, 1201 }, 1202 { 1203 .procname = "tcp_adv_win_scale", 1204 .data = &init_net.ipv4.sysctl_tcp_adv_win_scale, 1205 .maxlen = sizeof(int), 1206 .mode = 0644, 1207 .proc_handler = proc_dointvec_minmax, 1208 .extra1 = &tcp_adv_win_scale_min, 1209 .extra2 = &tcp_adv_win_scale_max, 1210 }, 1211 { 1212 .procname = "tcp_frto", 1213 .data = &init_net.ipv4.sysctl_tcp_frto, 1214 .maxlen = sizeof(u8), 1215 .mode = 0644, 1216 .proc_handler = proc_dou8vec_minmax, 1217 }, 1218 { 1219 .procname = "tcp_no_metrics_save", 1220 .data = &init_net.ipv4.sysctl_tcp_nometrics_save, 1221 .maxlen = sizeof(u8), 1222 .mode = 0644, 1223 .proc_handler = proc_dou8vec_minmax, 1224 }, 1225 { 1226 .procname = "tcp_no_ssthresh_metrics_save", 1227 .data = &init_net.ipv4.sysctl_tcp_no_ssthresh_metrics_save, 1228 .maxlen = sizeof(u8), 1229 .mode = 0644, 1230 .proc_handler = proc_dou8vec_minmax, 1231 .extra1 = SYSCTL_ZERO, 1232 .extra2 = SYSCTL_ONE, 1233 }, 1234 { 1235 .procname = "tcp_moderate_rcvbuf", 1236 .data = &init_net.ipv4.sysctl_tcp_moderate_rcvbuf, 1237 .maxlen = sizeof(u8), 1238 .mode = 0644, 1239 .proc_handler = proc_dou8vec_minmax, 1240 }, 1241 { 1242 .procname = "tcp_tso_win_divisor", 1243 .data = &init_net.ipv4.sysctl_tcp_tso_win_divisor, 1244 .maxlen = sizeof(u8), 1245 .mode = 0644, 1246 .proc_handler = proc_dou8vec_minmax, 1247 }, 1248 { 1249 .procname = "tcp_workaround_signed_windows", 1250 .data = &init_net.ipv4.sysctl_tcp_workaround_signed_windows, 1251 .maxlen = sizeof(u8), 1252 .mode = 0644, 1253 .proc_handler = proc_dou8vec_minmax, 1254 }, 1255 { 1256 .procname = "tcp_limit_output_bytes", 1257 .data = &init_net.ipv4.sysctl_tcp_limit_output_bytes, 1258 .maxlen = sizeof(int), 1259 .mode = 0644, 1260 .proc_handler = proc_dointvec 1261 }, 1262 { 1263 .procname = "tcp_challenge_ack_limit", 1264 .data = &init_net.ipv4.sysctl_tcp_challenge_ack_limit, 1265 .maxlen = sizeof(int), 1266 .mode = 0644, 1267 .proc_handler = proc_dointvec 1268 }, 1269 { 1270 .procname = "tcp_min_tso_segs", 1271 .data = &init_net.ipv4.sysctl_tcp_min_tso_segs, 1272 .maxlen = sizeof(u8), 1273 .mode = 0644, 1274 .proc_handler = proc_dou8vec_minmax, 1275 .extra1 = SYSCTL_ONE, 1276 }, 1277 { 1278 .procname = "tcp_tso_rtt_log", 1279 .data = &init_net.ipv4.sysctl_tcp_tso_rtt_log, 1280 .maxlen = sizeof(u8), 1281 .mode = 0644, 1282 .proc_handler = proc_dou8vec_minmax, 1283 }, 1284 { 1285 .procname = "tcp_min_rtt_wlen", 1286 .data = &init_net.ipv4.sysctl_tcp_min_rtt_wlen, 1287 .maxlen = sizeof(int), 1288 .mode = 0644, 1289 .proc_handler = proc_dointvec_minmax, 1290 .extra1 = SYSCTL_ZERO, 1291 .extra2 = &one_day_secs 1292 }, 1293 { 1294 .procname = "tcp_autocorking", 1295 .data = &init_net.ipv4.sysctl_tcp_autocorking, 1296 .maxlen = sizeof(u8), 1297 .mode = 0644, 1298 .proc_handler = proc_dou8vec_minmax, 1299 .extra1 = SYSCTL_ZERO, 1300 .extra2 = SYSCTL_ONE, 1301 }, 1302 { 1303 .procname = "tcp_invalid_ratelimit", 1304 .data = &init_net.ipv4.sysctl_tcp_invalid_ratelimit, 1305 .maxlen = sizeof(int), 1306 .mode = 0644, 1307 .proc_handler = proc_dointvec_ms_jiffies, 1308 }, 1309 { 1310 .procname = "tcp_pacing_ss_ratio", 1311 .data = &init_net.ipv4.sysctl_tcp_pacing_ss_ratio, 1312 .maxlen = sizeof(int), 1313 .mode = 0644, 1314 .proc_handler = proc_dointvec_minmax, 1315 .extra1 = SYSCTL_ZERO, 1316 .extra2 = SYSCTL_ONE_THOUSAND, 1317 }, 1318 { 1319 .procname = "tcp_pacing_ca_ratio", 1320 .data = &init_net.ipv4.sysctl_tcp_pacing_ca_ratio, 1321 .maxlen = sizeof(int), 1322 .mode = 0644, 1323 .proc_handler = proc_dointvec_minmax, 1324 .extra1 = SYSCTL_ZERO, 1325 .extra2 = SYSCTL_ONE_THOUSAND, 1326 }, 1327 { 1328 .procname = "tcp_wmem", 1329 .data = &init_net.ipv4.sysctl_tcp_wmem, 1330 .maxlen = sizeof(init_net.ipv4.sysctl_tcp_wmem), 1331 .mode = 0644, 1332 .proc_handler = proc_dointvec_minmax, 1333 .extra1 = SYSCTL_ONE, 1334 }, 1335 { 1336 .procname = "tcp_rmem", 1337 .data = &init_net.ipv4.sysctl_tcp_rmem, 1338 .maxlen = sizeof(init_net.ipv4.sysctl_tcp_rmem), 1339 .mode = 0644, 1340 .proc_handler = proc_dointvec_minmax, 1341 .extra1 = SYSCTL_ONE, 1342 }, 1343 { 1344 .procname = "tcp_comp_sack_delay_ns", 1345 .data = &init_net.ipv4.sysctl_tcp_comp_sack_delay_ns, 1346 .maxlen = sizeof(unsigned long), 1347 .mode = 0644, 1348 .proc_handler = proc_doulongvec_minmax, 1349 }, 1350 { 1351 .procname = "tcp_comp_sack_slack_ns", 1352 .data = &init_net.ipv4.sysctl_tcp_comp_sack_slack_ns, 1353 .maxlen = sizeof(unsigned long), 1354 .mode = 0644, 1355 .proc_handler = proc_doulongvec_minmax, 1356 }, 1357 { 1358 .procname = "tcp_comp_sack_nr", 1359 .data = &init_net.ipv4.sysctl_tcp_comp_sack_nr, 1360 .maxlen = sizeof(u8), 1361 .mode = 0644, 1362 .proc_handler = proc_dou8vec_minmax, 1363 .extra1 = SYSCTL_ZERO, 1364 }, 1365 { 1366 .procname = "tcp_reflect_tos", 1367 .data = &init_net.ipv4.sysctl_tcp_reflect_tos, 1368 .maxlen = sizeof(u8), 1369 .mode = 0644, 1370 .proc_handler = proc_dou8vec_minmax, 1371 .extra1 = SYSCTL_ZERO, 1372 .extra2 = SYSCTL_ONE, 1373 }, 1374 { 1375 .procname = "tcp_ehash_entries", 1376 .data = &init_net.ipv4.sysctl_tcp_child_ehash_entries, 1377 .mode = 0444, 1378 .proc_handler = proc_tcp_ehash_entries, 1379 }, 1380 { 1381 .procname = "tcp_child_ehash_entries", 1382 .data = &init_net.ipv4.sysctl_tcp_child_ehash_entries, 1383 .maxlen = sizeof(unsigned int), 1384 .mode = 0644, 1385 .proc_handler = proc_douintvec_minmax, 1386 .extra1 = SYSCTL_ZERO, 1387 .extra2 = &tcp_child_ehash_entries_max, 1388 }, 1389 { 1390 .procname = "udp_hash_entries", 1391 .data = &init_net.ipv4.sysctl_udp_child_hash_entries, 1392 .mode = 0444, 1393 .proc_handler = proc_udp_hash_entries, 1394 }, 1395 { 1396 .procname = "udp_child_hash_entries", 1397 .data = &init_net.ipv4.sysctl_udp_child_hash_entries, 1398 .maxlen = sizeof(unsigned int), 1399 .mode = 0644, 1400 .proc_handler = proc_douintvec_minmax, 1401 .extra1 = SYSCTL_ZERO, 1402 .extra2 = &udp_child_hash_entries_max, 1403 }, 1404 { 1405 .procname = "udp_rmem_min", 1406 .data = &init_net.ipv4.sysctl_udp_rmem_min, 1407 .maxlen = sizeof(init_net.ipv4.sysctl_udp_rmem_min), 1408 .mode = 0644, 1409 .proc_handler = proc_dointvec_minmax, 1410 .extra1 = SYSCTL_ONE 1411 }, 1412 { 1413 .procname = "udp_wmem_min", 1414 .data = &init_net.ipv4.sysctl_udp_wmem_min, 1415 .maxlen = sizeof(init_net.ipv4.sysctl_udp_wmem_min), 1416 .mode = 0644, 1417 .proc_handler = proc_dointvec_minmax, 1418 .extra1 = SYSCTL_ONE 1419 }, 1420 { 1421 .procname = "fib_notify_on_flag_change", 1422 .data = &init_net.ipv4.sysctl_fib_notify_on_flag_change, 1423 .maxlen = sizeof(u8), 1424 .mode = 0644, 1425 .proc_handler = proc_dou8vec_minmax, 1426 .extra1 = SYSCTL_ZERO, 1427 .extra2 = SYSCTL_TWO, 1428 }, 1429 { 1430 .procname = "tcp_plb_enabled", 1431 .data = &init_net.ipv4.sysctl_tcp_plb_enabled, 1432 .maxlen = sizeof(u8), 1433 .mode = 0644, 1434 .proc_handler = proc_dou8vec_minmax, 1435 .extra1 = SYSCTL_ZERO, 1436 .extra2 = SYSCTL_ONE, 1437 }, 1438 { 1439 .procname = "tcp_plb_idle_rehash_rounds", 1440 .data = &init_net.ipv4.sysctl_tcp_plb_idle_rehash_rounds, 1441 .maxlen = sizeof(u8), 1442 .mode = 0644, 1443 .proc_handler = proc_dou8vec_minmax, 1444 .extra2 = &tcp_plb_max_rounds, 1445 }, 1446 { 1447 .procname = "tcp_plb_rehash_rounds", 1448 .data = &init_net.ipv4.sysctl_tcp_plb_rehash_rounds, 1449 .maxlen = sizeof(u8), 1450 .mode = 0644, 1451 .proc_handler = proc_dou8vec_minmax, 1452 .extra2 = &tcp_plb_max_rounds, 1453 }, 1454 { 1455 .procname = "tcp_plb_suspend_rto_sec", 1456 .data = &init_net.ipv4.sysctl_tcp_plb_suspend_rto_sec, 1457 .maxlen = sizeof(u8), 1458 .mode = 0644, 1459 .proc_handler = proc_dou8vec_minmax, 1460 }, 1461 { 1462 .procname = "tcp_plb_cong_thresh", 1463 .data = &init_net.ipv4.sysctl_tcp_plb_cong_thresh, 1464 .maxlen = sizeof(int), 1465 .mode = 0644, 1466 .proc_handler = proc_dointvec_minmax, 1467 .extra1 = SYSCTL_ZERO, 1468 .extra2 = &tcp_plb_max_cong_thresh, 1469 }, 1470 { } 1471 }; 1472 1473 static __net_init int ipv4_sysctl_init_net(struct net *net) 1474 { 1475 struct ctl_table *table; 1476 1477 table = ipv4_net_table; 1478 if (!net_eq(net, &init_net)) { 1479 int i; 1480 1481 table = kmemdup(table, sizeof(ipv4_net_table), GFP_KERNEL); 1482 if (!table) 1483 goto err_alloc; 1484 1485 for (i = 0; i < ARRAY_SIZE(ipv4_net_table) - 1; i++) { 1486 if (table[i].data) { 1487 /* Update the variables to point into 1488 * the current struct net 1489 */ 1490 table[i].data += (void *)net - (void *)&init_net; 1491 } else { 1492 /* Entries without data pointer are global; 1493 * Make them read-only in non-init_net ns 1494 */ 1495 table[i].mode &= ~0222; 1496 } 1497 } 1498 } 1499 1500 net->ipv4.ipv4_hdr = register_net_sysctl(net, "net/ipv4", table); 1501 if (!net->ipv4.ipv4_hdr) 1502 goto err_reg; 1503 1504 net->ipv4.sysctl_local_reserved_ports = kzalloc(65536 / 8, GFP_KERNEL); 1505 if (!net->ipv4.sysctl_local_reserved_ports) 1506 goto err_ports; 1507 1508 return 0; 1509 1510 err_ports: 1511 unregister_net_sysctl_table(net->ipv4.ipv4_hdr); 1512 err_reg: 1513 if (!net_eq(net, &init_net)) 1514 kfree(table); 1515 err_alloc: 1516 return -ENOMEM; 1517 } 1518 1519 static __net_exit void ipv4_sysctl_exit_net(struct net *net) 1520 { 1521 struct ctl_table *table; 1522 1523 kfree(net->ipv4.sysctl_local_reserved_ports); 1524 table = net->ipv4.ipv4_hdr->ctl_table_arg; 1525 unregister_net_sysctl_table(net->ipv4.ipv4_hdr); 1526 kfree(table); 1527 } 1528 1529 static __net_initdata struct pernet_operations ipv4_sysctl_ops = { 1530 .init = ipv4_sysctl_init_net, 1531 .exit = ipv4_sysctl_exit_net, 1532 }; 1533 1534 static __init int sysctl_ipv4_init(void) 1535 { 1536 struct ctl_table_header *hdr; 1537 1538 hdr = register_net_sysctl(&init_net, "net/ipv4", ipv4_table); 1539 if (!hdr) 1540 return -ENOMEM; 1541 1542 if (register_pernet_subsys(&ipv4_sysctl_ops)) { 1543 unregister_net_sysctl_table(hdr); 1544 return -ENOMEM; 1545 } 1546 1547 return 0; 1548 } 1549 1550 __initcall(sysctl_ipv4_init); 1551