tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'net-add-export_ipv6_mod'

Eric Dumazet says:

====================
net: add EXPORT_IPV6_MOD()

In this series I am adding EXPORT_IPV6_MOD and EXPORT_IPV6_MOD_GPL()
so that we can replace some EXPORT_SYMBOL() when IPV6 is
not modular.

This is making all the selected symbols internal to core
linux networking.

v1: https://lore.kernel.org/20250210082805.465241-2-edumazet@google.com
====================

Link: https://patch.msgid.link/20250212132418.1524422-1-edumazet@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski 4671bb1a 7a7e0197

+114 -109
+8
include/net/ip.h
··· 673 673 memcpy(buf, &naddr, sizeof(naddr)); 674 674 } 675 675 676 + #if IS_MODULE(CONFIG_IPV6) 677 + #define EXPORT_IPV6_MOD(X) EXPORT_SYMBOL(X) 678 + #define EXPORT_IPV6_MOD_GPL(X) EXPORT_SYMBOL_GPL(X) 679 + #else 680 + #define EXPORT_IPV6_MOD(X) 681 + #define EXPORT_IPV6_MOD_GPL(X) 682 + #endif 683 + 676 684 #if IS_ENABLED(CONFIG_IPV6) 677 685 #include <linux/ipv6.h> 678 686 #endif
+1 -1
net/core/secure_seq.c
··· 71 71 return siphash(&combined, offsetofend(typeof(combined), daddr), 72 72 &ts_secret); 73 73 } 74 - EXPORT_SYMBOL(secure_tcpv6_ts_off); 74 + EXPORT_IPV6_MOD(secure_tcpv6_ts_off); 75 75 76 76 u32 secure_tcpv6_seq(const __be32 *saddr, const __be32 *daddr, 77 77 __be16 sport, __be16 dport)
+4 -4
net/ipv4/inetpeer.c
··· 60 60 seqlock_init(&bp->lock); 61 61 bp->total = 0; 62 62 } 63 - EXPORT_SYMBOL_GPL(inet_peer_base_init); 63 + EXPORT_IPV6_MOD_GPL(inet_peer_base_init); 64 64 65 65 #define PEER_MAX_GC 32 66 66 ··· 218 218 219 219 return p; 220 220 } 221 - EXPORT_SYMBOL_GPL(inet_getpeer); 221 + EXPORT_IPV6_MOD_GPL(inet_getpeer); 222 222 223 223 void inet_putpeer(struct inet_peer *p) 224 224 { ··· 269 269 WRITE_ONCE(peer->rate_tokens, token); 270 270 return rc; 271 271 } 272 - EXPORT_SYMBOL(inet_peer_xrlim_allow); 272 + EXPORT_IPV6_MOD(inet_peer_xrlim_allow); 273 273 274 274 void inetpeer_invalidate_tree(struct inet_peer_base *base) 275 275 { ··· 286 286 287 287 base->total = 0; 288 288 } 289 - EXPORT_SYMBOL(inetpeer_invalidate_tree); 289 + EXPORT_IPV6_MOD(inetpeer_invalidate_tree);
+4 -4
net/ipv4/syncookies.c
··· 222 222 223 223 return NULL; 224 224 } 225 - EXPORT_SYMBOL(tcp_get_cookie_sock); 225 + EXPORT_IPV6_MOD(tcp_get_cookie_sock); 226 226 227 227 /* 228 228 * when syncookies are in effect and tcp timestamps are enabled we stored ··· 259 259 260 260 return READ_ONCE(net->ipv4.sysctl_tcp_window_scaling) != 0; 261 261 } 262 - EXPORT_SYMBOL(cookie_timestamp_decode); 262 + EXPORT_IPV6_MOD(cookie_timestamp_decode); 263 263 264 264 static int cookie_tcp_reqsk_init(struct sock *sk, struct sk_buff *skb, 265 265 struct request_sock *req) ··· 310 310 311 311 return req; 312 312 } 313 - EXPORT_SYMBOL_GPL(cookie_bpf_check); 313 + EXPORT_IPV6_MOD_GPL(cookie_bpf_check); 314 314 #endif 315 315 316 316 struct request_sock *cookie_tcp_reqsk_alloc(const struct request_sock_ops *ops, ··· 351 351 352 352 return req; 353 353 } 354 - EXPORT_SYMBOL_GPL(cookie_tcp_reqsk_alloc); 354 + EXPORT_IPV6_MOD_GPL(cookie_tcp_reqsk_alloc); 355 355 356 356 static struct request_sock *cookie_tcp_check(struct net *net, struct sock *sk, 357 357 struct sk_buff *skb)
+22 -22
net/ipv4/tcp.c
··· 300 300 EXPORT_PER_CPU_SYMBOL_GPL(tcp_tw_isn); 301 301 302 302 long sysctl_tcp_mem[3] __read_mostly; 303 - EXPORT_SYMBOL(sysctl_tcp_mem); 303 + EXPORT_IPV6_MOD(sysctl_tcp_mem); 304 304 305 305 atomic_long_t tcp_memory_allocated ____cacheline_aligned_in_smp; /* Current allocated memory. */ 306 - EXPORT_SYMBOL(tcp_memory_allocated); 306 + EXPORT_IPV6_MOD(tcp_memory_allocated); 307 307 DEFINE_PER_CPU(int, tcp_memory_per_cpu_fw_alloc); 308 308 EXPORT_PER_CPU_SYMBOL_GPL(tcp_memory_per_cpu_fw_alloc); 309 309 ··· 316 316 * Current number of TCP sockets. 317 317 */ 318 318 struct percpu_counter tcp_sockets_allocated ____cacheline_aligned_in_smp; 319 - EXPORT_SYMBOL(tcp_sockets_allocated); 319 + EXPORT_IPV6_MOD(tcp_sockets_allocated); 320 320 321 321 /* 322 322 * TCP splice context ··· 349 349 if (!cmpxchg(&tcp_memory_pressure, 0, val)) 350 350 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES); 351 351 } 352 - EXPORT_SYMBOL_GPL(tcp_enter_memory_pressure); 352 + EXPORT_IPV6_MOD_GPL(tcp_enter_memory_pressure); 353 353 354 354 void tcp_leave_memory_pressure(struct sock *sk) 355 355 { ··· 362 362 NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURESCHRONO, 363 363 jiffies_to_msecs(jiffies - val)); 364 364 } 365 - EXPORT_SYMBOL_GPL(tcp_leave_memory_pressure); 365 + EXPORT_IPV6_MOD_GPL(tcp_leave_memory_pressure); 366 366 367 367 /* Convert seconds to retransmits based on initial and max timeout */ 368 368 static u8 secs_to_retrans(int seconds, int timeout, int rto_max) ··· 479 479 sk_sockets_allocated_inc(sk); 480 480 xa_init_flags(&sk->sk_user_frags, XA_FLAGS_ALLOC1); 481 481 } 482 - EXPORT_SYMBOL(tcp_init_sock); 482 + EXPORT_IPV6_MOD(tcp_init_sock); 483 483 484 484 static void tcp_tx_timestamp(struct sock *sk, struct sockcm_cookie *sockc) 485 485 { ··· 664 664 *karg = answ; 665 665 return 0; 666 666 } 667 - EXPORT_SYMBOL(tcp_ioctl); 667 + EXPORT_IPV6_MOD(tcp_ioctl); 668 668 669 669 void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb) 670 670 { ··· 880 880 881 881 return ret; 882 882 } 883 - EXPORT_SYMBOL(tcp_splice_read); 883 + EXPORT_IPV6_MOD(tcp_splice_read); 884 884 885 885 struct sk_buff *tcp_stream_alloc_skb(struct sock *sk, gfp_t gfp, 886 886 bool force_schedule) ··· 1380 1380 tcp_push(sk, 0, mss_now, tp->nonagle, size_goal); 1381 1381 release_sock(sk); 1382 1382 } 1383 - EXPORT_SYMBOL_GPL(tcp_splice_eof); 1383 + EXPORT_IPV6_MOD_GPL(tcp_splice_eof); 1384 1384 1385 1385 /* 1386 1386 * Handle reading urgent data. BSD has very simple semantics for ··· 1671 1671 } 1672 1672 return copied; 1673 1673 } 1674 - EXPORT_SYMBOL(tcp_read_skb); 1674 + EXPORT_IPV6_MOD(tcp_read_skb); 1675 1675 1676 1676 void tcp_read_done(struct sock *sk, size_t len) 1677 1677 { ··· 1716 1716 { 1717 1717 return tcp_inq(sock->sk); 1718 1718 } 1719 - EXPORT_SYMBOL(tcp_peek_len); 1719 + EXPORT_IPV6_MOD(tcp_peek_len); 1720 1720 1721 1721 /* Make sure sk_rcvbuf is big enough to satisfy SO_RCVLOWAT hint */ 1722 1722 int tcp_set_rcvlowat(struct sock *sk, int val) ··· 1743 1743 } 1744 1744 return 0; 1745 1745 } 1746 - EXPORT_SYMBOL(tcp_set_rcvlowat); 1746 + EXPORT_IPV6_MOD(tcp_set_rcvlowat); 1747 1747 1748 1748 void tcp_update_recv_tstamps(struct sk_buff *skb, 1749 1749 struct scm_timestamping_internal *tss) ··· 1776 1776 vma->vm_ops = &tcp_vm_ops; 1777 1777 return 0; 1778 1778 } 1779 - EXPORT_SYMBOL(tcp_mmap); 1779 + EXPORT_IPV6_MOD(tcp_mmap); 1780 1780 1781 1781 static skb_frag_t *skb_advance_to_frag(struct sk_buff *skb, u32 offset_skb, 1782 1782 u32 *offset_frag) ··· 2873 2873 } 2874 2874 return ret; 2875 2875 } 2876 - EXPORT_SYMBOL(tcp_recvmsg); 2876 + EXPORT_IPV6_MOD(tcp_recvmsg); 2877 2877 2878 2878 void tcp_set_state(struct sock *sk, int state) 2879 2879 { ··· 3003 3003 tcp_send_fin(sk); 3004 3004 } 3005 3005 } 3006 - EXPORT_SYMBOL(tcp_shutdown); 3006 + EXPORT_IPV6_MOD(tcp_shutdown); 3007 3007 3008 3008 int tcp_orphan_count_sum(void) 3009 3009 { ··· 3502 3502 } 3503 3503 3504 3504 DEFINE_STATIC_KEY_FALSE(tcp_tx_delay_enabled); 3505 - EXPORT_SYMBOL(tcp_tx_delay_enabled); 3505 + EXPORT_IPV6_MOD(tcp_tx_delay_enabled); 3506 3506 3507 3507 static void tcp_enable_tx_delay(void) 3508 3508 { ··· 4045 4045 optval, optlen); 4046 4046 return do_tcp_setsockopt(sk, level, optname, optval, optlen); 4047 4047 } 4048 - EXPORT_SYMBOL(tcp_setsockopt); 4048 + EXPORT_IPV6_MOD(tcp_setsockopt); 4049 4049 4050 4050 static void tcp_get_info_chrono_stats(const struct tcp_sock *tp, 4051 4051 struct tcp_info *info) ··· 4676 4676 4677 4677 return false; 4678 4678 } 4679 - EXPORT_SYMBOL(tcp_bpf_bypass_getsockopt); 4679 + EXPORT_IPV6_MOD(tcp_bpf_bypass_getsockopt); 4680 4680 4681 4681 int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval, 4682 4682 int __user *optlen) ··· 4690 4690 return do_tcp_getsockopt(sk, level, optname, USER_SOCKPTR(optval), 4691 4691 USER_SOCKPTR(optlen)); 4692 4692 } 4693 - EXPORT_SYMBOL(tcp_getsockopt); 4693 + EXPORT_IPV6_MOD(tcp_getsockopt); 4694 4694 4695 4695 #ifdef CONFIG_TCP_MD5SIG 4696 4696 int tcp_md5_sigpool_id = -1; 4697 - EXPORT_SYMBOL_GPL(tcp_md5_sigpool_id); 4697 + EXPORT_IPV6_MOD_GPL(tcp_md5_sigpool_id); 4698 4698 4699 4699 int tcp_md5_alloc_sigpool(void) 4700 4700 { ··· 4740 4740 */ 4741 4741 return data_race(crypto_ahash_update(hp->req)); 4742 4742 } 4743 - EXPORT_SYMBOL(tcp_md5_hash_key); 4743 + EXPORT_IPV6_MOD(tcp_md5_hash_key); 4744 4744 4745 4745 /* Called with rcu_read_lock() */ 4746 4746 static enum skb_drop_reason ··· 4860 4860 return tcp_inbound_md5_hash(sk, skb, saddr, daddr, family, 4861 4861 l3index, md5_location); 4862 4862 } 4863 - EXPORT_SYMBOL_GPL(tcp_inbound_hash); 4863 + EXPORT_IPV6_MOD_GPL(tcp_inbound_hash); 4864 4864 4865 4865 void tcp_done(struct sock *sk) 4866 4866 {
+1 -1
net/ipv4/tcp_fastopen.c
··· 468 468 } 469 469 return false; 470 470 } 471 - EXPORT_SYMBOL(tcp_fastopen_defer_connect); 471 + EXPORT_IPV6_MOD(tcp_fastopen_defer_connect); 472 472 473 473 /* 474 474 * The following code block is to deal with middle box issues with TFO:
+7 -7
net/ipv4/tcp_input.c
··· 630 630 631 631 inet_csk(sk)->icsk_ack.rcv_mss = hint; 632 632 } 633 - EXPORT_SYMBOL(tcp_initialize_rcv_mss); 633 + EXPORT_IPV6_MOD(tcp_initialize_rcv_mss); 634 634 635 635 /* Receiver "autotuning" code. 636 636 * ··· 2891 2891 */ 2892 2892 tcp_non_congestion_loss_retransmit(sk); 2893 2893 } 2894 - EXPORT_SYMBOL(tcp_simple_retransmit); 2894 + EXPORT_IPV6_MOD(tcp_simple_retransmit); 2895 2895 2896 2896 void tcp_enter_recovery(struct sock *sk, bool ece_ack) 2897 2897 { ··· 4521 4521 if (!sock_flag(sk, SOCK_DEAD)) 4522 4522 sk_error_report(sk); 4523 4523 } 4524 - EXPORT_SYMBOL(tcp_done_with_error); 4524 + EXPORT_IPV6_MOD(tcp_done_with_error); 4525 4525 4526 4526 /* When we get a reset we do this. */ 4527 4527 void tcp_reset(struct sock *sk, struct sk_buff *skb) ··· 6291 6291 discard: 6292 6292 tcp_drop_reason(sk, skb, reason); 6293 6293 } 6294 - EXPORT_SYMBOL(tcp_rcv_established); 6294 + EXPORT_IPV6_MOD(tcp_rcv_established); 6295 6295 6296 6296 void tcp_init_transfer(struct sock *sk, int bpf_op, struct sk_buff *skb) 6297 6297 { ··· 7004 7004 __kfree_skb(skb); 7005 7005 return 0; 7006 7006 } 7007 - EXPORT_SYMBOL(tcp_rcv_state_process); 7007 + EXPORT_IPV6_MOD(tcp_rcv_state_process); 7008 7008 7009 7009 static inline void pr_drop_req(struct request_sock *req, __u16 port, int family) 7010 7010 { ··· 7186 7186 7187 7187 return mss; 7188 7188 } 7189 - EXPORT_SYMBOL_GPL(tcp_get_syncookie_mss); 7189 + EXPORT_IPV6_MOD_GPL(tcp_get_syncookie_mss); 7190 7190 7191 7191 int tcp_conn_request(struct request_sock_ops *rsk_ops, 7192 7192 const struct tcp_request_sock_ops *af_ops, ··· 7367 7367 tcp_listendrop(sk); 7368 7368 return 0; 7369 7369 } 7370 - EXPORT_SYMBOL(tcp_conn_request); 7370 + EXPORT_IPV6_MOD(tcp_conn_request);
+23 -24
net/ipv4/tcp_ipv4.c
··· 92 92 #endif 93 93 94 94 struct inet_hashinfo tcp_hashinfo; 95 - EXPORT_SYMBOL(tcp_hashinfo); 96 95 97 96 static DEFINE_PER_CPU(struct sock_bh_locked, ipv4_tcp_sk) = { 98 97 .bh_lock = INIT_LOCAL_LOCK(bh_lock), ··· 198 199 199 200 return 0; 200 201 } 201 - EXPORT_SYMBOL_GPL(tcp_twsk_unique); 202 + EXPORT_IPV6_MOD_GPL(tcp_twsk_unique); 202 203 203 204 static int tcp_v4_pre_connect(struct sock *sk, struct sockaddr *uaddr, 204 205 int addr_len) ··· 358 359 inet->inet_dport = 0; 359 360 return err; 360 361 } 361 - EXPORT_SYMBOL(tcp_v4_connect); 362 + EXPORT_IPV6_MOD(tcp_v4_connect); 362 363 363 364 /* 364 365 * This routine reacts to ICMP_FRAG_NEEDED mtu indications as defined in RFC1191. ··· 399 400 tcp_simple_retransmit(sk); 400 401 } /* else let the usual retransmit timer handle it */ 401 402 } 402 - EXPORT_SYMBOL(tcp_v4_mtu_reduced); 403 + EXPORT_IPV6_MOD(tcp_v4_mtu_reduced); 403 404 404 405 static void do_redirect(struct sk_buff *skb, struct sock *sk) 405 406 { ··· 433 434 } 434 435 reqsk_put(req); 435 436 } 436 - EXPORT_SYMBOL(tcp_req_err); 437 + EXPORT_IPV6_MOD(tcp_req_err); 437 438 438 439 /* TCP-LD (RFC 6069) logic */ 439 440 void tcp_ld_RTO_revert(struct sock *sk, u32 seq) ··· 472 473 tcp_retransmit_timer(sk); 473 474 } 474 475 } 475 - EXPORT_SYMBOL(tcp_ld_RTO_revert); 476 + EXPORT_IPV6_MOD(tcp_ld_RTO_revert); 476 477 477 478 /* 478 479 * This routine is called by the ICMP module when it gets some ··· 674 675 675 676 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr); 676 677 } 677 - EXPORT_SYMBOL(tcp_v4_send_check); 678 + EXPORT_IPV6_MOD(tcp_v4_send_check); 678 679 679 680 #define REPLY_OPTIONS_LEN (MAX_TCP_OPTION_SPACE / sizeof(__be32)) 680 681 ··· 1229 1230 */ 1230 1231 1231 1232 DEFINE_STATIC_KEY_DEFERRED_FALSE(tcp_md5_needed, HZ); 1232 - EXPORT_SYMBOL(tcp_md5_needed); 1233 + EXPORT_IPV6_MOD(tcp_md5_needed); 1233 1234 1234 1235 static bool better_md5_match(struct tcp_md5sig_key *old, struct tcp_md5sig_key *new) 1235 1236 { ··· 1288 1289 } 1289 1290 return best_match; 1290 1291 } 1291 - EXPORT_SYMBOL(__tcp_md5_do_lookup); 1292 + EXPORT_IPV6_MOD(__tcp_md5_do_lookup); 1292 1293 1293 1294 static struct tcp_md5sig_key *tcp_md5_do_lookup_exact(const struct sock *sk, 1294 1295 const union tcp_md5_addr *addr, ··· 1335 1336 addr = (const union tcp_md5_addr *)&addr_sk->sk_daddr; 1336 1337 return tcp_md5_do_lookup(sk, l3index, addr, AF_INET); 1337 1338 } 1338 - EXPORT_SYMBOL(tcp_v4_md5_lookup); 1339 + EXPORT_IPV6_MOD(tcp_v4_md5_lookup); 1339 1340 1340 1341 static int tcp_md5sig_info_add(struct sock *sk, gfp_t gfp) 1341 1342 { ··· 1431 1432 return __tcp_md5_do_add(sk, addr, family, prefixlen, l3index, flags, 1432 1433 newkey, newkeylen, GFP_KERNEL); 1433 1434 } 1434 - EXPORT_SYMBOL(tcp_md5_do_add); 1435 + EXPORT_IPV6_MOD(tcp_md5_do_add); 1435 1436 1436 1437 int tcp_md5_key_copy(struct sock *sk, const union tcp_md5_addr *addr, 1437 1438 int family, u8 prefixlen, int l3index, ··· 1463 1464 key->flags, key->key, key->keylen, 1464 1465 sk_gfp_mask(sk, GFP_ATOMIC)); 1465 1466 } 1466 - EXPORT_SYMBOL(tcp_md5_key_copy); 1467 + EXPORT_IPV6_MOD(tcp_md5_key_copy); 1467 1468 1468 1469 int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family, 1469 1470 u8 prefixlen, int l3index, u8 flags) ··· 1478 1479 kfree_rcu(key, rcu); 1479 1480 return 0; 1480 1481 } 1481 - EXPORT_SYMBOL(tcp_md5_do_del); 1482 + EXPORT_IPV6_MOD(tcp_md5_do_del); 1482 1483 1483 1484 void tcp_clear_md5_list(struct sock *sk) 1484 1485 { ··· 1657 1658 memset(md5_hash, 0, 16); 1658 1659 return 1; 1659 1660 } 1660 - EXPORT_SYMBOL(tcp_v4_md5_hash_skb); 1661 + EXPORT_IPV6_MOD(tcp_v4_md5_hash_skb); 1661 1662 1662 1663 #endif 1663 1664 ··· 1730 1731 tcp_listendrop(sk); 1731 1732 return 0; 1732 1733 } 1733 - EXPORT_SYMBOL(tcp_v4_conn_request); 1734 + EXPORT_IPV6_MOD(tcp_v4_conn_request); 1734 1735 1735 1736 1736 1737 /* ··· 1854 1855 tcp_done(newsk); 1855 1856 goto exit; 1856 1857 } 1857 - EXPORT_SYMBOL(tcp_v4_syn_recv_sock); 1858 + EXPORT_IPV6_MOD(tcp_v4_syn_recv_sock); 1858 1859 1859 1860 static struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb) 1860 1861 { ··· 2133 2134 } 2134 2135 return false; 2135 2136 } 2136 - EXPORT_SYMBOL(tcp_add_backlog); 2137 + EXPORT_IPV6_MOD(tcp_add_backlog); 2137 2138 2138 2139 int tcp_filter(struct sock *sk, struct sk_buff *skb) 2139 2140 { ··· 2141 2142 2142 2143 return sk_filter_trim_cap(sk, skb, th->doff * 4); 2143 2144 } 2144 - EXPORT_SYMBOL(tcp_filter); 2145 + EXPORT_IPV6_MOD(tcp_filter); 2145 2146 2146 2147 static void tcp_v4_restore_cb(struct sk_buff *skb) 2147 2148 { ··· 2450 2451 sk->sk_rx_dst_ifindex = skb->skb_iif; 2451 2452 } 2452 2453 } 2453 - EXPORT_SYMBOL(inet_sk_rx_dst_set); 2454 + EXPORT_IPV6_MOD(inet_sk_rx_dst_set); 2454 2455 2455 2456 const struct inet_connection_sock_af_ops ipv4_specific = { 2456 2457 .queue_xmit = ip_queue_xmit, ··· 2466 2467 .sockaddr_len = sizeof(struct sockaddr_in), 2467 2468 .mtu_reduced = tcp_v4_mtu_reduced, 2468 2469 }; 2469 - EXPORT_SYMBOL(ipv4_specific); 2470 + EXPORT_IPV6_MOD(ipv4_specific); 2470 2471 2471 2472 #if defined(CONFIG_TCP_MD5SIG) || defined(CONFIG_TCP_AO) 2472 2473 static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = { ··· 2576 2577 2577 2578 sk_sockets_allocated_dec(sk); 2578 2579 } 2579 - EXPORT_SYMBOL(tcp_v4_destroy_sock); 2580 + EXPORT_IPV6_MOD(tcp_v4_destroy_sock); 2580 2581 2581 2582 #ifdef CONFIG_PROC_FS 2582 2583 /* Proc filesystem TCP sock list dumping. */ ··· 2812 2813 st->last_pos = *pos; 2813 2814 return rc; 2814 2815 } 2815 - EXPORT_SYMBOL(tcp_seq_start); 2816 + EXPORT_IPV6_MOD(tcp_seq_start); 2816 2817 2817 2818 void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2818 2819 { ··· 2843 2844 st->last_pos = *pos; 2844 2845 return rc; 2845 2846 } 2846 - EXPORT_SYMBOL(tcp_seq_next); 2847 + EXPORT_IPV6_MOD(tcp_seq_next); 2847 2848 2848 2849 void tcp_seq_stop(struct seq_file *seq, void *v) 2849 2850 { ··· 2861 2862 break; 2862 2863 } 2863 2864 } 2864 - EXPORT_SYMBOL(tcp_seq_stop); 2865 + EXPORT_IPV6_MOD(tcp_seq_stop); 2865 2866 2866 2867 static void get_openreq4(const struct request_sock *req, 2867 2868 struct seq_file *f, int i)
+5 -6
net/ipv4/tcp_minisocks.c
··· 264 264 inet_twsk_put(tw); 265 265 return TCP_TW_SUCCESS; 266 266 } 267 - EXPORT_SYMBOL(tcp_timewait_state_process); 267 + EXPORT_IPV6_MOD(tcp_timewait_state_process); 268 268 269 269 static void tcp_time_wait_init(struct sock *sk, struct tcp_timewait_sock *tcptw) 270 270 { ··· 398 398 #endif 399 399 tcp_ao_destroy_sock(sk, true); 400 400 } 401 - EXPORT_SYMBOL_GPL(tcp_twsk_destructor); 401 + EXPORT_IPV6_MOD_GPL(tcp_twsk_destructor); 402 402 403 403 void tcp_twsk_purge(struct list_head *net_exit_list) 404 404 { ··· 457 457 rcv_wnd); 458 458 ireq->rcv_wscale = rcv_wscale; 459 459 } 460 - EXPORT_SYMBOL(tcp_openreq_init_rwin); 461 460 462 461 static void tcp_ecn_openreq_child(struct tcp_sock *tp, 463 462 const struct request_sock *req) ··· 491 492 492 493 tcp_set_ca_state(sk, TCP_CA_Open); 493 494 } 494 - EXPORT_SYMBOL_GPL(tcp_ca_openreq_child); 495 + EXPORT_IPV6_MOD_GPL(tcp_ca_openreq_child); 495 496 496 497 static void smc_check_reset_syn_req(const struct tcp_sock *oldtp, 497 498 struct request_sock *req, ··· 908 909 } 909 910 return NULL; 910 911 } 911 - EXPORT_SYMBOL(tcp_check_req); 912 + EXPORT_IPV6_MOD(tcp_check_req); 912 913 913 914 /* 914 915 * Queue segment on the new socket if the new socket is active, ··· 950 951 sock_put(child); 951 952 return reason; 952 953 } 953 - EXPORT_SYMBOL(tcp_child_process); 954 + EXPORT_IPV6_MOD(tcp_child_process);
+6 -6
net/ipv4/tcp_output.c
··· 250 250 WRITE_ONCE(*__window_clamp, 251 251 min_t(__u32, U16_MAX << (*rcv_wscale), window_clamp)); 252 252 } 253 - EXPORT_SYMBOL(tcp_select_initial_window); 253 + EXPORT_IPV6_MOD(tcp_select_initial_window); 254 254 255 255 /* Chose a new window to advertise, update state in tcp_sock for the 256 256 * socket, and return result with RFC1323 scaling applied. The return ··· 1171 1171 if ((flags & TCPF_ACK_DEFERRED) && inet_csk_ack_scheduled(sk)) 1172 1172 tcp_send_ack(sk); 1173 1173 } 1174 - EXPORT_SYMBOL(tcp_release_cb); 1174 + EXPORT_IPV6_MOD(tcp_release_cb); 1175 1175 1176 1176 void __init tcp_tasklet_init(void) 1177 1177 { ··· 1783 1783 return __tcp_mtu_to_mss(sk, pmtu) - 1784 1784 (tcp_sk(sk)->tcp_header_len - sizeof(struct tcphdr)); 1785 1785 } 1786 - EXPORT_SYMBOL(tcp_mtu_to_mss); 1786 + EXPORT_IPV6_MOD(tcp_mtu_to_mss); 1787 1787 1788 1788 /* Inverse of above */ 1789 1789 int tcp_mss_to_mtu(struct sock *sk, int mss) ··· 1856 1856 1857 1857 return mss_now; 1858 1858 } 1859 - EXPORT_SYMBOL(tcp_sync_mss); 1859 + EXPORT_IPV6_MOD(tcp_sync_mss); 1860 1860 1861 1861 /* Compute the current effective MSS, taking SACKs and IP options, 1862 1862 * and even PMTU discovery events into account. ··· 3851 3851 3852 3852 return skb; 3853 3853 } 3854 - EXPORT_SYMBOL(tcp_make_synack); 3854 + EXPORT_IPV6_MOD(tcp_make_synack); 3855 3855 3856 3856 static void tcp_ca_dst_init(struct sock *sk, const struct dst_entry *dst) 3857 3857 { ··· 4428 4428 } 4429 4429 return res; 4430 4430 } 4431 - EXPORT_SYMBOL(tcp_rtx_synack); 4431 + EXPORT_IPV6_MOD(tcp_rtx_synack);
+2 -2
net/ipv4/tcp_timer.c
··· 750 750 751 751 __NET_INC_STATS(net, LINUX_MIB_TCPTIMEOUTS); 752 752 } 753 - EXPORT_SYMBOL(tcp_syn_ack_timeout); 753 + EXPORT_IPV6_MOD(tcp_syn_ack_timeout); 754 754 755 755 void tcp_reset_keepalive_timer(struct sock *sk, unsigned long len) 756 756 { ··· 772 772 else if (!val) 773 773 tcp_delete_keepalive_timer(sk); 774 774 } 775 - EXPORT_SYMBOL_GPL(tcp_set_keepalive); 775 + EXPORT_IPV6_MOD_GPL(tcp_set_keepalive); 776 776 777 777 static void tcp_keepalive_timer(struct timer_list *t) 778 778 {
+31 -32
net/ipv4/udp.c
··· 121 121 #endif 122 122 123 123 struct udp_table udp_table __read_mostly; 124 - EXPORT_SYMBOL(udp_table); 125 124 126 125 long sysctl_udp_mem[3] __read_mostly; 127 - EXPORT_SYMBOL(sysctl_udp_mem); 126 + EXPORT_IPV6_MOD(sysctl_udp_mem); 128 127 129 128 atomic_long_t udp_memory_allocated ____cacheline_aligned_in_smp; 130 - EXPORT_SYMBOL(udp_memory_allocated); 129 + EXPORT_IPV6_MOD(udp_memory_allocated); 131 130 DEFINE_PER_CPU(int, udp_memory_per_cpu_fw_alloc); 132 131 EXPORT_PER_CPU_SYMBOL_GPL(udp_memory_per_cpu_fw_alloc); 133 132 ··· 351 352 fail: 352 353 return error; 353 354 } 354 - EXPORT_SYMBOL(udp_lib_get_port); 355 + EXPORT_IPV6_MOD(udp_lib_get_port); 355 356 356 357 int udp_v4_get_port(struct sock *sk, unsigned short snum) 357 358 { ··· 417 418 return __inet_ehashfn(laddr, lport, faddr, fport, 418 419 udp_ehash_secret + net_hash_mix(net)); 419 420 } 420 - EXPORT_SYMBOL(udp_ehashfn); 421 + EXPORT_IPV6_MOD(udp_ehashfn); 421 422 422 423 /** 423 424 * udp4_lib_lookup1() - Simplified lookup using primary hash (destination port) ··· 652 653 653 654 spin_unlock_bh(&hslot->lock); 654 655 } 655 - EXPORT_SYMBOL(udp_lib_hash4); 656 + EXPORT_IPV6_MOD(udp_lib_hash4); 656 657 657 658 /* call with sock lock */ 658 659 void udp4_hash4(struct sock *sk) ··· 668 669 669 670 udp_lib_hash4(sk, hash); 670 671 } 671 - EXPORT_SYMBOL(udp4_hash4); 672 + EXPORT_IPV6_MOD(udp4_hash4); 672 673 #endif /* CONFIG_BASE_SMALL */ 673 674 674 675 /* UDP is nearly always wildcards out the wazoo, it makes no sense to try ··· 808 809 } 809 810 810 811 DEFINE_STATIC_KEY_FALSE(udp_encap_needed_key); 811 - EXPORT_SYMBOL(udp_encap_needed_key); 812 + EXPORT_IPV6_MOD(udp_encap_needed_key); 812 813 813 814 #if IS_ENABLED(CONFIG_IPV6) 814 815 DEFINE_STATIC_KEY_FALSE(udpv6_encap_needed_key); 815 - EXPORT_SYMBOL(udpv6_encap_needed_key); 816 + EXPORT_IPV6_MOD(udpv6_encap_needed_key); 816 817 #endif 817 818 818 819 void udp_encap_enable(void) ··· 1040 1041 ip_flush_pending_frames(sk); 1041 1042 } 1042 1043 } 1043 - EXPORT_SYMBOL(udp_flush_pending_frames); 1044 + EXPORT_IPV6_MOD(udp_flush_pending_frames); 1044 1045 1045 1046 /** 1046 1047 * udp4_hwcsum - handle outgoing HW checksumming ··· 1228 1229 WRITE_ONCE(up->pending, 0); 1229 1230 return err; 1230 1231 } 1231 - EXPORT_SYMBOL(udp_push_pending_frames); 1232 + EXPORT_IPV6_MOD(udp_push_pending_frames); 1232 1233 1233 1234 static int __udp_cmsg_send(struct cmsghdr *cmsg, u16 *gso_size) 1234 1235 { ··· 1265 1266 1266 1267 return need_ip; 1267 1268 } 1268 - EXPORT_SYMBOL_GPL(udp_cmsg_send); 1269 + EXPORT_IPV6_MOD_GPL(udp_cmsg_send); 1269 1270 1270 1271 int udp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) 1271 1272 { ··· 1560 1561 udp_push_pending_frames(sk); 1561 1562 release_sock(sk); 1562 1563 } 1563 - EXPORT_SYMBOL_GPL(udp_splice_eof); 1564 + EXPORT_IPV6_MOD_GPL(udp_splice_eof); 1564 1565 1565 1566 #define UDP_SKB_IS_STATELESS 0x80000000 1566 1567 ··· 1677 1678 prefetch(&skb->data); 1678 1679 udp_rmem_release(sk, udp_skb_truesize(skb), 1, false); 1679 1680 } 1680 - EXPORT_SYMBOL(udp_skb_destructor); 1681 + EXPORT_IPV6_MOD(udp_skb_destructor); 1681 1682 1682 1683 /* as above, but the caller held the rx queue lock, too */ 1683 1684 static void udp_skb_dtor_locked(struct sock *sk, struct sk_buff *skb) ··· 1784 1785 busylock_release(busy); 1785 1786 return err; 1786 1787 } 1787 - EXPORT_SYMBOL_GPL(__udp_enqueue_schedule_skb); 1788 + EXPORT_IPV6_MOD_GPL(__udp_enqueue_schedule_skb); 1788 1789 1789 1790 void udp_destruct_common(struct sock *sk) 1790 1791 { ··· 1800 1801 } 1801 1802 udp_rmem_release(sk, total, 0, true); 1802 1803 } 1803 - EXPORT_SYMBOL_GPL(udp_destruct_common); 1804 + EXPORT_IPV6_MOD_GPL(udp_destruct_common); 1804 1805 1805 1806 static void udp_destruct_sock(struct sock *sk) 1806 1807 { ··· 1831 1832 skb_release_head_state(skb); 1832 1833 __consume_stateless_skb(skb); 1833 1834 } 1834 - EXPORT_SYMBOL_GPL(skb_consume_udp); 1835 + EXPORT_IPV6_MOD_GPL(skb_consume_udp); 1835 1836 1836 1837 static struct sk_buff *__first_packet_length(struct sock *sk, 1837 1838 struct sk_buff_head *rcvq, ··· 1913 1914 1914 1915 return 0; 1915 1916 } 1916 - EXPORT_SYMBOL(udp_ioctl); 1917 + EXPORT_IPV6_MOD(udp_ioctl); 1917 1918 1918 1919 struct sk_buff *__skb_recv_udp(struct sock *sk, unsigned int flags, 1919 1920 int *off, int *err) ··· 2009 2010 WARN_ON_ONCE(!skb_set_owner_sk_safe(skb, sk)); 2010 2011 return recv_actor(sk, skb); 2011 2012 } 2012 - EXPORT_SYMBOL(udp_read_skb); 2013 + EXPORT_IPV6_MOD(udp_read_skb); 2013 2014 2014 2015 /* 2015 2016 * This should be easy, if there is something there we ··· 2136 2137 2137 2138 return BPF_CGROUP_RUN_PROG_INET4_CONNECT_LOCK(sk, uaddr, &addr_len); 2138 2139 } 2139 - EXPORT_SYMBOL(udp_pre_connect); 2140 + EXPORT_IPV6_MOD(udp_pre_connect); 2140 2141 2141 2142 static int udp_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) 2142 2143 { ··· 2185 2186 release_sock(sk); 2186 2187 return 0; 2187 2188 } 2188 - EXPORT_SYMBOL(udp_disconnect); 2189 + EXPORT_IPV6_MOD(udp_disconnect); 2189 2190 2190 2191 void udp_lib_unhash(struct sock *sk) 2191 2192 { ··· 2215 2216 spin_unlock_bh(&hslot->lock); 2216 2217 } 2217 2218 } 2218 - EXPORT_SYMBOL(udp_lib_unhash); 2219 + EXPORT_IPV6_MOD(udp_lib_unhash); 2219 2220 2220 2221 /* 2221 2222 * inet_rcv_saddr was changed, we must rehash secondary hash ··· 2279 2280 } 2280 2281 } 2281 2282 } 2282 - EXPORT_SYMBOL(udp_lib_rehash); 2283 + EXPORT_IPV6_MOD(udp_lib_rehash); 2283 2284 2284 2285 void udp_v4_rehash(struct sock *sk) 2285 2286 { ··· 2484 2485 } 2485 2486 return false; 2486 2487 } 2487 - EXPORT_SYMBOL(udp_sk_rx_dst_set); 2488 + EXPORT_IPV6_MOD(udp_sk_rx_dst_set); 2488 2489 2489 2490 /* 2490 2491 * Multicasts and broadcasts go to each listener. ··· 3040 3041 3041 3042 return err; 3042 3043 } 3043 - EXPORT_SYMBOL(udp_lib_setsockopt); 3044 + EXPORT_IPV6_MOD(udp_lib_setsockopt); 3044 3045 3045 3046 int udp_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval, 3046 3047 unsigned int optlen) ··· 3111 3112 return -EFAULT; 3112 3113 return 0; 3113 3114 } 3114 - EXPORT_SYMBOL(udp_lib_getsockopt); 3115 + EXPORT_IPV6_MOD(udp_lib_getsockopt); 3115 3116 3116 3117 int udp_getsockopt(struct sock *sk, int level, int optname, 3117 3118 char __user *optval, int __user *optlen) ··· 3153 3154 return mask; 3154 3155 3155 3156 } 3156 - EXPORT_SYMBOL(udp_poll); 3157 + EXPORT_IPV6_MOD(udp_poll); 3157 3158 3158 3159 int udp_abort(struct sock *sk, int err) 3159 3160 { ··· 3176 3177 3177 3178 return 0; 3178 3179 } 3179 - EXPORT_SYMBOL_GPL(udp_abort); 3180 + EXPORT_IPV6_MOD_GPL(udp_abort); 3180 3181 3181 3182 struct proto udp_prot = { 3182 3183 .name = "UDP", ··· 3310 3311 3311 3312 return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN; 3312 3313 } 3313 - EXPORT_SYMBOL(udp_seq_start); 3314 + EXPORT_IPV6_MOD(udp_seq_start); 3314 3315 3315 3316 void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos) 3316 3317 { ··· 3324 3325 ++*pos; 3325 3326 return sk; 3326 3327 } 3327 - EXPORT_SYMBOL(udp_seq_next); 3328 + EXPORT_IPV6_MOD(udp_seq_next); 3328 3329 3329 3330 void udp_seq_stop(struct seq_file *seq, void *v) 3330 3331 { ··· 3336 3337 if (state->bucket <= udptable->mask) 3337 3338 spin_unlock_bh(&udptable->hash[state->bucket].lock); 3338 3339 } 3339 - EXPORT_SYMBOL(udp_seq_stop); 3340 + EXPORT_IPV6_MOD(udp_seq_stop); 3340 3341 3341 3342 /* ------------------------------------------------------------------------ */ 3342 3343 static void udp4_format_sock(struct sock *sp, struct seq_file *f, ··· 3615 3616 .stop = udp_seq_stop, 3616 3617 .show = udp4_seq_show, 3617 3618 }; 3618 - EXPORT_SYMBOL(udp_seq_ops); 3619 + EXPORT_IPV6_MOD(udp_seq_ops); 3619 3620 3620 3621 static struct udp_seq_afinfo udp4_seq_afinfo = { 3621 3622 .family = AF_INET,