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 'convert-config_ipv6-to-built-in-and-remove-stubs'

Fernando Fernandez Mancera says:

====================
Convert CONFIG_IPV6 to built-in and remove stubs

Historically, the Linux kernel has supported compiling the IPv6 stack as
a loadable module. While this made sense in the early days of IPv6
adoption, modern deployments and distributions overwhelmingly either
build IPv6 directly into the kernel (CONFIG_IPV6=y) or disable it
entirely (CONFIG_IPV6=n). The modular IPv6 use-case offers image size
and memory savings for specific setups, this benefit is outweighed by
the architectural burden it imposes on the subsystems on implementation
and maintenance.

In addition, most of the distributions are already using CONFIG_IPV6=y
by default [1], including openWRT [2] and Android gki_defconfig [3]. So
this won't have an impact on them. The most impacted architecture would
probably be arm64 as their default config is still using CONFIG_IPV6=m.

To allow core networking, BPF, Netfilter, and various device drivers to
safely interact with a potentially unloaded IPv6 module, the kernel
relies on indirect call structures like ipv6_stub, ipv6_bpf_stub, and
nf_ipv6_ops, along with dynamic RCU registrations for things like ICMPv6
senders.

This patch series addresses this by changing CONFIG_IPV6 from a tristate
to a boolean, enforcing that IPv6 is either built-in or disabled. This
allows us to completely rip out the stub infrastructures and safely
replace them with direct function calls.

The bloat-o-meter report the following results for m68k, arm64, x86_64
defconfig.

m68k (keep on mind that CONFIG_IPV6 is disabled now):
add/remove: 65/938 grow/shrink: 36/254 up/down: 3022/-49692 (-46670)

arm64:
add/remove: 1251/265 grow/shrink: 81/46 up/down: 448740/-71519 (377221)

x86_64:
add/remove: 62/98 grow/shrink: 10/39 up/down: 2497/-4357 (-1860)

Considering that each new kernel release increases sizes by 30-40KiB on
average, this size increase isn't a huge jump for the distributions that
are still using CONFIG_IPV6=m. For the ones that are already using
CONFIG_IPV6=y, the size is reduced actually.

All the patches has been independently build tested. With allmodconfig
and allmodconfig + CONFIG_IPV6=n. In addition, net selftest has been run
against them on virtme-ng.

The series applied as a whole as been tested with allyesconfig and also
allyesconfig + CONFIG_IPV6=n but not all patches has been independently
tested this way.

[1] https://github.com/nyrahul/linux-kernel-configs

[2] https://github.com/openwrt/openwrt/commit/832e7b817221d288df76b763ca12c585365db5d8

[3] https://android.googlesource.com/kernel/common/+/refs/heads/android-mainline/arch/arm64/configs/gki_defconfig
====================

Link: https://patch.msgid.link/20260325120928.15848-1-fmancera@suse.de
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski e531a081 ced629dc

+296 -1397
+1 -1
arch/arm64/configs/defconfig
··· 140 140 CONFIG_IP_PNP=y 141 141 CONFIG_IP_PNP_DHCP=y 142 142 CONFIG_IP_PNP_BOOTP=y 143 - CONFIG_IPV6=m 143 + CONFIG_IPV6=y 144 144 CONFIG_NETFILTER=y 145 145 CONFIG_BRIDGE_NETFILTER=m 146 146 CONFIG_NF_CONNTRACK=m
+2 -42
arch/m68k/configs/amiga_defconfig
··· 72 72 CONFIG_INET_DIAG=m 73 73 CONFIG_INET_UDP_DIAG=m 74 74 CONFIG_INET_RAW_DIAG=m 75 - CONFIG_IPV6=m 76 - CONFIG_IPV6_ROUTER_PREF=y 77 - CONFIG_INET6_AH=m 78 - CONFIG_INET6_ESP=m 79 - CONFIG_INET6_ESP_OFFLOAD=m 80 - CONFIG_INET6_IPCOMP=m 81 - CONFIG_IPV6_ILA=m 82 - CONFIG_IPV6_VTI=m 83 - CONFIG_IPV6_GRE=m 75 + # CONFIG_IPV6 is not set 84 76 CONFIG_NETFILTER=y 85 77 CONFIG_NETFILTER_NETLINK_HOOK=m 86 78 CONFIG_NF_CONNTRACK=m ··· 88 96 CONFIG_NF_CONNTRACK_SIP=m 89 97 CONFIG_NF_CONNTRACK_TFTP=m 90 98 CONFIG_NF_TABLES=m 91 - CONFIG_NF_TABLES_INET=y 92 99 CONFIG_NF_TABLES_NETDEV=y 93 100 CONFIG_NFT_NUMGEN=m 94 101 CONFIG_NFT_CT=m ··· 104 113 CONFIG_NFT_REJECT=m 105 114 CONFIG_NFT_COMPAT=m 106 115 CONFIG_NFT_HASH=m 107 - CONFIG_NFT_FIB_INET=m 108 116 CONFIG_NFT_XFRM=m 109 117 CONFIG_NFT_SOCKET=m 110 118 CONFIG_NFT_OSF=m ··· 111 121 CONFIG_NFT_SYNPROXY=m 112 122 CONFIG_NFT_DUP_NETDEV=m 113 123 CONFIG_NFT_FWD_NETDEV=m 114 - CONFIG_NFT_FIB_NETDEV=m 115 - CONFIG_NFT_REJECT_NETDEV=m 116 124 CONFIG_NF_FLOW_TABLE_INET=m 117 125 CONFIG_NF_FLOW_TABLE=m 118 126 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 185 197 CONFIG_IP_SET_HASH_NETPORT=m 186 198 CONFIG_IP_SET_HASH_NETIFACE=m 187 199 CONFIG_IP_SET_LIST_SET=m 200 + CONFIG_NF_TABLES_IPV4=y 188 201 CONFIG_NFT_DUP_IPV4=m 189 202 CONFIG_NFT_FIB_IPV4=m 190 203 CONFIG_NF_TABLES_ARP=y ··· 207 218 CONFIG_IP_NF_RAW=m 208 219 CONFIG_IP_NF_ARPFILTER=m 209 220 CONFIG_IP_NF_ARP_MANGLE=m 210 - CONFIG_NFT_DUP_IPV6=m 211 - CONFIG_NFT_FIB_IPV6=m 212 - CONFIG_IP6_NF_IPTABLES=m 213 - CONFIG_IP6_NF_MATCH_AH=m 214 - CONFIG_IP6_NF_MATCH_EUI64=m 215 - CONFIG_IP6_NF_MATCH_FRAG=m 216 - CONFIG_IP6_NF_MATCH_OPTS=m 217 - CONFIG_IP6_NF_MATCH_HL=m 218 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 219 - CONFIG_IP6_NF_MATCH_MH=m 220 - CONFIG_IP6_NF_MATCH_RPFILTER=m 221 - CONFIG_IP6_NF_MATCH_RT=m 222 - CONFIG_IP6_NF_MATCH_SRH=m 223 - CONFIG_IP6_NF_TARGET_HL=m 224 - CONFIG_IP6_NF_TARGET_REJECT=m 225 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 226 - CONFIG_IP6_NF_RAW=m 227 - CONFIG_IP6_NF_NAT=m 228 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 229 - CONFIG_IP6_NF_TARGET_NPT=m 230 221 CONFIG_NF_TABLES_BRIDGE=m 231 222 CONFIG_NFT_BRIDGE_META=m 232 - CONFIG_NFT_BRIDGE_REJECT=m 233 223 CONFIG_NF_CONNTRACK_BRIDGE=m 234 224 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 235 225 CONFIG_BRIDGE_NF_EBTABLES=m ··· 219 251 CONFIG_BRIDGE_EBT_AMONG=m 220 252 CONFIG_BRIDGE_EBT_ARP=m 221 253 CONFIG_BRIDGE_EBT_IP=m 222 - CONFIG_BRIDGE_EBT_IP6=m 223 254 CONFIG_BRIDGE_EBT_LIMIT=m 224 255 CONFIG_BRIDGE_EBT_MARK=m 225 256 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 237 270 CONFIG_L2TP=m 238 271 CONFIG_BRIDGE=m 239 272 CONFIG_ATALK=m 240 - CONFIG_6LOWPAN=m 241 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 242 - CONFIG_6LOWPAN_GHC_UDP=m 243 - CONFIG_6LOWPAN_GHC_ICMPV6=m 244 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 245 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 246 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 247 273 CONFIG_DNS_RESOLVER=y 248 274 CONFIG_BATMAN_ADV=m 249 275 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/apollo_defconfig
··· 68 68 CONFIG_INET_DIAG=m 69 69 CONFIG_INET_UDP_DIAG=m 70 70 CONFIG_INET_RAW_DIAG=m 71 - CONFIG_IPV6=m 72 - CONFIG_IPV6_ROUTER_PREF=y 73 - CONFIG_INET6_AH=m 74 - CONFIG_INET6_ESP=m 75 - CONFIG_INET6_ESP_OFFLOAD=m 76 - CONFIG_INET6_IPCOMP=m 77 - CONFIG_IPV6_ILA=m 78 - CONFIG_IPV6_VTI=m 79 - CONFIG_IPV6_GRE=m 71 + # CONFIG_IPV6 is not set 80 72 CONFIG_NETFILTER=y 81 73 CONFIG_NETFILTER_NETLINK_HOOK=m 82 74 CONFIG_NF_CONNTRACK=m ··· 84 92 CONFIG_NF_CONNTRACK_SIP=m 85 93 CONFIG_NF_CONNTRACK_TFTP=m 86 94 CONFIG_NF_TABLES=m 87 - CONFIG_NF_TABLES_INET=y 88 95 CONFIG_NF_TABLES_NETDEV=y 89 96 CONFIG_NFT_NUMGEN=m 90 97 CONFIG_NFT_CT=m ··· 100 109 CONFIG_NFT_REJECT=m 101 110 CONFIG_NFT_COMPAT=m 102 111 CONFIG_NFT_HASH=m 103 - CONFIG_NFT_FIB_INET=m 104 112 CONFIG_NFT_XFRM=m 105 113 CONFIG_NFT_SOCKET=m 106 114 CONFIG_NFT_OSF=m ··· 107 117 CONFIG_NFT_SYNPROXY=m 108 118 CONFIG_NFT_DUP_NETDEV=m 109 119 CONFIG_NFT_FWD_NETDEV=m 110 - CONFIG_NFT_FIB_NETDEV=m 111 - CONFIG_NFT_REJECT_NETDEV=m 112 120 CONFIG_NF_FLOW_TABLE_INET=m 113 121 CONFIG_NF_FLOW_TABLE=m 114 122 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 181 193 CONFIG_IP_SET_HASH_NETPORT=m 182 194 CONFIG_IP_SET_HASH_NETIFACE=m 183 195 CONFIG_IP_SET_LIST_SET=m 196 + CONFIG_NF_TABLES_IPV4=y 184 197 CONFIG_NFT_DUP_IPV4=m 185 198 CONFIG_NFT_FIB_IPV4=m 186 199 CONFIG_NF_TABLES_ARP=y ··· 203 214 CONFIG_IP_NF_RAW=m 204 215 CONFIG_IP_NF_ARPFILTER=m 205 216 CONFIG_IP_NF_ARP_MANGLE=m 206 - CONFIG_NFT_DUP_IPV6=m 207 - CONFIG_NFT_FIB_IPV6=m 208 - CONFIG_IP6_NF_IPTABLES=m 209 - CONFIG_IP6_NF_MATCH_AH=m 210 - CONFIG_IP6_NF_MATCH_EUI64=m 211 - CONFIG_IP6_NF_MATCH_FRAG=m 212 - CONFIG_IP6_NF_MATCH_OPTS=m 213 - CONFIG_IP6_NF_MATCH_HL=m 214 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 215 - CONFIG_IP6_NF_MATCH_MH=m 216 - CONFIG_IP6_NF_MATCH_RPFILTER=m 217 - CONFIG_IP6_NF_MATCH_RT=m 218 - CONFIG_IP6_NF_MATCH_SRH=m 219 - CONFIG_IP6_NF_TARGET_HL=m 220 - CONFIG_IP6_NF_TARGET_REJECT=m 221 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 222 - CONFIG_IP6_NF_RAW=m 223 - CONFIG_IP6_NF_NAT=m 224 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 225 - CONFIG_IP6_NF_TARGET_NPT=m 226 217 CONFIG_NF_TABLES_BRIDGE=m 227 218 CONFIG_NFT_BRIDGE_META=m 228 - CONFIG_NFT_BRIDGE_REJECT=m 229 219 CONFIG_NF_CONNTRACK_BRIDGE=m 230 220 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 231 221 CONFIG_BRIDGE_NF_EBTABLES=m ··· 215 247 CONFIG_BRIDGE_EBT_AMONG=m 216 248 CONFIG_BRIDGE_EBT_ARP=m 217 249 CONFIG_BRIDGE_EBT_IP=m 218 - CONFIG_BRIDGE_EBT_IP6=m 219 250 CONFIG_BRIDGE_EBT_LIMIT=m 220 251 CONFIG_BRIDGE_EBT_MARK=m 221 252 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 233 266 CONFIG_L2TP=m 234 267 CONFIG_BRIDGE=m 235 268 CONFIG_ATALK=m 236 - CONFIG_6LOWPAN=m 237 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 238 - CONFIG_6LOWPAN_GHC_UDP=m 239 - CONFIG_6LOWPAN_GHC_ICMPV6=m 240 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 241 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 242 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 243 269 CONFIG_DNS_RESOLVER=y 244 270 CONFIG_BATMAN_ADV=m 245 271 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/atari_defconfig
··· 75 75 CONFIG_INET_DIAG=m 76 76 CONFIG_INET_UDP_DIAG=m 77 77 CONFIG_INET_RAW_DIAG=m 78 - CONFIG_IPV6=m 79 - CONFIG_IPV6_ROUTER_PREF=y 80 - CONFIG_INET6_AH=m 81 - CONFIG_INET6_ESP=m 82 - CONFIG_INET6_ESP_OFFLOAD=m 83 - CONFIG_INET6_IPCOMP=m 84 - CONFIG_IPV6_ILA=m 85 - CONFIG_IPV6_VTI=m 86 - CONFIG_IPV6_GRE=m 78 + # CONFIG_IPV6 is not set 87 79 CONFIG_NETFILTER=y 88 80 CONFIG_NETFILTER_NETLINK_HOOK=m 89 81 CONFIG_NF_CONNTRACK=m ··· 91 99 CONFIG_NF_CONNTRACK_SIP=m 92 100 CONFIG_NF_CONNTRACK_TFTP=m 93 101 CONFIG_NF_TABLES=m 94 - CONFIG_NF_TABLES_INET=y 95 102 CONFIG_NF_TABLES_NETDEV=y 96 103 CONFIG_NFT_NUMGEN=m 97 104 CONFIG_NFT_CT=m ··· 107 116 CONFIG_NFT_REJECT=m 108 117 CONFIG_NFT_COMPAT=m 109 118 CONFIG_NFT_HASH=m 110 - CONFIG_NFT_FIB_INET=m 111 119 CONFIG_NFT_XFRM=m 112 120 CONFIG_NFT_SOCKET=m 113 121 CONFIG_NFT_OSF=m ··· 114 124 CONFIG_NFT_SYNPROXY=m 115 125 CONFIG_NFT_DUP_NETDEV=m 116 126 CONFIG_NFT_FWD_NETDEV=m 117 - CONFIG_NFT_FIB_NETDEV=m 118 - CONFIG_NFT_REJECT_NETDEV=m 119 127 CONFIG_NF_FLOW_TABLE_INET=m 120 128 CONFIG_NF_FLOW_TABLE=m 121 129 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 188 200 CONFIG_IP_SET_HASH_NETPORT=m 189 201 CONFIG_IP_SET_HASH_NETIFACE=m 190 202 CONFIG_IP_SET_LIST_SET=m 203 + CONFIG_NF_TABLES_IPV4=y 191 204 CONFIG_NFT_DUP_IPV4=m 192 205 CONFIG_NFT_FIB_IPV4=m 193 206 CONFIG_NF_TABLES_ARP=y ··· 210 221 CONFIG_IP_NF_RAW=m 211 222 CONFIG_IP_NF_ARPFILTER=m 212 223 CONFIG_IP_NF_ARP_MANGLE=m 213 - CONFIG_NFT_DUP_IPV6=m 214 - CONFIG_NFT_FIB_IPV6=m 215 - CONFIG_IP6_NF_IPTABLES=m 216 - CONFIG_IP6_NF_MATCH_AH=m 217 - CONFIG_IP6_NF_MATCH_EUI64=m 218 - CONFIG_IP6_NF_MATCH_FRAG=m 219 - CONFIG_IP6_NF_MATCH_OPTS=m 220 - CONFIG_IP6_NF_MATCH_HL=m 221 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 222 - CONFIG_IP6_NF_MATCH_MH=m 223 - CONFIG_IP6_NF_MATCH_RPFILTER=m 224 - CONFIG_IP6_NF_MATCH_RT=m 225 - CONFIG_IP6_NF_MATCH_SRH=m 226 - CONFIG_IP6_NF_TARGET_HL=m 227 - CONFIG_IP6_NF_TARGET_REJECT=m 228 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 229 - CONFIG_IP6_NF_RAW=m 230 - CONFIG_IP6_NF_NAT=m 231 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 232 - CONFIG_IP6_NF_TARGET_NPT=m 233 224 CONFIG_NF_TABLES_BRIDGE=m 234 225 CONFIG_NFT_BRIDGE_META=m 235 - CONFIG_NFT_BRIDGE_REJECT=m 236 226 CONFIG_NF_CONNTRACK_BRIDGE=m 237 227 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 238 228 CONFIG_BRIDGE_NF_EBTABLES=m ··· 222 254 CONFIG_BRIDGE_EBT_AMONG=m 223 255 CONFIG_BRIDGE_EBT_ARP=m 224 256 CONFIG_BRIDGE_EBT_IP=m 225 - CONFIG_BRIDGE_EBT_IP6=m 226 257 CONFIG_BRIDGE_EBT_LIMIT=m 227 258 CONFIG_BRIDGE_EBT_MARK=m 228 259 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 240 273 CONFIG_L2TP=m 241 274 CONFIG_BRIDGE=m 242 275 CONFIG_ATALK=m 243 - CONFIG_6LOWPAN=m 244 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 245 - CONFIG_6LOWPAN_GHC_UDP=m 246 - CONFIG_6LOWPAN_GHC_ICMPV6=m 247 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 248 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 249 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 250 276 CONFIG_DNS_RESOLVER=y 251 277 CONFIG_BATMAN_ADV=m 252 278 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/bvme6000_defconfig
··· 65 65 CONFIG_INET_DIAG=m 66 66 CONFIG_INET_UDP_DIAG=m 67 67 CONFIG_INET_RAW_DIAG=m 68 - CONFIG_IPV6=m 69 - CONFIG_IPV6_ROUTER_PREF=y 70 - CONFIG_INET6_AH=m 71 - CONFIG_INET6_ESP=m 72 - CONFIG_INET6_ESP_OFFLOAD=m 73 - CONFIG_INET6_IPCOMP=m 74 - CONFIG_IPV6_ILA=m 75 - CONFIG_IPV6_VTI=m 76 - CONFIG_IPV6_GRE=m 68 + # CONFIG_IPV6 is not set 77 69 CONFIG_NETFILTER=y 78 70 CONFIG_NETFILTER_NETLINK_HOOK=m 79 71 CONFIG_NF_CONNTRACK=m ··· 81 89 CONFIG_NF_CONNTRACK_SIP=m 82 90 CONFIG_NF_CONNTRACK_TFTP=m 83 91 CONFIG_NF_TABLES=m 84 - CONFIG_NF_TABLES_INET=y 85 92 CONFIG_NF_TABLES_NETDEV=y 86 93 CONFIG_NFT_NUMGEN=m 87 94 CONFIG_NFT_CT=m ··· 97 106 CONFIG_NFT_REJECT=m 98 107 CONFIG_NFT_COMPAT=m 99 108 CONFIG_NFT_HASH=m 100 - CONFIG_NFT_FIB_INET=m 101 109 CONFIG_NFT_XFRM=m 102 110 CONFIG_NFT_SOCKET=m 103 111 CONFIG_NFT_OSF=m ··· 104 114 CONFIG_NFT_SYNPROXY=m 105 115 CONFIG_NFT_DUP_NETDEV=m 106 116 CONFIG_NFT_FWD_NETDEV=m 107 - CONFIG_NFT_FIB_NETDEV=m 108 - CONFIG_NFT_REJECT_NETDEV=m 109 117 CONFIG_NF_FLOW_TABLE_INET=m 110 118 CONFIG_NF_FLOW_TABLE=m 111 119 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 178 190 CONFIG_IP_SET_HASH_NETPORT=m 179 191 CONFIG_IP_SET_HASH_NETIFACE=m 180 192 CONFIG_IP_SET_LIST_SET=m 193 + CONFIG_NF_TABLES_IPV4=y 181 194 CONFIG_NFT_DUP_IPV4=m 182 195 CONFIG_NFT_FIB_IPV4=m 183 196 CONFIG_NF_TABLES_ARP=y ··· 200 211 CONFIG_IP_NF_RAW=m 201 212 CONFIG_IP_NF_ARPFILTER=m 202 213 CONFIG_IP_NF_ARP_MANGLE=m 203 - CONFIG_NFT_DUP_IPV6=m 204 - CONFIG_NFT_FIB_IPV6=m 205 - CONFIG_IP6_NF_IPTABLES=m 206 - CONFIG_IP6_NF_MATCH_AH=m 207 - CONFIG_IP6_NF_MATCH_EUI64=m 208 - CONFIG_IP6_NF_MATCH_FRAG=m 209 - CONFIG_IP6_NF_MATCH_OPTS=m 210 - CONFIG_IP6_NF_MATCH_HL=m 211 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 212 - CONFIG_IP6_NF_MATCH_MH=m 213 - CONFIG_IP6_NF_MATCH_RPFILTER=m 214 - CONFIG_IP6_NF_MATCH_RT=m 215 - CONFIG_IP6_NF_MATCH_SRH=m 216 - CONFIG_IP6_NF_TARGET_HL=m 217 - CONFIG_IP6_NF_TARGET_REJECT=m 218 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 219 - CONFIG_IP6_NF_RAW=m 220 - CONFIG_IP6_NF_NAT=m 221 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 222 - CONFIG_IP6_NF_TARGET_NPT=m 223 214 CONFIG_NF_TABLES_BRIDGE=m 224 215 CONFIG_NFT_BRIDGE_META=m 225 - CONFIG_NFT_BRIDGE_REJECT=m 226 216 CONFIG_NF_CONNTRACK_BRIDGE=m 227 217 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 228 218 CONFIG_BRIDGE_NF_EBTABLES=m ··· 212 244 CONFIG_BRIDGE_EBT_AMONG=m 213 245 CONFIG_BRIDGE_EBT_ARP=m 214 246 CONFIG_BRIDGE_EBT_IP=m 215 - CONFIG_BRIDGE_EBT_IP6=m 216 247 CONFIG_BRIDGE_EBT_LIMIT=m 217 248 CONFIG_BRIDGE_EBT_MARK=m 218 249 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 230 263 CONFIG_L2TP=m 231 264 CONFIG_BRIDGE=m 232 265 CONFIG_ATALK=m 233 - CONFIG_6LOWPAN=m 234 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 235 - CONFIG_6LOWPAN_GHC_UDP=m 236 - CONFIG_6LOWPAN_GHC_ICMPV6=m 237 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 238 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 239 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 240 266 CONFIG_DNS_RESOLVER=y 241 267 CONFIG_BATMAN_ADV=m 242 268 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/hp300_defconfig
··· 67 67 CONFIG_INET_DIAG=m 68 68 CONFIG_INET_UDP_DIAG=m 69 69 CONFIG_INET_RAW_DIAG=m 70 - CONFIG_IPV6=m 71 - CONFIG_IPV6_ROUTER_PREF=y 72 - CONFIG_INET6_AH=m 73 - CONFIG_INET6_ESP=m 74 - CONFIG_INET6_ESP_OFFLOAD=m 75 - CONFIG_INET6_IPCOMP=m 76 - CONFIG_IPV6_ILA=m 77 - CONFIG_IPV6_VTI=m 78 - CONFIG_IPV6_GRE=m 70 + # CONFIG_IPV6 is not set 79 71 CONFIG_NETFILTER=y 80 72 CONFIG_NETFILTER_NETLINK_HOOK=m 81 73 CONFIG_NF_CONNTRACK=m ··· 83 91 CONFIG_NF_CONNTRACK_SIP=m 84 92 CONFIG_NF_CONNTRACK_TFTP=m 85 93 CONFIG_NF_TABLES=m 86 - CONFIG_NF_TABLES_INET=y 87 94 CONFIG_NF_TABLES_NETDEV=y 88 95 CONFIG_NFT_NUMGEN=m 89 96 CONFIG_NFT_CT=m ··· 99 108 CONFIG_NFT_REJECT=m 100 109 CONFIG_NFT_COMPAT=m 101 110 CONFIG_NFT_HASH=m 102 - CONFIG_NFT_FIB_INET=m 103 111 CONFIG_NFT_XFRM=m 104 112 CONFIG_NFT_SOCKET=m 105 113 CONFIG_NFT_OSF=m ··· 106 116 CONFIG_NFT_SYNPROXY=m 107 117 CONFIG_NFT_DUP_NETDEV=m 108 118 CONFIG_NFT_FWD_NETDEV=m 109 - CONFIG_NFT_FIB_NETDEV=m 110 - CONFIG_NFT_REJECT_NETDEV=m 111 119 CONFIG_NF_FLOW_TABLE_INET=m 112 120 CONFIG_NF_FLOW_TABLE=m 113 121 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 180 192 CONFIG_IP_SET_HASH_NETPORT=m 181 193 CONFIG_IP_SET_HASH_NETIFACE=m 182 194 CONFIG_IP_SET_LIST_SET=m 195 + CONFIG_NF_TABLES_IPV4=y 183 196 CONFIG_NFT_DUP_IPV4=m 184 197 CONFIG_NFT_FIB_IPV4=m 185 198 CONFIG_NF_TABLES_ARP=y ··· 202 213 CONFIG_IP_NF_RAW=m 203 214 CONFIG_IP_NF_ARPFILTER=m 204 215 CONFIG_IP_NF_ARP_MANGLE=m 205 - CONFIG_NFT_DUP_IPV6=m 206 - CONFIG_NFT_FIB_IPV6=m 207 - CONFIG_IP6_NF_IPTABLES=m 208 - CONFIG_IP6_NF_MATCH_AH=m 209 - CONFIG_IP6_NF_MATCH_EUI64=m 210 - CONFIG_IP6_NF_MATCH_FRAG=m 211 - CONFIG_IP6_NF_MATCH_OPTS=m 212 - CONFIG_IP6_NF_MATCH_HL=m 213 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 214 - CONFIG_IP6_NF_MATCH_MH=m 215 - CONFIG_IP6_NF_MATCH_RPFILTER=m 216 - CONFIG_IP6_NF_MATCH_RT=m 217 - CONFIG_IP6_NF_MATCH_SRH=m 218 - CONFIG_IP6_NF_TARGET_HL=m 219 - CONFIG_IP6_NF_TARGET_REJECT=m 220 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 221 - CONFIG_IP6_NF_RAW=m 222 - CONFIG_IP6_NF_NAT=m 223 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 224 - CONFIG_IP6_NF_TARGET_NPT=m 225 216 CONFIG_NF_TABLES_BRIDGE=m 226 217 CONFIG_NFT_BRIDGE_META=m 227 - CONFIG_NFT_BRIDGE_REJECT=m 228 218 CONFIG_NF_CONNTRACK_BRIDGE=m 229 219 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 230 220 CONFIG_BRIDGE_NF_EBTABLES=m ··· 214 246 CONFIG_BRIDGE_EBT_AMONG=m 215 247 CONFIG_BRIDGE_EBT_ARP=m 216 248 CONFIG_BRIDGE_EBT_IP=m 217 - CONFIG_BRIDGE_EBT_IP6=m 218 249 CONFIG_BRIDGE_EBT_LIMIT=m 219 250 CONFIG_BRIDGE_EBT_MARK=m 220 251 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 232 265 CONFIG_L2TP=m 233 266 CONFIG_BRIDGE=m 234 267 CONFIG_ATALK=m 235 - CONFIG_6LOWPAN=m 236 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 237 - CONFIG_6LOWPAN_GHC_UDP=m 238 - CONFIG_6LOWPAN_GHC_ICMPV6=m 239 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 240 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 241 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 242 268 CONFIG_DNS_RESOLVER=y 243 269 CONFIG_BATMAN_ADV=m 244 270 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/mac_defconfig
··· 66 66 CONFIG_INET_DIAG=m 67 67 CONFIG_INET_UDP_DIAG=m 68 68 CONFIG_INET_RAW_DIAG=m 69 - CONFIG_IPV6=m 70 - CONFIG_IPV6_ROUTER_PREF=y 71 - CONFIG_INET6_AH=m 72 - CONFIG_INET6_ESP=m 73 - CONFIG_INET6_ESP_OFFLOAD=m 74 - CONFIG_INET6_IPCOMP=m 75 - CONFIG_IPV6_ILA=m 76 - CONFIG_IPV6_VTI=m 77 - CONFIG_IPV6_GRE=m 69 + # CONFIG_IPV6 is not set 78 70 CONFIG_NETFILTER=y 79 71 CONFIG_NETFILTER_NETLINK_HOOK=m 80 72 CONFIG_NF_CONNTRACK=m ··· 82 90 CONFIG_NF_CONNTRACK_SIP=m 83 91 CONFIG_NF_CONNTRACK_TFTP=m 84 92 CONFIG_NF_TABLES=m 85 - CONFIG_NF_TABLES_INET=y 86 93 CONFIG_NF_TABLES_NETDEV=y 87 94 CONFIG_NFT_NUMGEN=m 88 95 CONFIG_NFT_CT=m ··· 98 107 CONFIG_NFT_REJECT=m 99 108 CONFIG_NFT_COMPAT=m 100 109 CONFIG_NFT_HASH=m 101 - CONFIG_NFT_FIB_INET=m 102 110 CONFIG_NFT_XFRM=m 103 111 CONFIG_NFT_SOCKET=m 104 112 CONFIG_NFT_OSF=m ··· 105 115 CONFIG_NFT_SYNPROXY=m 106 116 CONFIG_NFT_DUP_NETDEV=m 107 117 CONFIG_NFT_FWD_NETDEV=m 108 - CONFIG_NFT_FIB_NETDEV=m 109 - CONFIG_NFT_REJECT_NETDEV=m 110 118 CONFIG_NF_FLOW_TABLE_INET=m 111 119 CONFIG_NF_FLOW_TABLE=m 112 120 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 179 191 CONFIG_IP_SET_HASH_NETPORT=m 180 192 CONFIG_IP_SET_HASH_NETIFACE=m 181 193 CONFIG_IP_SET_LIST_SET=m 194 + CONFIG_NF_TABLES_IPV4=y 182 195 CONFIG_NFT_DUP_IPV4=m 183 196 CONFIG_NFT_FIB_IPV4=m 184 197 CONFIG_NF_TABLES_ARP=y ··· 201 212 CONFIG_IP_NF_RAW=m 202 213 CONFIG_IP_NF_ARPFILTER=m 203 214 CONFIG_IP_NF_ARP_MANGLE=m 204 - CONFIG_NFT_DUP_IPV6=m 205 - CONFIG_NFT_FIB_IPV6=m 206 - CONFIG_IP6_NF_IPTABLES=m 207 - CONFIG_IP6_NF_MATCH_AH=m 208 - CONFIG_IP6_NF_MATCH_EUI64=m 209 - CONFIG_IP6_NF_MATCH_FRAG=m 210 - CONFIG_IP6_NF_MATCH_OPTS=m 211 - CONFIG_IP6_NF_MATCH_HL=m 212 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 213 - CONFIG_IP6_NF_MATCH_MH=m 214 - CONFIG_IP6_NF_MATCH_RPFILTER=m 215 - CONFIG_IP6_NF_MATCH_RT=m 216 - CONFIG_IP6_NF_MATCH_SRH=m 217 - CONFIG_IP6_NF_TARGET_HL=m 218 - CONFIG_IP6_NF_TARGET_REJECT=m 219 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 220 - CONFIG_IP6_NF_RAW=m 221 - CONFIG_IP6_NF_NAT=m 222 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 223 - CONFIG_IP6_NF_TARGET_NPT=m 224 215 CONFIG_NF_TABLES_BRIDGE=m 225 216 CONFIG_NFT_BRIDGE_META=m 226 - CONFIG_NFT_BRIDGE_REJECT=m 227 217 CONFIG_NF_CONNTRACK_BRIDGE=m 228 218 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 229 219 CONFIG_BRIDGE_NF_EBTABLES=m ··· 213 245 CONFIG_BRIDGE_EBT_AMONG=m 214 246 CONFIG_BRIDGE_EBT_ARP=m 215 247 CONFIG_BRIDGE_EBT_IP=m 216 - CONFIG_BRIDGE_EBT_IP6=m 217 248 CONFIG_BRIDGE_EBT_LIMIT=m 218 249 CONFIG_BRIDGE_EBT_MARK=m 219 250 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 231 264 CONFIG_L2TP=m 232 265 CONFIG_BRIDGE=m 233 266 CONFIG_ATALK=m 234 - CONFIG_6LOWPAN=m 235 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 236 - CONFIG_6LOWPAN_GHC_UDP=m 237 - CONFIG_6LOWPAN_GHC_ICMPV6=m 238 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 239 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 240 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 241 267 CONFIG_DNS_RESOLVER=y 242 268 CONFIG_BATMAN_ADV=m 243 269 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/multi_defconfig
··· 86 86 CONFIG_INET_DIAG=m 87 87 CONFIG_INET_UDP_DIAG=m 88 88 CONFIG_INET_RAW_DIAG=m 89 - CONFIG_IPV6=m 90 - CONFIG_IPV6_ROUTER_PREF=y 91 - CONFIG_INET6_AH=m 92 - CONFIG_INET6_ESP=m 93 - CONFIG_INET6_ESP_OFFLOAD=m 94 - CONFIG_INET6_IPCOMP=m 95 - CONFIG_IPV6_ILA=m 96 - CONFIG_IPV6_VTI=m 97 - CONFIG_IPV6_GRE=m 89 + # CONFIG_IPV6 is not set 98 90 CONFIG_NETFILTER=y 99 91 CONFIG_NETFILTER_NETLINK_HOOK=m 100 92 CONFIG_NF_CONNTRACK=m ··· 102 110 CONFIG_NF_CONNTRACK_SIP=m 103 111 CONFIG_NF_CONNTRACK_TFTP=m 104 112 CONFIG_NF_TABLES=m 105 - CONFIG_NF_TABLES_INET=y 106 113 CONFIG_NF_TABLES_NETDEV=y 107 114 CONFIG_NFT_NUMGEN=m 108 115 CONFIG_NFT_CT=m ··· 118 127 CONFIG_NFT_REJECT=m 119 128 CONFIG_NFT_COMPAT=m 120 129 CONFIG_NFT_HASH=m 121 - CONFIG_NFT_FIB_INET=m 122 130 CONFIG_NFT_XFRM=m 123 131 CONFIG_NFT_SOCKET=m 124 132 CONFIG_NFT_OSF=m ··· 125 135 CONFIG_NFT_SYNPROXY=m 126 136 CONFIG_NFT_DUP_NETDEV=m 127 137 CONFIG_NFT_FWD_NETDEV=m 128 - CONFIG_NFT_FIB_NETDEV=m 129 - CONFIG_NFT_REJECT_NETDEV=m 130 138 CONFIG_NF_FLOW_TABLE_INET=m 131 139 CONFIG_NF_FLOW_TABLE=m 132 140 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 199 211 CONFIG_IP_SET_HASH_NETPORT=m 200 212 CONFIG_IP_SET_HASH_NETIFACE=m 201 213 CONFIG_IP_SET_LIST_SET=m 214 + CONFIG_NF_TABLES_IPV4=y 202 215 CONFIG_NFT_DUP_IPV4=m 203 216 CONFIG_NFT_FIB_IPV4=m 204 217 CONFIG_NF_TABLES_ARP=y ··· 221 232 CONFIG_IP_NF_RAW=m 222 233 CONFIG_IP_NF_ARPFILTER=m 223 234 CONFIG_IP_NF_ARP_MANGLE=m 224 - CONFIG_NFT_DUP_IPV6=m 225 - CONFIG_NFT_FIB_IPV6=m 226 - CONFIG_IP6_NF_IPTABLES=m 227 - CONFIG_IP6_NF_MATCH_AH=m 228 - CONFIG_IP6_NF_MATCH_EUI64=m 229 - CONFIG_IP6_NF_MATCH_FRAG=m 230 - CONFIG_IP6_NF_MATCH_OPTS=m 231 - CONFIG_IP6_NF_MATCH_HL=m 232 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 233 - CONFIG_IP6_NF_MATCH_MH=m 234 - CONFIG_IP6_NF_MATCH_RPFILTER=m 235 - CONFIG_IP6_NF_MATCH_RT=m 236 - CONFIG_IP6_NF_MATCH_SRH=m 237 - CONFIG_IP6_NF_TARGET_HL=m 238 - CONFIG_IP6_NF_TARGET_REJECT=m 239 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 240 - CONFIG_IP6_NF_RAW=m 241 - CONFIG_IP6_NF_NAT=m 242 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 243 - CONFIG_IP6_NF_TARGET_NPT=m 244 235 CONFIG_NF_TABLES_BRIDGE=m 245 236 CONFIG_NFT_BRIDGE_META=m 246 - CONFIG_NFT_BRIDGE_REJECT=m 247 237 CONFIG_NF_CONNTRACK_BRIDGE=m 248 238 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 249 239 CONFIG_BRIDGE_NF_EBTABLES=m ··· 233 265 CONFIG_BRIDGE_EBT_AMONG=m 234 266 CONFIG_BRIDGE_EBT_ARP=m 235 267 CONFIG_BRIDGE_EBT_IP=m 236 - CONFIG_BRIDGE_EBT_IP6=m 237 268 CONFIG_BRIDGE_EBT_LIMIT=m 238 269 CONFIG_BRIDGE_EBT_MARK=m 239 270 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 251 284 CONFIG_L2TP=m 252 285 CONFIG_BRIDGE=m 253 286 CONFIG_ATALK=m 254 - CONFIG_6LOWPAN=m 255 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 256 - CONFIG_6LOWPAN_GHC_UDP=m 257 - CONFIG_6LOWPAN_GHC_ICMPV6=m 258 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 259 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 260 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 261 287 CONFIG_DNS_RESOLVER=y 262 288 CONFIG_BATMAN_ADV=m 263 289 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/mvme147_defconfig
··· 64 64 CONFIG_INET_DIAG=m 65 65 CONFIG_INET_UDP_DIAG=m 66 66 CONFIG_INET_RAW_DIAG=m 67 - CONFIG_IPV6=m 68 - CONFIG_IPV6_ROUTER_PREF=y 69 - CONFIG_INET6_AH=m 70 - CONFIG_INET6_ESP=m 71 - CONFIG_INET6_ESP_OFFLOAD=m 72 - CONFIG_INET6_IPCOMP=m 73 - CONFIG_IPV6_ILA=m 74 - CONFIG_IPV6_VTI=m 75 - CONFIG_IPV6_GRE=m 67 + # CONFIG_IPV6 is not set 76 68 CONFIG_NETFILTER=y 77 69 CONFIG_NETFILTER_NETLINK_HOOK=m 78 70 CONFIG_NF_CONNTRACK=m ··· 80 88 CONFIG_NF_CONNTRACK_SIP=m 81 89 CONFIG_NF_CONNTRACK_TFTP=m 82 90 CONFIG_NF_TABLES=m 83 - CONFIG_NF_TABLES_INET=y 84 91 CONFIG_NF_TABLES_NETDEV=y 85 92 CONFIG_NFT_NUMGEN=m 86 93 CONFIG_NFT_CT=m ··· 96 105 CONFIG_NFT_REJECT=m 97 106 CONFIG_NFT_COMPAT=m 98 107 CONFIG_NFT_HASH=m 99 - CONFIG_NFT_FIB_INET=m 100 108 CONFIG_NFT_XFRM=m 101 109 CONFIG_NFT_SOCKET=m 102 110 CONFIG_NFT_OSF=m ··· 103 113 CONFIG_NFT_SYNPROXY=m 104 114 CONFIG_NFT_DUP_NETDEV=m 105 115 CONFIG_NFT_FWD_NETDEV=m 106 - CONFIG_NFT_FIB_NETDEV=m 107 - CONFIG_NFT_REJECT_NETDEV=m 108 116 CONFIG_NF_FLOW_TABLE_INET=m 109 117 CONFIG_NF_FLOW_TABLE=m 110 118 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 177 189 CONFIG_IP_SET_HASH_NETPORT=m 178 190 CONFIG_IP_SET_HASH_NETIFACE=m 179 191 CONFIG_IP_SET_LIST_SET=m 192 + CONFIG_NF_TABLES_IPV4=y 180 193 CONFIG_NFT_DUP_IPV4=m 181 194 CONFIG_NFT_FIB_IPV4=m 182 195 CONFIG_NF_TABLES_ARP=y ··· 199 210 CONFIG_IP_NF_RAW=m 200 211 CONFIG_IP_NF_ARPFILTER=m 201 212 CONFIG_IP_NF_ARP_MANGLE=m 202 - CONFIG_NFT_DUP_IPV6=m 203 - CONFIG_NFT_FIB_IPV6=m 204 - CONFIG_IP6_NF_IPTABLES=m 205 - CONFIG_IP6_NF_MATCH_AH=m 206 - CONFIG_IP6_NF_MATCH_EUI64=m 207 - CONFIG_IP6_NF_MATCH_FRAG=m 208 - CONFIG_IP6_NF_MATCH_OPTS=m 209 - CONFIG_IP6_NF_MATCH_HL=m 210 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 211 - CONFIG_IP6_NF_MATCH_MH=m 212 - CONFIG_IP6_NF_MATCH_RPFILTER=m 213 - CONFIG_IP6_NF_MATCH_RT=m 214 - CONFIG_IP6_NF_MATCH_SRH=m 215 - CONFIG_IP6_NF_TARGET_HL=m 216 - CONFIG_IP6_NF_TARGET_REJECT=m 217 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 218 - CONFIG_IP6_NF_RAW=m 219 - CONFIG_IP6_NF_NAT=m 220 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 221 - CONFIG_IP6_NF_TARGET_NPT=m 222 213 CONFIG_NF_TABLES_BRIDGE=m 223 214 CONFIG_NFT_BRIDGE_META=m 224 - CONFIG_NFT_BRIDGE_REJECT=m 225 215 CONFIG_NF_CONNTRACK_BRIDGE=m 226 216 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 227 217 CONFIG_BRIDGE_NF_EBTABLES=m ··· 211 243 CONFIG_BRIDGE_EBT_AMONG=m 212 244 CONFIG_BRIDGE_EBT_ARP=m 213 245 CONFIG_BRIDGE_EBT_IP=m 214 - CONFIG_BRIDGE_EBT_IP6=m 215 246 CONFIG_BRIDGE_EBT_LIMIT=m 216 247 CONFIG_BRIDGE_EBT_MARK=m 217 248 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 229 262 CONFIG_L2TP=m 230 263 CONFIG_BRIDGE=m 231 264 CONFIG_ATALK=m 232 - CONFIG_6LOWPAN=m 233 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 234 - CONFIG_6LOWPAN_GHC_UDP=m 235 - CONFIG_6LOWPAN_GHC_ICMPV6=m 236 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 237 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 238 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 239 265 CONFIG_DNS_RESOLVER=y 240 266 CONFIG_BATMAN_ADV=m 241 267 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/mvme16x_defconfig
··· 65 65 CONFIG_INET_DIAG=m 66 66 CONFIG_INET_UDP_DIAG=m 67 67 CONFIG_INET_RAW_DIAG=m 68 - CONFIG_IPV6=m 69 - CONFIG_IPV6_ROUTER_PREF=y 70 - CONFIG_INET6_AH=m 71 - CONFIG_INET6_ESP=m 72 - CONFIG_INET6_ESP_OFFLOAD=m 73 - CONFIG_INET6_IPCOMP=m 74 - CONFIG_IPV6_ILA=m 75 - CONFIG_IPV6_VTI=m 76 - CONFIG_IPV6_GRE=m 68 + # CONFIG_IPV6 is not set 77 69 CONFIG_NETFILTER=y 78 70 CONFIG_NETFILTER_NETLINK_HOOK=m 79 71 CONFIG_NF_CONNTRACK=m ··· 81 89 CONFIG_NF_CONNTRACK_SIP=m 82 90 CONFIG_NF_CONNTRACK_TFTP=m 83 91 CONFIG_NF_TABLES=m 84 - CONFIG_NF_TABLES_INET=y 85 92 CONFIG_NF_TABLES_NETDEV=y 86 93 CONFIG_NFT_NUMGEN=m 87 94 CONFIG_NFT_CT=m ··· 97 106 CONFIG_NFT_REJECT=m 98 107 CONFIG_NFT_COMPAT=m 99 108 CONFIG_NFT_HASH=m 100 - CONFIG_NFT_FIB_INET=m 101 109 CONFIG_NFT_XFRM=m 102 110 CONFIG_NFT_SOCKET=m 103 111 CONFIG_NFT_OSF=m ··· 104 114 CONFIG_NFT_SYNPROXY=m 105 115 CONFIG_NFT_DUP_NETDEV=m 106 116 CONFIG_NFT_FWD_NETDEV=m 107 - CONFIG_NFT_FIB_NETDEV=m 108 - CONFIG_NFT_REJECT_NETDEV=m 109 117 CONFIG_NF_FLOW_TABLE_INET=m 110 118 CONFIG_NF_FLOW_TABLE=m 111 119 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 178 190 CONFIG_IP_SET_HASH_NETPORT=m 179 191 CONFIG_IP_SET_HASH_NETIFACE=m 180 192 CONFIG_IP_SET_LIST_SET=m 193 + CONFIG_NF_TABLES_IPV4=y 181 194 CONFIG_NFT_DUP_IPV4=m 182 195 CONFIG_NFT_FIB_IPV4=m 183 196 CONFIG_NF_TABLES_ARP=y ··· 200 211 CONFIG_IP_NF_RAW=m 201 212 CONFIG_IP_NF_ARPFILTER=m 202 213 CONFIG_IP_NF_ARP_MANGLE=m 203 - CONFIG_NFT_DUP_IPV6=m 204 - CONFIG_NFT_FIB_IPV6=m 205 - CONFIG_IP6_NF_IPTABLES=m 206 - CONFIG_IP6_NF_MATCH_AH=m 207 - CONFIG_IP6_NF_MATCH_EUI64=m 208 - CONFIG_IP6_NF_MATCH_FRAG=m 209 - CONFIG_IP6_NF_MATCH_OPTS=m 210 - CONFIG_IP6_NF_MATCH_HL=m 211 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 212 - CONFIG_IP6_NF_MATCH_MH=m 213 - CONFIG_IP6_NF_MATCH_RPFILTER=m 214 - CONFIG_IP6_NF_MATCH_RT=m 215 - CONFIG_IP6_NF_MATCH_SRH=m 216 - CONFIG_IP6_NF_TARGET_HL=m 217 - CONFIG_IP6_NF_TARGET_REJECT=m 218 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 219 - CONFIG_IP6_NF_RAW=m 220 - CONFIG_IP6_NF_NAT=m 221 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 222 - CONFIG_IP6_NF_TARGET_NPT=m 223 214 CONFIG_NF_TABLES_BRIDGE=m 224 215 CONFIG_NFT_BRIDGE_META=m 225 - CONFIG_NFT_BRIDGE_REJECT=m 226 216 CONFIG_NF_CONNTRACK_BRIDGE=m 227 217 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 228 218 CONFIG_BRIDGE_NF_EBTABLES=m ··· 212 244 CONFIG_BRIDGE_EBT_AMONG=m 213 245 CONFIG_BRIDGE_EBT_ARP=m 214 246 CONFIG_BRIDGE_EBT_IP=m 215 - CONFIG_BRIDGE_EBT_IP6=m 216 247 CONFIG_BRIDGE_EBT_LIMIT=m 217 248 CONFIG_BRIDGE_EBT_MARK=m 218 249 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 230 263 CONFIG_L2TP=m 231 264 CONFIG_BRIDGE=m 232 265 CONFIG_ATALK=m 233 - CONFIG_6LOWPAN=m 234 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 235 - CONFIG_6LOWPAN_GHC_UDP=m 236 - CONFIG_6LOWPAN_GHC_ICMPV6=m 237 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 238 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 239 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 240 266 CONFIG_DNS_RESOLVER=y 241 267 CONFIG_BATMAN_ADV=m 242 268 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/q40_defconfig
··· 66 66 CONFIG_INET_DIAG=m 67 67 CONFIG_INET_UDP_DIAG=m 68 68 CONFIG_INET_RAW_DIAG=m 69 - CONFIG_IPV6=m 70 - CONFIG_IPV6_ROUTER_PREF=y 71 - CONFIG_INET6_AH=m 72 - CONFIG_INET6_ESP=m 73 - CONFIG_INET6_ESP_OFFLOAD=m 74 - CONFIG_INET6_IPCOMP=m 75 - CONFIG_IPV6_ILA=m 76 - CONFIG_IPV6_VTI=m 77 - CONFIG_IPV6_GRE=m 69 + # CONFIG_IPV6 is not set 78 70 CONFIG_NETFILTER=y 79 71 CONFIG_NETFILTER_NETLINK_HOOK=m 80 72 CONFIG_NF_CONNTRACK=m ··· 82 90 CONFIG_NF_CONNTRACK_SIP=m 83 91 CONFIG_NF_CONNTRACK_TFTP=m 84 92 CONFIG_NF_TABLES=m 85 - CONFIG_NF_TABLES_INET=y 86 93 CONFIG_NF_TABLES_NETDEV=y 87 94 CONFIG_NFT_NUMGEN=m 88 95 CONFIG_NFT_CT=m ··· 98 107 CONFIG_NFT_REJECT=m 99 108 CONFIG_NFT_COMPAT=m 100 109 CONFIG_NFT_HASH=m 101 - CONFIG_NFT_FIB_INET=m 102 110 CONFIG_NFT_XFRM=m 103 111 CONFIG_NFT_SOCKET=m 104 112 CONFIG_NFT_OSF=m ··· 105 115 CONFIG_NFT_SYNPROXY=m 106 116 CONFIG_NFT_DUP_NETDEV=m 107 117 CONFIG_NFT_FWD_NETDEV=m 108 - CONFIG_NFT_FIB_NETDEV=m 109 - CONFIG_NFT_REJECT_NETDEV=m 110 118 CONFIG_NF_FLOW_TABLE_INET=m 111 119 CONFIG_NF_FLOW_TABLE=m 112 120 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 179 191 CONFIG_IP_SET_HASH_NETPORT=m 180 192 CONFIG_IP_SET_HASH_NETIFACE=m 181 193 CONFIG_IP_SET_LIST_SET=m 194 + CONFIG_NF_TABLES_IPV4=y 182 195 CONFIG_NFT_DUP_IPV4=m 183 196 CONFIG_NFT_FIB_IPV4=m 184 197 CONFIG_NF_TABLES_ARP=y ··· 201 212 CONFIG_IP_NF_RAW=m 202 213 CONFIG_IP_NF_ARPFILTER=m 203 214 CONFIG_IP_NF_ARP_MANGLE=m 204 - CONFIG_NFT_DUP_IPV6=m 205 - CONFIG_NFT_FIB_IPV6=m 206 - CONFIG_IP6_NF_IPTABLES=m 207 - CONFIG_IP6_NF_MATCH_AH=m 208 - CONFIG_IP6_NF_MATCH_EUI64=m 209 - CONFIG_IP6_NF_MATCH_FRAG=m 210 - CONFIG_IP6_NF_MATCH_OPTS=m 211 - CONFIG_IP6_NF_MATCH_HL=m 212 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 213 - CONFIG_IP6_NF_MATCH_MH=m 214 - CONFIG_IP6_NF_MATCH_RPFILTER=m 215 - CONFIG_IP6_NF_MATCH_RT=m 216 - CONFIG_IP6_NF_MATCH_SRH=m 217 - CONFIG_IP6_NF_TARGET_HL=m 218 - CONFIG_IP6_NF_TARGET_REJECT=m 219 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 220 - CONFIG_IP6_NF_RAW=m 221 - CONFIG_IP6_NF_NAT=m 222 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 223 - CONFIG_IP6_NF_TARGET_NPT=m 224 215 CONFIG_NF_TABLES_BRIDGE=m 225 216 CONFIG_NFT_BRIDGE_META=m 226 - CONFIG_NFT_BRIDGE_REJECT=m 227 217 CONFIG_NF_CONNTRACK_BRIDGE=m 228 218 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 229 219 CONFIG_BRIDGE_NF_EBTABLES=m ··· 213 245 CONFIG_BRIDGE_EBT_AMONG=m 214 246 CONFIG_BRIDGE_EBT_ARP=m 215 247 CONFIG_BRIDGE_EBT_IP=m 216 - CONFIG_BRIDGE_EBT_IP6=m 217 248 CONFIG_BRIDGE_EBT_LIMIT=m 218 249 CONFIG_BRIDGE_EBT_MARK=m 219 250 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 231 264 CONFIG_L2TP=m 232 265 CONFIG_BRIDGE=m 233 266 CONFIG_ATALK=m 234 - CONFIG_6LOWPAN=m 235 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 236 - CONFIG_6LOWPAN_GHC_UDP=m 237 - CONFIG_6LOWPAN_GHC_ICMPV6=m 238 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 239 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 240 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 241 267 CONFIG_DNS_RESOLVER=y 242 268 CONFIG_BATMAN_ADV=m 243 269 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/sun3_defconfig
··· 61 61 CONFIG_INET_DIAG=m 62 62 CONFIG_INET_UDP_DIAG=m 63 63 CONFIG_INET_RAW_DIAG=m 64 - CONFIG_IPV6=m 65 - CONFIG_IPV6_ROUTER_PREF=y 66 - CONFIG_INET6_AH=m 67 - CONFIG_INET6_ESP=m 68 - CONFIG_INET6_ESP_OFFLOAD=m 69 - CONFIG_INET6_IPCOMP=m 70 - CONFIG_IPV6_ILA=m 71 - CONFIG_IPV6_VTI=m 72 - CONFIG_IPV6_GRE=m 64 + # CONFIG_IPV6 is not set 73 65 CONFIG_NETFILTER=y 74 66 CONFIG_NETFILTER_NETLINK_HOOK=m 75 67 CONFIG_NF_CONNTRACK=m ··· 77 85 CONFIG_NF_CONNTRACK_SIP=m 78 86 CONFIG_NF_CONNTRACK_TFTP=m 79 87 CONFIG_NF_TABLES=m 80 - CONFIG_NF_TABLES_INET=y 81 88 CONFIG_NF_TABLES_NETDEV=y 82 89 CONFIG_NFT_NUMGEN=m 83 90 CONFIG_NFT_CT=m ··· 93 102 CONFIG_NFT_REJECT=m 94 103 CONFIG_NFT_COMPAT=m 95 104 CONFIG_NFT_HASH=m 96 - CONFIG_NFT_FIB_INET=m 97 105 CONFIG_NFT_XFRM=m 98 106 CONFIG_NFT_SOCKET=m 99 107 CONFIG_NFT_OSF=m ··· 100 110 CONFIG_NFT_SYNPROXY=m 101 111 CONFIG_NFT_DUP_NETDEV=m 102 112 CONFIG_NFT_FWD_NETDEV=m 103 - CONFIG_NFT_FIB_NETDEV=m 104 - CONFIG_NFT_REJECT_NETDEV=m 105 113 CONFIG_NF_FLOW_TABLE_INET=m 106 114 CONFIG_NF_FLOW_TABLE=m 107 115 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 174 186 CONFIG_IP_SET_HASH_NETPORT=m 175 187 CONFIG_IP_SET_HASH_NETIFACE=m 176 188 CONFIG_IP_SET_LIST_SET=m 189 + CONFIG_NF_TABLES_IPV4=y 177 190 CONFIG_NFT_DUP_IPV4=m 178 191 CONFIG_NFT_FIB_IPV4=m 179 192 CONFIG_NF_TABLES_ARP=y ··· 196 207 CONFIG_IP_NF_RAW=m 197 208 CONFIG_IP_NF_ARPFILTER=m 198 209 CONFIG_IP_NF_ARP_MANGLE=m 199 - CONFIG_NFT_DUP_IPV6=m 200 - CONFIG_NFT_FIB_IPV6=m 201 - CONFIG_IP6_NF_IPTABLES=m 202 - CONFIG_IP6_NF_MATCH_AH=m 203 - CONFIG_IP6_NF_MATCH_EUI64=m 204 - CONFIG_IP6_NF_MATCH_FRAG=m 205 - CONFIG_IP6_NF_MATCH_OPTS=m 206 - CONFIG_IP6_NF_MATCH_HL=m 207 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 208 - CONFIG_IP6_NF_MATCH_MH=m 209 - CONFIG_IP6_NF_MATCH_RPFILTER=m 210 - CONFIG_IP6_NF_MATCH_RT=m 211 - CONFIG_IP6_NF_MATCH_SRH=m 212 - CONFIG_IP6_NF_TARGET_HL=m 213 - CONFIG_IP6_NF_TARGET_REJECT=m 214 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 215 - CONFIG_IP6_NF_RAW=m 216 - CONFIG_IP6_NF_NAT=m 217 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 218 - CONFIG_IP6_NF_TARGET_NPT=m 219 210 CONFIG_NF_TABLES_BRIDGE=m 220 211 CONFIG_NFT_BRIDGE_META=m 221 - CONFIG_NFT_BRIDGE_REJECT=m 222 212 CONFIG_NF_CONNTRACK_BRIDGE=m 223 213 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 224 214 CONFIG_BRIDGE_NF_EBTABLES=m ··· 208 240 CONFIG_BRIDGE_EBT_AMONG=m 209 241 CONFIG_BRIDGE_EBT_ARP=m 210 242 CONFIG_BRIDGE_EBT_IP=m 211 - CONFIG_BRIDGE_EBT_IP6=m 212 243 CONFIG_BRIDGE_EBT_LIMIT=m 213 244 CONFIG_BRIDGE_EBT_MARK=m 214 245 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 226 259 CONFIG_L2TP=m 227 260 CONFIG_BRIDGE=m 228 261 CONFIG_ATALK=m 229 - CONFIG_6LOWPAN=m 230 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 231 - CONFIG_6LOWPAN_GHC_UDP=m 232 - CONFIG_6LOWPAN_GHC_ICMPV6=m 233 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 234 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 235 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 236 262 CONFIG_DNS_RESOLVER=y 237 263 CONFIG_BATMAN_ADV=m 238 264 # CONFIG_BATMAN_ADV_BATMAN_V is not set
+2 -42
arch/m68k/configs/sun3x_defconfig
··· 62 62 CONFIG_INET_DIAG=m 63 63 CONFIG_INET_UDP_DIAG=m 64 64 CONFIG_INET_RAW_DIAG=m 65 - CONFIG_IPV6=m 66 - CONFIG_IPV6_ROUTER_PREF=y 67 - CONFIG_INET6_AH=m 68 - CONFIG_INET6_ESP=m 69 - CONFIG_INET6_ESP_OFFLOAD=m 70 - CONFIG_INET6_IPCOMP=m 71 - CONFIG_IPV6_ILA=m 72 - CONFIG_IPV6_VTI=m 73 - CONFIG_IPV6_GRE=m 65 + # CONFIG_IPV6 is not set 74 66 CONFIG_NETFILTER=y 75 67 CONFIG_NETFILTER_NETLINK_HOOK=m 76 68 CONFIG_NF_CONNTRACK=m ··· 78 86 CONFIG_NF_CONNTRACK_SIP=m 79 87 CONFIG_NF_CONNTRACK_TFTP=m 80 88 CONFIG_NF_TABLES=m 81 - CONFIG_NF_TABLES_INET=y 82 89 CONFIG_NF_TABLES_NETDEV=y 83 90 CONFIG_NFT_NUMGEN=m 84 91 CONFIG_NFT_CT=m ··· 94 103 CONFIG_NFT_REJECT=m 95 104 CONFIG_NFT_COMPAT=m 96 105 CONFIG_NFT_HASH=m 97 - CONFIG_NFT_FIB_INET=m 98 106 CONFIG_NFT_XFRM=m 99 107 CONFIG_NFT_SOCKET=m 100 108 CONFIG_NFT_OSF=m ··· 101 111 CONFIG_NFT_SYNPROXY=m 102 112 CONFIG_NFT_DUP_NETDEV=m 103 113 CONFIG_NFT_FWD_NETDEV=m 104 - CONFIG_NFT_FIB_NETDEV=m 105 - CONFIG_NFT_REJECT_NETDEV=m 106 114 CONFIG_NF_FLOW_TABLE_INET=m 107 115 CONFIG_NF_FLOW_TABLE=m 108 116 CONFIG_NETFILTER_XTABLES_LEGACY=y ··· 175 187 CONFIG_IP_SET_HASH_NETPORT=m 176 188 CONFIG_IP_SET_HASH_NETIFACE=m 177 189 CONFIG_IP_SET_LIST_SET=m 190 + CONFIG_NF_TABLES_IPV4=y 178 191 CONFIG_NFT_DUP_IPV4=m 179 192 CONFIG_NFT_FIB_IPV4=m 180 193 CONFIG_NF_TABLES_ARP=y ··· 197 208 CONFIG_IP_NF_RAW=m 198 209 CONFIG_IP_NF_ARPFILTER=m 199 210 CONFIG_IP_NF_ARP_MANGLE=m 200 - CONFIG_NFT_DUP_IPV6=m 201 - CONFIG_NFT_FIB_IPV6=m 202 - CONFIG_IP6_NF_IPTABLES=m 203 - CONFIG_IP6_NF_MATCH_AH=m 204 - CONFIG_IP6_NF_MATCH_EUI64=m 205 - CONFIG_IP6_NF_MATCH_FRAG=m 206 - CONFIG_IP6_NF_MATCH_OPTS=m 207 - CONFIG_IP6_NF_MATCH_HL=m 208 - CONFIG_IP6_NF_MATCH_IPV6HEADER=m 209 - CONFIG_IP6_NF_MATCH_MH=m 210 - CONFIG_IP6_NF_MATCH_RPFILTER=m 211 - CONFIG_IP6_NF_MATCH_RT=m 212 - CONFIG_IP6_NF_MATCH_SRH=m 213 - CONFIG_IP6_NF_TARGET_HL=m 214 - CONFIG_IP6_NF_TARGET_REJECT=m 215 - CONFIG_IP6_NF_TARGET_SYNPROXY=m 216 - CONFIG_IP6_NF_RAW=m 217 - CONFIG_IP6_NF_NAT=m 218 - CONFIG_IP6_NF_TARGET_MASQUERADE=m 219 - CONFIG_IP6_NF_TARGET_NPT=m 220 211 CONFIG_NF_TABLES_BRIDGE=m 221 212 CONFIG_NFT_BRIDGE_META=m 222 - CONFIG_NFT_BRIDGE_REJECT=m 223 213 CONFIG_NF_CONNTRACK_BRIDGE=m 224 214 CONFIG_BRIDGE_NF_EBTABLES_LEGACY=m 225 215 CONFIG_BRIDGE_NF_EBTABLES=m ··· 209 241 CONFIG_BRIDGE_EBT_AMONG=m 210 242 CONFIG_BRIDGE_EBT_ARP=m 211 243 CONFIG_BRIDGE_EBT_IP=m 212 - CONFIG_BRIDGE_EBT_IP6=m 213 244 CONFIG_BRIDGE_EBT_LIMIT=m 214 245 CONFIG_BRIDGE_EBT_MARK=m 215 246 CONFIG_BRIDGE_EBT_PKTTYPE=m ··· 227 260 CONFIG_L2TP=m 228 261 CONFIG_BRIDGE=m 229 262 CONFIG_ATALK=m 230 - CONFIG_6LOWPAN=m 231 - CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=m 232 - CONFIG_6LOWPAN_GHC_UDP=m 233 - CONFIG_6LOWPAN_GHC_ICMPV6=m 234 - CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=m 235 - CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=m 236 - CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=m 237 263 CONFIG_DNS_RESOLVER=y 238 264 CONFIG_BATMAN_ADV=m 239 265 # CONFIG_BATMAN_ADV_BATMAN_V is not set
-1
drivers/infiniband/Kconfig
··· 4 4 depends on HAS_IOMEM && HAS_DMA 5 5 depends on NET 6 6 depends on INET 7 - depends on m || IPV6 != m 8 7 depends on !ALPHA 9 8 select DMA_SHARED_BUFFER 10 9 select IRQ_POLL
+1 -2
drivers/infiniband/core/addr.c
··· 41 41 #include <net/neighbour.h> 42 42 #include <net/route.h> 43 43 #include <net/netevent.h> 44 - #include <net/ipv6_stubs.h> 45 44 #include <net/ip6_route.h> 46 45 #include <rdma/ib_addr.h> 47 46 #include <rdma/ib_cache.h> ··· 410 411 fl6.saddr = src_in->sin6_addr; 411 412 fl6.flowi6_oif = addr->bound_dev_if; 412 413 413 - dst = ipv6_stub->ipv6_dst_lookup_flow(addr->net, NULL, &fl6, NULL); 414 + dst = ip6_dst_lookup_flow(addr->net, NULL, &fl6, NULL); 414 415 if (IS_ERR(dst)) 415 416 return PTR_ERR(dst); 416 417
+1 -1
drivers/infiniband/hw/ocrdma/Kconfig
··· 1 1 # SPDX-License-Identifier: GPL-2.0-only 2 2 config INFINIBAND_OCRDMA 3 3 tristate "Emulex One Connect HCA support" 4 - depends on ETHERNET && NETDEVICES && PCI && INET && (IPV6 || IPV6=n) 4 + depends on ETHERNET && NETDEVICES && PCI && INET 5 5 select NET_VENDOR_EMULEX 6 6 select BE2NET 7 7 help
+3 -3
drivers/infiniband/sw/rxe/rxe_net.c
··· 138 138 memcpy(&fl6.daddr, daddr, sizeof(*daddr)); 139 139 fl6.flowi6_proto = IPPROTO_UDP; 140 140 141 - ndst = ipv6_stub->ipv6_dst_lookup_flow(sock_net(recv_sockets.sk6->sk), 142 - recv_sockets.sk6->sk, &fl6, 143 - NULL); 141 + ndst = ip6_dst_lookup_flow(sock_net(recv_sockets.sk6->sk), 142 + recv_sockets.sk6->sk, &fl6, 143 + NULL); 144 144 if (IS_ERR(ndst)) { 145 145 rxe_dbg_qp(qp, "no route to %pI6\n", daddr); 146 146 return NULL;
+1 -1
drivers/infiniband/ulp/ipoib/Kconfig
··· 1 1 # SPDX-License-Identifier: GPL-2.0-only 2 2 config INFINIBAND_IPOIB 3 3 tristate "IP-over-InfiniBand" 4 - depends on NETDEVICES && INET && (IPV6 || IPV6=n) 4 + depends on NETDEVICES && INET 5 5 help 6 6 Support for the IP-over-InfiniBand protocol (IPoIB). This 7 7 transports IP packets over InfiniBand so you can use your IB
-9
drivers/net/Kconfig
··· 41 41 config BONDING 42 42 tristate "Bonding driver support" 43 43 depends on INET 44 - depends on IPV6 || IPV6=n 45 44 depends on TLS || TLS_DEVICE=n 46 45 help 47 46 Say 'Y' or 'M' if you wish to be able to 'bond' multiple Ethernet ··· 74 75 config WIREGUARD 75 76 tristate "WireGuard secure network tunnel" 76 77 depends on NET && INET 77 - depends on IPV6 || !IPV6 78 78 select NET_UDP_TUNNEL 79 79 select DST_CACHE 80 80 select CRYPTO_LIB_CURVE25519 ··· 103 105 config OVPN 104 106 tristate "OpenVPN data channel offload" 105 107 depends on NET && INET 106 - depends on IPV6 || !IPV6 107 108 select DST_CACHE 108 109 select NET_UDP_TUNNEL 109 110 select CRYPTO ··· 199 202 config IPVLAN 200 203 tristate "IP-VLAN support" 201 204 depends on INET 202 - depends on IPV6 || !IPV6 203 205 help 204 206 This allows one to create virtual devices off of a main interface 205 207 and packets will be delivered based on the dest L3 (IPv6/IPv4 addr) ··· 245 249 config GENEVE 246 250 tristate "Generic Network Virtualization Encapsulation" 247 251 depends on INET 248 - depends on IPV6 || !IPV6 249 252 select NET_UDP_TUNNEL 250 253 select GRO_CELLS 251 254 help ··· 260 265 config BAREUDP 261 266 tristate "Bare UDP Encapsulation" 262 267 depends on INET 263 - depends on IPV6 || !IPV6 264 268 select NET_UDP_TUNNEL 265 269 select GRO_CELLS 266 270 help ··· 302 308 config AMT 303 309 tristate "Automatic Multicast Tunneling (AMT)" 304 310 depends on INET && IP_MULTICAST 305 - depends on IPV6 || !IPV6 306 311 select NET_UDP_TUNNEL 307 312 help 308 313 This allows one to create AMT(Automatic Multicast Tunneling) ··· 473 480 tristate "Virtual Routing and Forwarding (Lite)" 474 481 depends on IP_MULTIPLE_TABLES 475 482 depends on NET_L3_MASTER_DEV 476 - depends on IPV6 || IPV6=n 477 483 depends on IPV6_MULTIPLE_TABLES || IPV6=n 478 484 help 479 485 This option enables the support for mapping interfaces into VRF's. The ··· 607 615 tristate "Simulated networking device" 608 616 depends on DEBUG_FS 609 617 depends on INET 610 - depends on IPV6 || IPV6=n 611 618 depends on PSAMPLE || PSAMPLE=n 612 619 depends on PTP_1588_CLOCK_MOCK || PTP_1588_CLOCK_MOCK=n 613 620 select NET_DEVLINK
+1 -1
drivers/net/ethernet/broadcom/Kconfig
··· 96 96 97 97 config CNIC 98 98 tristate "QLogic CNIC support" 99 - depends on PCI && (IPV6 || IPV6=n) 99 + depends on PCI 100 100 select BNX2 101 101 select UIO 102 102 help
+1 -1
drivers/net/ethernet/chelsio/Kconfig
··· 68 68 69 69 config CHELSIO_T4 70 70 tristate "Chelsio Communications T4/T5/T6 Ethernet support" 71 - depends on PCI && (IPV6 || IPV6=n) && (TLS || TLS=n) 71 + depends on PCI && (TLS || TLS=n) 72 72 depends on PTP_1588_CLOCK_OPTIONAL 73 73 select FW_LOADER 74 74 select MDIO
+5 -4
drivers/net/ethernet/mellanox/mlx5/core/en/rep/neigh.c
··· 10 10 #include <linux/notifier.h> 11 11 #include <net/netevent.h> 12 12 #include <net/arp.h> 13 + #include <net/ndisc.h> 13 14 #include "neigh.h" 14 15 #include "tc.h" 15 16 #include "en_rep.h" ··· 19 18 20 19 static unsigned long mlx5e_rep_ipv6_interval(void) 21 20 { 22 - if (IS_ENABLED(CONFIG_IPV6) && ipv6_stub->nd_tbl) 23 - return NEIGH_VAR(&ipv6_stub->nd_tbl->parms, DELAY_PROBE_TIME); 21 + if (IS_ENABLED(CONFIG_IPV6) && ipv6_mod_enabled()) 22 + return NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME); 24 23 25 24 return ~0UL; 26 25 } ··· 218 217 case NETEVENT_NEIGH_UPDATE: 219 218 n = ptr; 220 219 #if IS_ENABLED(CONFIG_IPV6) 221 - if (n->tbl != ipv6_stub->nd_tbl && n->tbl != &arp_tbl) 220 + if (n->tbl != &nd_tbl && n->tbl != &arp_tbl) 222 221 #else 223 222 if (n->tbl != &arp_tbl) 224 223 #endif ··· 239 238 * done per device delay prob time parameter. 240 239 */ 241 240 #if IS_ENABLED(CONFIG_IPV6) 242 - if (!p->dev || (p->tbl != ipv6_stub->nd_tbl && p->tbl != &arp_tbl)) 241 + if (!p->dev || (p->tbl != &nd_tbl && p->tbl != &arp_tbl)) 243 242 #else 244 243 if (!p->dev || p->tbl != &arp_tbl) 245 244 #endif
+1 -2
drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c
··· 453 453 454 454 if (tunnel && tunnel->get_remote_ifindex) 455 455 attr->fl.fl6.flowi6_oif = tunnel->get_remote_ifindex(dev); 456 - dst = ipv6_stub->ipv6_dst_lookup_flow(dev_net(dev), NULL, &attr->fl.fl6, 457 - NULL); 456 + dst = ip6_dst_lookup_flow(dev_net(dev), NULL, &attr->fl.fl6, NULL); 458 457 if (IS_ERR(dst)) 459 458 return PTR_ERR(dst); 460 459
+1 -1
drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_encap.c
··· 402 402 tbl = &arp_tbl; 403 403 #if IS_ENABLED(CONFIG_IPV6) 404 404 else if (m_neigh->family == AF_INET6) 405 - tbl = ipv6_stub->nd_tbl; 405 + tbl = &nd_tbl; 406 406 #endif 407 407 else 408 408 return;
-1
drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c
··· 36 36 #include <linux/inetdevice.h> 37 37 #include <linux/netdevice.h> 38 38 #include <net/netevent.h> 39 - #include <net/ipv6_stubs.h> 40 39 41 40 #include "en.h" 42 41 #include "eswitch.h"
-1
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
··· 38 38 #include <net/pkt_cls.h> 39 39 #include <net/act_api.h> 40 40 #include <net/devlink.h> 41 - #include <net/ipv6_stubs.h> 42 41 43 42 #include "eswitch.h" 44 43 #include "en.h"
-1
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c
··· 41 41 #include <linux/refcount.h> 42 42 #include <linux/completion.h> 43 43 #include <net/arp.h> 44 - #include <net/ipv6_stubs.h> 45 44 #include <net/bareudp.h> 46 45 #include <net/bonding.h> 47 46 #include <net/dst_metadata.h>
-1
drivers/net/ethernet/mellanox/mlxsw/Kconfig
··· 56 56 depends on MLXSW_CORE && MLXSW_PCI && NET_SWITCHDEV && VLAN_8021Q 57 57 depends on PSAMPLE || PSAMPLE=n 58 58 depends on BRIDGE || BRIDGE=n 59 - depends on IPV6 || IPV6=n 60 59 depends on NET_IPGRE || NET_IPGRE=n 61 60 depends on IPV6_GRE || IPV6_GRE=n 62 61 depends on VXLAN || VXLAN=n
-1
drivers/net/ethernet/netronome/Kconfig
··· 33 33 bool "NFP4000/NFP6000 TC Flower offload support" 34 34 depends on NFP 35 35 depends on NET_SWITCHDEV 36 - depends on IPV6!=m || NFP=m 37 36 default y 38 37 help 39 38 Enable driver support for TC Flower offload on NFP4000 and NFP6000.
+1 -1
drivers/net/ethernet/netronome/nfp/flower/action.c
··· 470 470 471 471 flow.daddr = ip_tun->key.u.ipv6.dst; 472 472 flow.flowi4_proto = IPPROTO_UDP; 473 - dst = ipv6_stub->ipv6_dst_lookup_flow(net, NULL, &flow, NULL); 473 + dst = ip6_dst_lookup_flow(net, NULL, &flow, NULL); 474 474 if (!IS_ERR(dst)) { 475 475 set_tun->ttl = ip6_dst_hoplimit(dst); 476 476 dst_release(dst);
+3 -4
drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c
··· 650 650 flow6.daddr = *(struct in6_addr *)n->primary_key; 651 651 if (!neigh_invalid) { 652 652 struct dst_entry *dst; 653 - /* Use ipv6_dst_lookup_flow to populate flow6->saddr 653 + /* Use ip6_dst_lookup_flow to populate flow6->saddr 654 654 * and other fields. This information is only needed 655 655 * for new entries, lookup can be skipped when an entry 656 656 * gets invalidated - as only the daddr is needed for ··· 730 730 return NOTIFY_DONE; 731 731 } 732 732 #if IS_ENABLED(CONFIG_IPV6) 733 - if (n->tbl != ipv6_stub->nd_tbl && n->tbl != &arp_tbl) 733 + if (n->tbl != &nd_tbl && n->tbl != &arp_tbl) 734 734 #else 735 735 if (n->tbl != &arp_tbl) 736 736 #endif ··· 815 815 flow.flowi6_proto = IPPROTO_UDP; 816 816 817 817 #if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6) 818 - dst = ipv6_stub->ipv6_dst_lookup_flow(dev_net(netdev), NULL, &flow, 819 - NULL); 818 + dst = ip6_dst_lookup_flow(dev_net(netdev), NULL, &flow, NULL); 820 819 if (IS_ERR(dst)) 821 820 goto fail_rcu_unlock; 822 821 #else
+1 -1
drivers/net/ethernet/sfc/tc_counters.c
··· 112 112 encap->neigh->egdev); 113 113 else 114 114 #if IS_ENABLED(CONFIG_IPV6) 115 - n = neigh_lookup(ipv6_stub->nd_tbl, 115 + n = neigh_lookup(&nd_tbl, 116 116 &encap->neigh->dst_ip6, 117 117 encap->neigh->egdev); 118 118 #else
+2 -3
drivers/net/ethernet/sfc/tc_encap_actions.c
··· 149 149 #if IS_ENABLED(CONFIG_IPV6) 150 150 struct dst_entry *dst; 151 151 152 - dst = ipv6_stub->ipv6_dst_lookup_flow(net, NULL, &flow6, 153 - NULL); 152 + dst = ip6_dst_lookup_flow(net, NULL, &flow6, NULL); 154 153 rc = PTR_ERR_OR_ZERO(dst); 155 154 if (rc) { 156 155 NL_SET_ERR_MSG_MOD(extack, "Failed to lookup route for IPv6 encap"); ··· 530 531 if (n->tbl == &arp_tbl) { 531 532 keysize = sizeof(keys.dst_ip); 532 533 #if IS_ENABLED(CONFIG_IPV6) 533 - } else if (n->tbl == ipv6_stub->nd_tbl) { 534 + } else if (n->tbl == &nd_tbl) { 534 535 ipv6 = true; 535 536 keysize = sizeof(keys.dst_ip6); 536 537 #endif
-1
drivers/net/geneve.c
··· 12 12 #include <linux/module.h> 13 13 #include <linux/etherdevice.h> 14 14 #include <linux/hash.h> 15 - #include <net/ipv6_stubs.h> 16 15 #include <net/dst_metadata.h> 17 16 #include <net/gro_cells.h> 18 17 #include <net/rtnetlink.h>
+1 -1
drivers/net/gtp.c
··· 374 374 fl6->saddr = *saddr; 375 375 fl6->flowi6_proto = sk->sk_protocol; 376 376 377 - dst = ipv6_stub->ipv6_dst_lookup_flow(net, sk, fl6, NULL); 377 + dst = ip6_dst_lookup_flow(net, sk, fl6, NULL); 378 378 if (IS_ERR(dst)) 379 379 return ERR_PTR(-ENETUNREACH); 380 380
+1 -2
drivers/net/ovpn/peer.c
··· 827 827 .daddr = dest, 828 828 }; 829 829 830 - entry = ipv6_stub->ipv6_dst_lookup_flow(dev_net(ovpn->dev), NULL, &fl, 831 - NULL); 830 + entry = ip6_dst_lookup_flow(dev_net(ovpn->dev), NULL, &fl, NULL); 832 831 if (IS_ERR(entry)) { 833 832 net_dbg_ratelimited("%s: no route to host %pI6c\n", 834 833 netdev_name(ovpn->dev), &dest);
+1 -2
drivers/net/ovpn/udp.c
··· 14 14 #include <net/addrconf.h> 15 15 #include <net/dst_cache.h> 16 16 #include <net/route.h> 17 - #include <net/ipv6_stubs.h> 18 17 #include <net/transp_v6.h> 19 18 #include <net/udp.h> 20 19 #include <net/udp_tunnel.h> ··· 250 251 dst_cache_reset(cache); 251 252 } 252 253 253 - dst = ipv6_stub->ipv6_dst_lookup_flow(sock_net(sk), sk, &fl, NULL); 254 + dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl, NULL); 254 255 if (IS_ERR(dst)) { 255 256 ret = PTR_ERR(dst); 256 257 net_dbg_ratelimited("%s: no route to host %pISpc: %d\n",
+9 -8
drivers/net/usb/cdc_mbim.c
··· 20 20 #include <linux/usb/cdc_ncm.h> 21 21 #include <net/ipv6.h> 22 22 #include <net/addrconf.h> 23 - #include <net/ipv6_stubs.h> 24 23 #include <net/ndisc.h> 25 24 26 25 /* alternative VLAN for IP session 0 if not untagged */ ··· 301 302 return NULL; 302 303 } 303 304 305 + #if IS_ENABLED(CONFIG_IPV6) 304 306 /* Some devices are known to send Neighbor Solicitation messages and 305 307 * require Neighbor Advertisement replies. The IPv6 core will not 306 308 * respond since IFF_NOARP is set, so we must handle them ourselves. ··· 342 342 is_router = !!READ_ONCE(in6_dev->cnf.forwarding); 343 343 in6_dev_put(in6_dev); 344 344 345 - /* ipv6_stub != NULL if in6_dev_get returned an inet6_dev */ 346 - ipv6_stub->ndisc_send_na(netdev, &iph->saddr, &msg->target, 347 - is_router /* router */, 348 - true /* solicited */, 349 - false /* override */, 350 - true /* inc_opt */); 345 + ndisc_send_na(netdev, &iph->saddr, &msg->target, 346 + is_router /* router */, 347 + true /* solicited */, 348 + false /* override */, 349 + true /* inc_opt */); 351 350 out: 352 351 dev_put(netdev); 353 352 } ··· 361 362 msg->icmph.icmp6_code == 0 && 362 363 msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION); 363 364 } 364 - 365 + #endif /* IPV6 */ 365 366 366 367 static struct sk_buff *cdc_mbim_process_dgram(struct usbnet *dev, u8 *buf, size_t len, u16 tci) 367 368 { ··· 377 378 proto = htons(ETH_P_IP); 378 379 break; 379 380 case 0x60: 381 + #if IS_ENABLED(CONFIG_IPV6) 380 382 if (is_neigh_solicit(buf, len)) 381 383 do_neigh_solicit(dev, buf, tci); 384 + #endif 382 385 proto = htons(ETH_P_IPV6); 383 386 break; 384 387 default:
+5 -6
drivers/net/vxlan/vxlan_core.c
··· 19 19 #include <net/arp.h> 20 20 #include <net/ndisc.h> 21 21 #include <net/gro.h> 22 - #include <net/ipv6_stubs.h> 23 22 #include <net/ip.h> 24 23 #include <net/icmp.h> 25 24 #include <net/rtnetlink.h> ··· 2044 2045 ipv6_addr_is_multicast(&msg->target)) 2045 2046 goto out; 2046 2047 2047 - n = neigh_lookup(ipv6_stub->nd_tbl, &msg->target, dev); 2048 + n = neigh_lookup(&nd_tbl, &msg->target, dev); 2048 2049 2049 2050 if (n) { 2050 2051 struct vxlan_rdst *rdst = NULL; ··· 2129 2130 { 2130 2131 struct ipv6hdr *pip6; 2131 2132 2132 - /* check if nd_tbl is not initiliazed due to 2133 - * ipv6.disable=1 set during boot 2133 + /* check if ipv6.disable=1 set during boot was set 2134 + * during booting so nd_tbl is not initialized 2134 2135 */ 2135 - if (!ipv6_stub->nd_tbl) 2136 + if (!ipv6_mod_enabled()) 2136 2137 return false; 2137 2138 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) 2138 2139 return false; 2139 2140 pip6 = ipv6_hdr(skb); 2140 - n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev); 2141 + n = neigh_lookup(&nd_tbl, &pip6->daddr, dev); 2141 2142 if (!n && (vxlan->cfg.flags & VXLAN_F_L3MISS)) { 2142 2143 union vxlan_addr ipa = { 2143 2144 .sin6.sin6_addr = pip6->daddr,
+2 -4
drivers/net/vxlan/vxlan_multicast.c
··· 39 39 40 40 sk = sock6->sock->sk; 41 41 lock_sock(sk); 42 - ret = ipv6_stub->ipv6_sock_mc_join(sk, ifindex, 43 - &ip->sin6.sin6_addr); 42 + ret = ipv6_sock_mc_join(sk, ifindex, &ip->sin6.sin6_addr); 44 43 release_sock(sk); 45 44 #endif 46 45 } ··· 72 73 73 74 sk = sock6->sock->sk; 74 75 lock_sock(sk); 75 - ret = ipv6_stub->ipv6_sock_mc_drop(sk, ifindex, 76 - &ip->sin6.sin6_addr); 76 + ret = ipv6_sock_mc_drop(sk, ifindex, &ip->sin6.sin6_addr); 77 77 release_sock(sk); 78 78 #endif 79 79 }
+1 -2
drivers/net/wireguard/socket.c
··· 136 136 if (cache) 137 137 dst_cache_reset(cache); 138 138 } 139 - dst = ipv6_stub->ipv6_dst_lookup_flow(sock_net(sock), sock, &fl, 140 - NULL); 139 + dst = ip6_dst_lookup_flow(sock_net(sock), sock, &fl, NULL); 141 140 if (IS_ERR(dst)) { 142 141 ret = PTR_ERR(dst); 143 142 net_dbg_ratelimited("%s: No route to %pISpfsc, error %d\n",
+1 -1
drivers/net/wireless/intel/ipw2x00/ipw2100.c
··· 4838 4838 4839 4839 /* If IPv6 is configured in the kernel then we don't want to filter out all 4840 4840 * of the multicast packets as IPv6 needs some. */ 4841 - #if !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE) 4841 + #if !defined(CONFIG_IPV6) 4842 4842 cmd.host_command = ADD_MULTICAST; 4843 4843 cmd.host_command_sequence = 0; 4844 4844 cmd.host_command_length = 0;
-1
drivers/scsi/bnx2fc/Kconfig
··· 2 2 config SCSI_BNX2X_FCOE 3 3 tristate "QLogic FCoE offload support" 4 4 depends on PCI 5 - depends on (IPV6 || IPV6=n) 6 5 depends on LIBFC 7 6 depends on LIBFCOE 8 7 select NETDEVICES
-1
drivers/scsi/bnx2i/Kconfig
··· 3 3 tristate "QLogic NetXtreme II iSCSI support" 4 4 depends on NET 5 5 depends on PCI 6 - depends on (IPV6 || IPV6=n) 7 6 select SCSI_ISCSI_ATTRS 8 7 select NETDEVICES 9 8 select ETHERNET
+1 -1
drivers/scsi/cxgbi/cxgb3i/Kconfig
··· 1 1 # SPDX-License-Identifier: GPL-2.0-only 2 2 config SCSI_CXGB3_ISCSI 3 3 tristate "Chelsio T3 iSCSI support" 4 - depends on PCI && INET && (IPV6 || IPV6=n) 4 + depends on PCI && INET 5 5 select NETDEVICES 6 6 select ETHERNET 7 7 select NET_VENDOR_CHELSIO
+1 -1
drivers/scsi/cxgbi/cxgb4i/Kconfig
··· 1 1 # SPDX-License-Identifier: GPL-2.0-only 2 2 config SCSI_CXGB4_ISCSI 3 3 tristate "Chelsio T4 iSCSI support" 4 - depends on PCI && INET && (IPV6 || IPV6=n) 4 + depends on PCI && INET 5 5 depends on PTP_1588_CLOCK_OPTIONAL 6 6 depends on THERMAL || !THERMAL 7 7 depends on ETHERNET
+1 -1
fs/dlm/Kconfig
··· 2 2 menuconfig DLM 3 3 tristate "Distributed Lock Manager (DLM)" 4 4 depends on INET 5 - depends on SYSFS && CONFIGFS_FS && (IPV6 || IPV6=n) 5 + depends on SYSFS && CONFIGFS_FS 6 6 help 7 7 A general purpose distributed lock manager for kernel or userspace 8 8 applications.
+1 -1
fs/gfs2/Kconfig
··· 26 26 27 27 config GFS2_FS_LOCKING_DLM 28 28 bool "GFS2 DLM locking" 29 - depends on (GFS2_FS!=n) && NET && INET && (IPV6 || IPV6=n) && \ 29 + depends on (GFS2_FS!=n) && NET && INET && \ 30 30 CONFIGFS_FS && SYSFS && (DLM=y || DLM=GFS2_FS) 31 31 help 32 32 Multiple node locking module for GFS2
+2 -27
include/linux/icmpv6.h
··· 15 15 16 16 #if IS_ENABLED(CONFIG_IPV6) 17 17 18 - typedef void ip6_icmp_send_t(struct sk_buff *skb, u8 type, u8 code, __u32 info, 19 - const struct in6_addr *force_saddr, 20 - const struct inet6_skb_parm *parm); 21 18 void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info, 22 19 const struct in6_addr *force_saddr, 23 20 const struct inet6_skb_parm *parm); 24 - #if IS_BUILTIN(CONFIG_IPV6) 25 - static inline void __icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info, 26 - const struct inet6_skb_parm *parm) 27 - { 28 - icmp6_send(skb, type, code, info, NULL, parm); 29 - } 30 - static inline int inet6_register_icmp_sender(ip6_icmp_send_t *fn) 31 - { 32 - BUILD_BUG_ON(fn != icmp6_send); 33 - return 0; 34 - } 35 - static inline int inet6_unregister_icmp_sender(ip6_icmp_send_t *fn) 36 - { 37 - BUILD_BUG_ON(fn != icmp6_send); 38 - return 0; 39 - } 40 - #else 41 - extern void __icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info, 42 - const struct inet6_skb_parm *parm); 43 - extern int inet6_register_icmp_sender(ip6_icmp_send_t *fn); 44 - extern int inet6_unregister_icmp_sender(ip6_icmp_send_t *fn); 45 - #endif 46 21 47 22 static inline void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info) 48 23 { 49 - __icmpv6_send(skb, type, code, info, IP6CB(skb)); 24 + icmp6_send(skb, type, code, info, NULL, IP6CB(skb)); 50 25 } 51 26 52 27 int ip6_err_gen_icmpv6_unreach(struct sk_buff *skb, int nhs, int type, ··· 33 58 static inline void icmpv6_ndo_send(struct sk_buff *skb_in, u8 type, u8 code, __u32 info) 34 59 { 35 60 struct inet6_skb_parm parm = { 0 }; 36 - __icmpv6_send(skb_in, type, code, info, &parm); 61 + icmp6_send(skb_in, type, code, info, NULL, &parm); 37 62 } 38 63 #endif 39 64
+1 -1
include/linux/indirect_call_wrapper.h
··· 57 57 * builtin, this macro simplify dealing with indirect calls with only ipv4/ipv6 58 58 * alternatives 59 59 */ 60 - #if IS_BUILTIN(CONFIG_IPV6) 60 + #if IS_ENABLED(CONFIG_IPV6) 61 61 #define INDIRECT_CALL_INET(f, f2, f1, ...) \ 62 62 INDIRECT_CALL_2(f, f2, f1, __VA_ARGS__) 63 63 #elif IS_ENABLED(CONFIG_INET)
+6 -96
include/linux/netfilter_ipv6.h
··· 34 34 struct nf_queue_entry; 35 35 struct nf_bridge_frag_data; 36 36 37 - /* 38 - * Hook functions for ipv6 to allow xt_* modules to be built-in even 39 - * if IPv6 is a module. 40 - */ 41 - struct nf_ipv6_ops { 42 - #if IS_MODULE(CONFIG_IPV6) 43 - int (*chk_addr)(struct net *net, const struct in6_addr *addr, 44 - const struct net_device *dev, int strict); 45 - int (*route_me_harder)(struct net *net, struct sock *sk, struct sk_buff *skb); 46 - int (*dev_get_saddr)(struct net *net, const struct net_device *dev, 47 - const struct in6_addr *daddr, unsigned int srcprefs, 48 - struct in6_addr *saddr); 49 - int (*route)(struct net *net, struct dst_entry **dst, struct flowi *fl, 50 - bool strict); 51 - u32 (*cookie_init_sequence)(const struct ipv6hdr *iph, 52 - const struct tcphdr *th, u16 *mssp); 53 - int (*cookie_v6_check)(const struct ipv6hdr *iph, 54 - const struct tcphdr *th); 55 - #endif 56 - void (*route_input)(struct sk_buff *skb); 57 - int (*fragment)(struct net *net, struct sock *sk, struct sk_buff *skb, 58 - int (*output)(struct net *, struct sock *, struct sk_buff *)); 59 - int (*reroute)(struct sk_buff *skb, const struct nf_queue_entry *entry); 60 - #if IS_MODULE(CONFIG_IPV6) 61 - int (*br_fragment)(struct net *net, struct sock *sk, 62 - struct sk_buff *skb, 63 - struct nf_bridge_frag_data *data, 64 - int (*output)(struct net *, struct sock *sk, 65 - const struct nf_bridge_frag_data *data, 66 - struct sk_buff *)); 67 - #endif 68 - }; 69 - 70 37 #ifdef CONFIG_NETFILTER 71 38 #include <net/addrconf.h> 72 - 73 - extern const struct nf_ipv6_ops __rcu *nf_ipv6_ops; 74 - static inline const struct nf_ipv6_ops *nf_get_ipv6_ops(void) 75 - { 76 - return rcu_dereference(nf_ipv6_ops); 77 - } 78 39 79 40 static inline int nf_ipv6_chk_addr(struct net *net, const struct in6_addr *addr, 80 41 const struct net_device *dev, int strict) 81 42 { 82 - #if IS_MODULE(CONFIG_IPV6) 83 - const struct nf_ipv6_ops *v6_ops = nf_get_ipv6_ops(); 84 - 85 - if (!v6_ops) 86 - return 1; 87 - 88 - return v6_ops->chk_addr(net, addr, dev, strict); 89 - #elif IS_BUILTIN(CONFIG_IPV6) 43 + #if IS_ENABLED(CONFIG_IPV6) 90 44 return ipv6_chk_addr(net, addr, dev, strict); 91 45 #else 92 46 return 1; ··· 53 99 static inline int nf_ip6_route(struct net *net, struct dst_entry **dst, 54 100 struct flowi *fl, bool strict) 55 101 { 56 - #if IS_MODULE(CONFIG_IPV6) 57 - const struct nf_ipv6_ops *v6ops = nf_get_ipv6_ops(); 58 - 59 - if (v6ops) 60 - return v6ops->route(net, dst, fl, strict); 61 - 62 - return -EHOSTUNREACH; 63 - #endif 64 - #if IS_BUILTIN(CONFIG_IPV6) 102 + #if IS_ENABLED(CONFIG_IPV6) 65 103 return __nf_ip6_route(net, dst, fl, strict); 66 104 #else 67 105 return -EHOSTUNREACH; ··· 75 129 const struct nf_bridge_frag_data *data, 76 130 struct sk_buff *)) 77 131 { 78 - #if IS_MODULE(CONFIG_IPV6) 79 - const struct nf_ipv6_ops *v6_ops = nf_get_ipv6_ops(); 80 - 81 - if (!v6_ops) 82 - return 1; 83 - 84 - return v6_ops->br_fragment(net, sk, skb, data, output); 85 - #elif IS_BUILTIN(CONFIG_IPV6) 132 + #if IS_ENABLED(CONFIG_IPV6) 86 133 return br_ip6_fragment(net, sk, skb, data, output); 87 134 #else 88 135 return 1; ··· 86 147 87 148 static inline int nf_ip6_route_me_harder(struct net *net, struct sock *sk, struct sk_buff *skb) 88 149 { 89 - #if IS_MODULE(CONFIG_IPV6) 90 - const struct nf_ipv6_ops *v6_ops = nf_get_ipv6_ops(); 91 - 92 - if (!v6_ops) 93 - return -EHOSTUNREACH; 94 - 95 - return v6_ops->route_me_harder(net, sk, skb); 96 - #elif IS_BUILTIN(CONFIG_IPV6) 150 + #if IS_ENABLED(CONFIG_IPV6) 97 151 return ip6_route_me_harder(net, sk, skb); 98 152 #else 99 153 return -EHOSTUNREACH; ··· 97 165 const struct tcphdr *th, 98 166 u16 *mssp) 99 167 { 100 - #if IS_ENABLED(CONFIG_SYN_COOKIES) 101 - #if IS_MODULE(CONFIG_IPV6) 102 - const struct nf_ipv6_ops *v6_ops = nf_get_ipv6_ops(); 103 - 104 - if (v6_ops) 105 - return v6_ops->cookie_init_sequence(iph, th, mssp); 106 - #elif IS_BUILTIN(CONFIG_IPV6) 168 + #if IS_ENABLED(CONFIG_IPV6) && IS_ENABLED(CONFIG_SYN_COOKIES) 107 169 return __cookie_v6_init_sequence(iph, th, mssp); 108 - #endif 109 170 #endif 110 171 return 0; 111 172 } ··· 106 181 static inline int nf_cookie_v6_check(const struct ipv6hdr *iph, 107 182 const struct tcphdr *th) 108 183 { 109 - #if IS_ENABLED(CONFIG_SYN_COOKIES) 110 - #if IS_MODULE(CONFIG_IPV6) 111 - const struct nf_ipv6_ops *v6_ops = nf_get_ipv6_ops(); 112 - 113 - if (v6_ops) 114 - return v6_ops->cookie_v6_check(iph, th); 115 - #elif IS_BUILTIN(CONFIG_IPV6) 184 + #if IS_ENABLED(CONFIG_IPV6) && IS_ENABLED(CONFIG_SYN_COOKIES) 116 185 return __cookie_v6_check(iph, th); 117 - #endif 118 186 #endif 119 187 return 0; 120 188 } ··· 116 198 unsigned int dataoff, u_int8_t protocol); 117 199 118 200 int nf_ip6_check_hbh_len(struct sk_buff *skb, u32 *plen); 119 - 120 - int ipv6_netfilter_init(void); 121 - void ipv6_netfilter_fini(void); 122 - 123 - #else /* CONFIG_NETFILTER */ 124 - static inline int ipv6_netfilter_init(void) { return 0; } 125 - static inline void ipv6_netfilter_fini(void) { return; } 126 - static inline const struct nf_ipv6_ops *nf_get_ipv6_ops(void) { return NULL; } 127 201 #endif /* CONFIG_NETFILTER */ 128 202 129 203 #endif /*__LINUX_IP6_NETFILTER_H*/
-8
include/net/ip.h
··· 692 692 693 693 #endif 694 694 695 - #if IS_MODULE(CONFIG_IPV6) 696 - #define EXPORT_IPV6_MOD(X) EXPORT_SYMBOL(X) 697 - #define EXPORT_IPV6_MOD_GPL(X) EXPORT_SYMBOL_GPL(X) 698 - #else 699 - #define EXPORT_IPV6_MOD(X) 700 - #define EXPORT_IPV6_MOD_GPL(X) 701 - #endif 702 - 703 695 static inline unsigned int ipv4_addr_hash(__be32 ip) 704 696 { 705 697 return (__force unsigned int) ip;
+33 -2
include/net/ip6_fib.h
··· 486 486 rcu_read_unlock(); 487 487 } 488 488 489 + #if IS_ENABLED(CONFIG_IPV6) 489 490 int fib6_nh_init(struct net *net, struct fib6_nh *fib6_nh, 490 491 struct fib6_config *cfg, gfp_t gfp_flags, 491 492 struct netlink_ext_ack *extack); 492 493 void fib6_nh_release(struct fib6_nh *fib6_nh); 493 494 void fib6_nh_release_dsts(struct fib6_nh *fib6_nh); 495 + #else 496 + static inline int fib6_nh_init(struct net *net, struct fib6_nh *fib6_nh, 497 + struct fib6_config *cfg, gfp_t gfp_flags, 498 + struct netlink_ext_ack *extack) 499 + { 500 + NL_SET_ERR_MSG(extack, "IPv6 support not enabled in kernel"); 501 + return -EAFNOSUPPORT; 502 + } 503 + 504 + static inline void fib6_nh_release(struct fib6_nh *fib6_nh) 505 + { 506 + } 507 + 508 + static inline void fib6_nh_release_dsts(struct fib6_nh *fib6_nh) 509 + { 510 + } 511 + #endif 512 + 494 513 495 514 int call_fib6_entry_notifiers(struct net *net, 496 515 enum fib_event_type event_type, ··· 521 502 unsigned int nsiblings, 522 503 struct netlink_ext_ack *extack); 523 504 int call_fib6_entry_notifiers_replace(struct net *net, struct fib6_info *rt); 505 + #if IS_ENABLED(CONFIG_IPV6) 524 506 void fib6_rt_update(struct net *net, struct fib6_info *rt, 525 507 struct nl_info *info); 508 + #else 509 + static inline void fib6_rt_update(struct net *net, struct fib6_info *rt, 510 + struct nl_info *info) 511 + { 512 + } 513 + #endif 526 514 void inet6_rt_notify(int event, struct fib6_info *rt, struct nl_info *info, 527 515 unsigned int flags); 528 516 ··· 614 588 struct netlink_ext_ack *extack); 615 589 616 590 void fib6_update_sernum(struct net *net, struct fib6_info *rt); 591 + #if IS_ENABLED(CONFIG_IPV6) 617 592 void fib6_update_sernum_upto_root(struct net *net, struct fib6_info *rt); 618 - void fib6_update_sernum_stub(struct net *net, struct fib6_info *f6i); 593 + #else 594 + static inline void fib6_update_sernum_upto_root(struct net *net, struct fib6_info *rt) 595 + { 596 + } 597 + #endif 619 598 620 599 void fib6_metric_set(struct fib6_info *f6i, int metric, u32 val); 621 600 static inline bool fib6_metric_locked(struct fib6_info *f6i, int metric) ··· 630 599 void fib6_info_hw_flags_set(struct net *net, struct fib6_info *f6i, 631 600 bool offload, bool trap, bool offload_failed); 632 601 633 - #if IS_BUILTIN(CONFIG_IPV6) && defined(CONFIG_BPF_SYSCALL) 602 + #if IS_ENABLED(CONFIG_IPV6) && defined(CONFIG_BPF_SYSCALL) 634 603 struct bpf_iter__ipv6_route { 635 604 __bpf_md_ptr(struct bpf_iter_meta *, meta); 636 605 __bpf_md_ptr(struct fib6_info *, rt);
+26
include/net/ip6_route.h
··· 77 77 f6i->fib6_nh->fib_nh_gw_family; 78 78 } 79 79 80 + #if IS_ENABLED(CONFIG_IPV6) 80 81 void ip6_route_input(struct sk_buff *skb); 82 + #else 83 + static inline void ip6_route_input(struct sk_buff *skb) 84 + { 85 + } 86 + #endif 87 + 81 88 struct dst_entry *ip6_route_input_lookup(struct net *net, 82 89 struct net_device *dev, 83 90 struct flowi6 *fl6, ··· 126 119 int ip6_route_add(struct fib6_config *cfg, gfp_t gfp_flags, 127 120 struct netlink_ext_ack *extack); 128 121 int ip6_ins_rt(struct net *net, struct fib6_info *f6i); 122 + #if IS_ENABLED(CONFIG_IPV6) 129 123 int ip6_del_rt(struct net *net, struct fib6_info *f6i, bool skip_notify); 124 + #else 125 + static inline int ip6_del_rt(struct net *net, struct fib6_info *f6i, 126 + bool skip_notify) 127 + { 128 + return -EAFNOSUPPORT; 129 + } 130 + #endif 130 131 131 132 void rt6_flush_exceptions(struct fib6_info *f6i); 132 133 void rt6_age_exceptions(struct fib6_info *f6i, struct fib6_gc_args *gc_args, ··· 285 270 return __ipv6_anycast_destination(&rt->rt6i_dst, rt->rt6i_flags, daddr); 286 271 } 287 272 273 + #if IS_ENABLED(CONFIG_IPV6) 288 274 int ip6_fragment(struct net *net, struct sock *sk, struct sk_buff *skb, 289 275 int (*output)(struct net *, struct sock *, struct sk_buff *)); 276 + #else 277 + static inline int ip6_fragment(struct net *net, struct sock *sk, 278 + struct sk_buff *skb, 279 + int (*output)(struct net *, struct sock *, 280 + struct sk_buff *)) 281 + { 282 + kfree_skb(skb); 283 + return -EAFNOSUPPORT; 284 + } 285 + #endif 290 286 291 287 /* Variant of dst_mtu() for IPv6 users */ 292 288 static inline u32 dst6_mtu(const struct dst_entry *dst)
+12
include/net/ipv6.h
··· 1044 1044 1045 1045 int ip6_dst_lookup(struct net *net, struct sock *sk, struct dst_entry **dst, 1046 1046 struct flowi6 *fl6); 1047 + #if IS_ENABLED(CONFIG_IPV6) 1047 1048 struct dst_entry *ip6_dst_lookup_flow(struct net *net, const struct sock *sk, struct flowi6 *fl6, 1048 1049 const struct in6_addr *final_dst); 1050 + #else 1051 + static inline struct dst_entry *ip6_dst_lookup_flow(struct net *net, const struct sock *sk, 1052 + struct flowi6 *fl6, 1053 + const struct in6_addr *final_dst) 1054 + { 1055 + return ERR_PTR(-EAFNOSUPPORT); 1056 + } 1057 + #endif 1058 + 1049 1059 struct dst_entry *ip6_sk_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6, 1050 1060 const struct in6_addr *final_dst, 1051 1061 bool connected); ··· 1149 1139 void inet6_cleanup_sock(struct sock *sk); 1150 1140 void inet6_sock_destruct(struct sock *sk); 1151 1141 int inet6_release(struct socket *sock); 1142 + int __inet6_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len, 1143 + u32 flags); 1152 1144 int inet6_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len); 1153 1145 int inet6_bind_sk(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len); 1154 1146 int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
-101
include/net/ipv6_stubs.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 */ 2 - #ifndef _IPV6_STUBS_H 3 - #define _IPV6_STUBS_H 4 - 5 - #include <linux/in6.h> 6 - #include <linux/netdevice.h> 7 - #include <linux/skbuff.h> 8 - #include <net/dst.h> 9 - #include <net/flow.h> 10 - #include <net/neighbour.h> 11 - #include <net/sock.h> 12 - #include <net/ipv6.h> 13 - 14 - /* structs from net/ip6_fib.h */ 15 - struct fib6_info; 16 - struct fib6_nh; 17 - struct fib6_config; 18 - struct fib6_result; 19 - 20 - /* This is ugly, ideally these symbols should be built 21 - * into the core kernel. 22 - */ 23 - struct ipv6_stub { 24 - int (*ipv6_sock_mc_join)(struct sock *sk, int ifindex, 25 - const struct in6_addr *addr); 26 - int (*ipv6_sock_mc_drop)(struct sock *sk, int ifindex, 27 - const struct in6_addr *addr); 28 - struct dst_entry *(*ipv6_dst_lookup_flow)(struct net *net, 29 - const struct sock *sk, 30 - struct flowi6 *fl6, 31 - const struct in6_addr *final_dst); 32 - int (*ipv6_route_input)(struct sk_buff *skb); 33 - 34 - struct fib6_table *(*fib6_get_table)(struct net *net, u32 id); 35 - int (*fib6_lookup)(struct net *net, int oif, struct flowi6 *fl6, 36 - struct fib6_result *res, int flags); 37 - int (*fib6_table_lookup)(struct net *net, struct fib6_table *table, 38 - int oif, struct flowi6 *fl6, 39 - struct fib6_result *res, int flags); 40 - void (*fib6_select_path)(const struct net *net, struct fib6_result *res, 41 - struct flowi6 *fl6, int oif, bool oif_match, 42 - const struct sk_buff *skb, int strict); 43 - u32 (*ip6_mtu_from_fib6)(const struct fib6_result *res, 44 - const struct in6_addr *daddr, 45 - const struct in6_addr *saddr); 46 - 47 - int (*fib6_nh_init)(struct net *net, struct fib6_nh *fib6_nh, 48 - struct fib6_config *cfg, gfp_t gfp_flags, 49 - struct netlink_ext_ack *extack); 50 - void (*fib6_nh_release)(struct fib6_nh *fib6_nh); 51 - void (*fib6_nh_release_dsts)(struct fib6_nh *fib6_nh); 52 - void (*fib6_update_sernum)(struct net *net, struct fib6_info *rt); 53 - int (*ip6_del_rt)(struct net *net, struct fib6_info *rt, bool skip_notify); 54 - void (*fib6_rt_update)(struct net *net, struct fib6_info *rt, 55 - struct nl_info *info); 56 - 57 - void (*udpv6_encap_enable)(void); 58 - void (*ndisc_send_na)(struct net_device *dev, const struct in6_addr *daddr, 59 - const struct in6_addr *solicited_addr, 60 - bool router, bool solicited, bool override, bool inc_opt); 61 - #if IS_ENABLED(CONFIG_XFRM) 62 - void (*xfrm6_local_rxpmtu)(struct sk_buff *skb, u32 mtu); 63 - int (*xfrm6_udp_encap_rcv)(struct sock *sk, struct sk_buff *skb); 64 - struct sk_buff *(*xfrm6_gro_udp_encap_rcv)(struct sock *sk, 65 - struct list_head *head, 66 - struct sk_buff *skb); 67 - int (*xfrm6_rcv_encap)(struct sk_buff *skb, int nexthdr, __be32 spi, 68 - int encap_type); 69 - #endif 70 - struct neigh_table *nd_tbl; 71 - 72 - int (*ipv6_fragment)(struct net *net, struct sock *sk, struct sk_buff *skb, 73 - int (*output)(struct net *, struct sock *, struct sk_buff *)); 74 - struct net_device *(*ipv6_dev_find)(struct net *net, const struct in6_addr *addr, 75 - struct net_device *dev); 76 - int (*ip6_xmit)(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6, 77 - __u32 mark, struct ipv6_txoptions *opt, int tclass, u32 priority); 78 - }; 79 - extern const struct ipv6_stub *ipv6_stub __read_mostly; 80 - 81 - /* A stub used by bpf helpers. Similarly ugly as ipv6_stub */ 82 - struct ipv6_bpf_stub { 83 - int (*inet6_bind)(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len, 84 - u32 flags); 85 - struct sock *(*udp6_lib_lookup)(const struct net *net, 86 - const struct in6_addr *saddr, __be16 sport, 87 - const struct in6_addr *daddr, __be16 dport, 88 - int dif, int sdif, struct sk_buff *skb); 89 - int (*ipv6_setsockopt)(struct sock *sk, int level, int optname, 90 - sockptr_t optval, unsigned int optlen); 91 - int (*ipv6_getsockopt)(struct sock *sk, int level, int optname, 92 - sockptr_t optval, sockptr_t optlen); 93 - int (*ipv6_dev_get_saddr)(struct net *net, 94 - const struct net_device *dst_dev, 95 - const struct in6_addr *daddr, 96 - unsigned int prefs, 97 - struct in6_addr *saddr); 98 - }; 99 - extern const struct ipv6_bpf_stub *ipv6_bpf_stub __read_mostly; 100 - 101 - #endif
+7 -24
include/net/ndisc.h
··· 2 2 #ifndef _NDISC_H 3 3 #define _NDISC_H 4 4 5 - #include <net/ipv6_stubs.h> 6 - 7 5 /* 8 6 * ICMP codes for neighbour discovery messages 9 7 */ ··· 357 359 return ___neigh_lookup_noref(&nd_tbl, neigh_key_eq128, ndisc_hashfn, pkey, dev); 358 360 } 359 361 360 - static inline 361 - struct neighbour *__ipv6_neigh_lookup_noref_stub(struct net_device *dev, 362 - const void *pkey) 363 - { 364 - return ___neigh_lookup_noref(ipv6_stub->nd_tbl, neigh_key_eq128, 365 - ndisc_hashfn, pkey, dev); 366 - } 367 - 368 362 static inline struct neighbour *__ipv6_neigh_lookup(struct net_device *dev, const void *pkey) 369 363 { 370 364 struct neighbour *n; ··· 381 391 rcu_read_unlock(); 382 392 } 383 393 384 - static inline void __ipv6_confirm_neigh_stub(struct net_device *dev, 385 - const void *pkey) 386 - { 387 - struct neighbour *n; 388 - 389 - rcu_read_lock(); 390 - n = __ipv6_neigh_lookup_noref_stub(dev, pkey); 391 - neigh_confirm(n); 392 - rcu_read_unlock(); 393 - } 394 - 395 - /* uses ipv6_stub and is meant for use outside of IPv6 core */ 396 394 static inline struct neighbour *ip_neigh_gw6(struct net_device *dev, 397 395 const void *addr) 398 396 { 397 + #if IS_ENABLED(CONFIG_IPV6) 399 398 struct neighbour *neigh; 400 399 401 - neigh = __ipv6_neigh_lookup_noref_stub(dev, addr); 400 + neigh = __ipv6_neigh_lookup_noref(dev, addr); 402 401 if (unlikely(!neigh)) 403 - neigh = __neigh_create(ipv6_stub->nd_tbl, addr, dev, false); 402 + neigh = __neigh_create(&nd_tbl, addr, dev, false); 404 403 405 404 return neigh; 405 + #else 406 + return ERR_PTR(-EAFNOSUPPORT); 407 + #endif 406 408 } 407 409 408 410 int ndisc_init(void); ··· 416 434 417 435 void ndisc_send_rs(struct net_device *dev, 418 436 const struct in6_addr *saddr, const struct in6_addr *daddr); 437 + 419 438 void ndisc_send_na(struct net_device *dev, const struct in6_addr *daddr, 420 439 const struct in6_addr *solicited_addr, 421 440 bool router, bool solicited, bool override, bool inc_opt);
+1 -2
include/net/udp_tunnel.h
··· 7 7 8 8 #if IS_ENABLED(CONFIG_IPV6) 9 9 #include <net/ipv6.h> 10 - #include <net/ipv6_stubs.h> 11 10 #endif 12 11 13 12 #define UDP_TUNNEL_PARTIAL_FEATURES NETIF_F_GSO_ENCAP_ALL ··· 229 230 230 231 #if IS_ENABLED(CONFIG_IPV6) 231 232 if (READ_ONCE(sk->sk_family) == PF_INET6) 232 - ipv6_stub->udpv6_encap_enable(); 233 + udpv6_encap_enable(); 233 234 #endif 234 235 udp_encap_enable(); 235 236 }
-1
net/bridge/Kconfig
··· 7 7 tristate "802.1d Ethernet Bridging" 8 8 select LLC 9 9 select STP 10 - depends on IPV6 || IPV6=n 11 10 help 12 11 If you say Y here, then your Linux box will be able to act as an 13 12 Ethernet bridge, which means that the different Ethernet segments it
+1 -2
net/bridge/br_arp_nd_proxy.c
··· 17 17 #include <linux/if_vlan.h> 18 18 #include <linux/inetdevice.h> 19 19 #include <net/addrconf.h> 20 - #include <net/ipv6_stubs.h> 21 20 #if IS_ENABLED(CONFIG_IPV6) 22 21 #include <net/ip6_checksum.h> 23 22 #endif ··· 454 455 return; 455 456 } 456 457 457 - n = neigh_lookup(ipv6_stub->nd_tbl, &msg->target, vlandev); 458 + n = neigh_lookup(&nd_tbl, &msg->target, vlandev); 458 459 if (n) { 459 460 struct net_bridge_fdb_entry *f; 460 461
+3 -9
net/bridge/br_netfilter_hooks.c
··· 32 32 33 33 #include <net/ip.h> 34 34 #include <net/ipv6.h> 35 + #include <net/ip6_route.h> 35 36 #include <net/addrconf.h> 36 37 #include <net/dst_metadata.h> 37 38 #include <net/route.h> ··· 891 890 } 892 891 if (IS_ENABLED(CONFIG_NF_DEFRAG_IPV6) && 893 892 skb->protocol == htons(ETH_P_IPV6)) { 894 - const struct nf_ipv6_ops *v6ops = nf_get_ipv6_ops(); 895 893 struct brnf_frag_data *data; 896 894 897 895 if (br_validate_ipv6(net, skb)) ··· 906 906 skb_copy_from_linear_data_offset(skb, -data->size, data->mac, 907 907 data->size); 908 908 909 - if (v6ops) { 910 - ret = v6ops->fragment(net, sk, skb, br_nf_push_frag_xmit); 911 - local_unlock_nested_bh(&brnf_frag_data_storage.bh_lock); 912 - return ret; 913 - } 909 + ret = ip6_fragment(net, sk, skb, br_nf_push_frag_xmit); 914 910 local_unlock_nested_bh(&brnf_frag_data_storage.bh_lock); 915 - 916 - kfree_skb(skb); 917 - return -EMSGSIZE; 911 + return ret; 918 912 } 919 913 nf_bridge_info_free(skb); 920 914 return br_dev_queue_push_xmit(net, sk, skb);
+3 -4
net/bridge/br_netfilter_ipv6.c
··· 30 30 31 31 #include <net/ip.h> 32 32 #include <net/ipv6.h> 33 + #include <net/ip6_route.h> 33 34 #include <net/addrconf.h> 34 35 #include <net/route.h> 35 36 #include <net/netfilter/br_netfilter.h> ··· 96 95 97 96 /* PF_BRIDGE/PRE_ROUTING: Undo the changes made for ip6tables 98 97 * PREROUTING and continue the bridge PRE_ROUTING hook. See comment 99 - * for br_nf_pre_routing_finish(), same logic is used here but 100 - * equivalent IPv6 function ip6_route_input() called indirectly. 98 + * for br_nf_pre_routing_finish(), same logic is used here. 101 99 */ 102 100 static int br_nf_pre_routing_finish_ipv6(struct net *net, struct sock *sk, struct sk_buff *skb) 103 101 { 104 102 struct nf_bridge_info *nf_bridge = nf_bridge_info_get(skb); 105 103 struct rtable *rt; 106 104 struct net_device *dev = skb->dev, *br_indev; 107 - const struct nf_ipv6_ops *v6ops = nf_get_ipv6_ops(); 108 105 109 106 br_indev = nf_bridge_get_physindev(skb, net); 110 107 if (!br_indev) { ··· 119 120 nf_bridge->in_prerouting = 0; 120 121 if (br_nf_ipv6_daddr_was_changed(skb, nf_bridge)) { 121 122 skb_dst_drop(skb); 122 - v6ops->route_input(skb); 123 + ip6_route_input(skb); 123 124 124 125 if (skb_dst(skb)->error) { 125 126 kfree_skb(skb);
-3
net/core/dev.c
··· 1182 1182 strscpy(name, dev->name, IFNAMSIZ); 1183 1183 } while (read_seqretry(&netdev_rename_lock, seq)); 1184 1184 } 1185 - EXPORT_IPV6_MOD_GPL(netdev_copy_name); 1186 1185 1187 1186 /** 1188 1187 * netdev_get_name - get a netdevice name, knowing its ifindex. ··· 1311 1312 1312 1313 return NULL; 1313 1314 } 1314 - EXPORT_IPV6_MOD(netdev_get_by_flags_rcu); 1315 1315 1316 1316 /** 1317 1317 * dev_valid_name - check if name is okay for network device ··· 1836 1838 netdev_unlock_ops(lower_dev); 1837 1839 } 1838 1840 } 1839 - EXPORT_IPV6_MOD(netif_disable_lro); 1840 1841 1841 1842 /** 1842 1843 * dev_disable_gro_hw - disable HW Generic Receive Offload on a device
+31 -41
net/core/filter.c
··· 73 73 #include <net/seg6.h> 74 74 #include <net/seg6_local.h> 75 75 #include <net/lwtunnel.h> 76 - #include <net/ipv6_stubs.h> 77 76 #include <net/bpf_sk_storage.h> 78 77 #include <net/transp_v6.h> 79 78 #include <linux/btf_ids.h> ··· 2278 2279 .saddr = ip6h->saddr, 2279 2280 }; 2280 2281 2281 - dst = ipv6_stub->ipv6_dst_lookup_flow(net, NULL, &fl6, NULL); 2282 + dst = ip6_dst_lookup_flow(net, NULL, &fl6, NULL); 2282 2283 if (IS_ERR(dst)) 2283 2284 goto out_drop; 2284 2285 ··· 5576 5577 } 5577 5578 5578 5579 if (getopt) 5579 - return ipv6_bpf_stub->ipv6_getsockopt(sk, SOL_IPV6, optname, 5580 - KERNEL_SOCKPTR(optval), 5581 - KERNEL_SOCKPTR(optlen)); 5580 + return do_ipv6_getsockopt(sk, SOL_IPV6, optname, 5581 + KERNEL_SOCKPTR(optval), 5582 + KERNEL_SOCKPTR(optlen)); 5582 5583 5583 - return ipv6_bpf_stub->ipv6_setsockopt(sk, SOL_IPV6, optname, 5584 - KERNEL_SOCKPTR(optval), *optlen); 5584 + return do_ipv6_setsockopt(sk, SOL_IPV6, optname, 5585 + KERNEL_SOCKPTR(optval), *optlen); 5585 5586 } 5586 5587 5587 5588 static int __bpf_setsockopt(struct sock *sk, int level, int optname, ··· 5980 5981 .arg2_type = ARG_ANYTHING, 5981 5982 }; 5982 5983 5983 - const struct ipv6_bpf_stub *ipv6_bpf_stub __read_mostly; 5984 - EXPORT_SYMBOL_GPL(ipv6_bpf_stub); 5985 - 5986 5984 BPF_CALL_3(bpf_bind, struct bpf_sock_addr_kern *, ctx, struct sockaddr *, addr, 5987 5985 int, addr_len) 5988 5986 { ··· 6003 6007 return err; 6004 6008 if (((struct sockaddr_in6 *)addr)->sin6_port == htons(0)) 6005 6009 flags |= BIND_FORCE_ADDRESS_NO_PORT; 6006 - /* ipv6_bpf_stub cannot be NULL, since it's called from 6007 - * bpf_cgroup_inet6_connect hook and ipv6 is already loaded 6008 - */ 6009 - return ipv6_bpf_stub->inet6_bind(sk, (struct sockaddr_unsized *)addr, 6010 - addr_len, flags); 6010 + 6011 + return __inet6_bind(sk, (struct sockaddr_unsized *)addr, 6012 + addr_len, flags); 6011 6013 #endif /* CONFIG_IPV6 */ 6012 6014 } 6013 6015 #endif /* CONFIG_INET */ ··· 6093 6099 static int bpf_ipv4_fib_lookup(struct net *net, struct bpf_fib_lookup *params, 6094 6100 u32 flags, bool check_mtu) 6095 6101 { 6102 + struct neighbour *neigh = NULL; 6096 6103 struct fib_nh_common *nhc; 6097 6104 struct in_device *in_dev; 6098 - struct neighbour *neigh; 6099 6105 struct net_device *dev; 6100 6106 struct fib_result res; 6101 6107 struct flowi4 fl4; ··· 6215 6221 if (likely(nhc->nhc_gw_family != AF_INET6)) 6216 6222 neigh = __ipv4_neigh_lookup_noref(dev, 6217 6223 (__force u32)params->ipv4_dst); 6218 - else 6219 - neigh = __ipv6_neigh_lookup_noref_stub(dev, params->ipv6_dst); 6224 + else if (IS_ENABLED(CONFIG_IPV6)) 6225 + neigh = __ipv6_neigh_lookup_noref(dev, params->ipv6_dst); 6220 6226 6221 6227 if (!neigh || !(READ_ONCE(neigh->nud_state) & NUD_VALID)) 6222 6228 return BPF_FIB_LKUP_RET_NO_NEIGH; ··· 6284 6290 params->tbid = 0; 6285 6291 } 6286 6292 6287 - tb = ipv6_stub->fib6_get_table(net, tbid); 6293 + tb = fib6_get_table(net, tbid); 6288 6294 if (unlikely(!tb)) 6289 6295 return BPF_FIB_LKUP_RET_NOT_FWDED; 6290 6296 6291 - err = ipv6_stub->fib6_table_lookup(net, tb, oif, &fl6, &res, 6292 - strict); 6297 + err = fib6_table_lookup(net, tb, oif, &fl6, &res, strict); 6293 6298 } else { 6294 6299 if (flags & BPF_FIB_LOOKUP_MARK) 6295 6300 fl6.flowi6_mark = params->mark; ··· 6298 6305 fl6.flowi6_tun_key.tun_id = 0; 6299 6306 fl6.flowi6_uid = sock_net_uid(net, NULL); 6300 6307 6301 - err = ipv6_stub->fib6_lookup(net, oif, &fl6, &res, strict); 6308 + err = fib6_lookup(net, oif, &fl6, &res, strict); 6302 6309 } 6303 6310 6304 6311 if (unlikely(err || IS_ERR_OR_NULL(res.f6i) || ··· 6319 6326 return BPF_FIB_LKUP_RET_NOT_FWDED; 6320 6327 } 6321 6328 6322 - ipv6_stub->fib6_select_path(net, &res, &fl6, fl6.flowi6_oif, 6323 - fl6.flowi6_oif != 0, NULL, strict); 6329 + fib6_select_path(net, &res, &fl6, fl6.flowi6_oif, 6330 + fl6.flowi6_oif != 0, NULL, strict); 6324 6331 6325 6332 if (check_mtu) { 6326 - mtu = ipv6_stub->ip6_mtu_from_fib6(&res, dst, src); 6333 + mtu = ip6_mtu_from_fib6(&res, dst, src); 6327 6334 if (params->tot_len > mtu) { 6328 6335 params->mtu_result = mtu; /* union with tot_len */ 6329 6336 return BPF_FIB_LKUP_RET_FRAG_NEEDED; ··· 6344 6351 if (res.f6i->fib6_prefsrc.plen) { 6345 6352 *src = res.f6i->fib6_prefsrc.addr; 6346 6353 } else { 6347 - err = ipv6_bpf_stub->ipv6_dev_get_saddr(net, dev, 6348 - &fl6.daddr, 0, 6349 - src); 6354 + err = ipv6_dev_get_saddr(net, dev, &fl6.daddr, 0, src); 6350 6355 if (err) 6351 6356 return BPF_FIB_LKUP_RET_NO_SRC_ADDR; 6352 6357 } ··· 6356 6365 /* xdp and cls_bpf programs are run in RCU-bh so rcu_read_lock_bh is 6357 6366 * not needed here. 6358 6367 */ 6359 - neigh = __ipv6_neigh_lookup_noref_stub(dev, dst); 6368 + neigh = __ipv6_neigh_lookup_noref(dev, dst); 6360 6369 if (!neigh || !(READ_ONCE(neigh->nud_state) & NUD_VALID)) 6361 6370 return BPF_FIB_LKUP_RET_NO_NEIGH; 6362 6371 memcpy(params->dmac, neigh->ha, ETH_ALEN); ··· 6891 6900 src6, tuple->ipv6.sport, 6892 6901 dst6, ntohs(tuple->ipv6.dport), 6893 6902 dif, sdif, &refcounted); 6894 - else if (likely(ipv6_bpf_stub)) 6895 - sk = ipv6_bpf_stub->udp6_lib_lookup(net, 6896 - src6, tuple->ipv6.sport, 6897 - dst6, tuple->ipv6.dport, 6898 - dif, sdif, NULL); 6903 + else if (likely(ipv6_mod_enabled())) 6904 + sk = __udp6_lib_lookup(net, src6, tuple->ipv6.sport, 6905 + dst6, tuple->ipv6.dport, 6906 + dif, sdif, NULL); 6899 6907 #endif 6900 6908 } 6901 6909 ··· 7580 7590 ret = __cookie_v4_check((struct iphdr *)iph, th); 7581 7591 break; 7582 7592 7583 - #if IS_BUILTIN(CONFIG_IPV6) 7593 + #if IS_ENABLED(CONFIG_IPV6) 7584 7594 case 6: 7585 7595 if (unlikely(iph_len < sizeof(struct ipv6hdr))) 7586 7596 return -EINVAL; ··· 7650 7660 mss = tcp_v4_get_syncookie(sk, iph, th, &cookie); 7651 7661 break; 7652 7662 7653 - #if IS_BUILTIN(CONFIG_IPV6) 7663 + #if IS_ENABLED(CONFIG_IPV6) 7654 7664 case 6: 7655 7665 if (unlikely(iph_len < sizeof(struct ipv6hdr))) 7656 7666 return -EINVAL; ··· 8016 8026 BPF_CALL_3(bpf_tcp_raw_gen_syncookie_ipv6, struct ipv6hdr *, iph, 8017 8027 struct tcphdr *, th, u32, th_len) 8018 8028 { 8019 - #if IS_BUILTIN(CONFIG_IPV6) 8029 + #if IS_ENABLED(CONFIG_IPV6) 8020 8030 const u16 mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - 8021 8031 sizeof(struct ipv6hdr); 8022 8032 u32 cookie; ··· 8068 8078 BPF_CALL_2(bpf_tcp_raw_check_syncookie_ipv6, struct ipv6hdr *, iph, 8069 8079 struct tcphdr *, th) 8070 8080 { 8071 - #if IS_BUILTIN(CONFIG_IPV6) 8081 + #if IS_ENABLED(CONFIG_IPV6) 8072 8082 if (__cookie_v6_check(iph, th) > 0) 8073 8083 return 0; 8074 8084 ··· 11954 11964 return (unsigned long)sk; 11955 11965 #endif 11956 11966 11957 - #if IS_BUILTIN(CONFIG_IPV6) 11967 + #if IS_ENABLED(CONFIG_IPV6) 11958 11968 if (sk && sk->sk_prot == &tcpv6_prot && sk->sk_state == TCP_TIME_WAIT) 11959 11969 return (unsigned long)sk; 11960 11970 #endif ··· 11977 11987 return (unsigned long)sk; 11978 11988 #endif 11979 11989 11980 - #if IS_BUILTIN(CONFIG_IPV6) 11990 + #if IS_ENABLED(CONFIG_IPV6) 11981 11991 if (sk && sk->sk_prot == &tcpv6_prot && sk->sk_state == TCP_NEW_SYN_RECV) 11982 11992 return (unsigned long)sk; 11983 11993 #endif ··· 12240 12250 ops = &tcp_request_sock_ops; 12241 12251 min_mss = 536; 12242 12252 break; 12243 - #if IS_BUILTIN(CONFIG_IPV6) 12253 + #if IS_ENABLED(CONFIG_IPV6) 12244 12254 case htons(ETH_P_IPV6): 12245 12255 ops = &tcp6_request_sock_ops; 12246 12256 min_mss = IPV6_MIN_MTU - 60;
-1
net/core/hotdata.c
··· 27 27 EXPORT_SYMBOL(net_hotdata); 28 28 29 29 struct net_aligned_data net_aligned_data; 30 - EXPORT_IPV6_MOD(net_aligned_data);
+7 -3
net/core/lwt_bpf.c
··· 13 13 #include <net/gre.h> 14 14 #include <net/ip.h> 15 15 #include <net/ip6_route.h> 16 - #include <net/ipv6_stubs.h> 17 16 18 17 struct bpf_lwt_prog { 19 18 struct bpf_prog *prog; ··· 102 103 dev_put(dev); 103 104 } else if (skb->protocol == htons(ETH_P_IPV6)) { 104 105 skb_dst_drop(skb); 105 - err = ipv6_stub->ipv6_route_input(skb); 106 + if (IS_ENABLED(CONFIG_IPV6)) { 107 + ip6_route_input(skb); 108 + err = skb_dst(skb)->error; 109 + } else { 110 + err = -EAFNOSUPPORT; 111 + } 106 112 } else { 107 113 err = -EAFNOSUPPORT; 108 114 } ··· 237 233 fl6.daddr = iph6->daddr; 238 234 fl6.saddr = iph6->saddr; 239 235 240 - dst = ipv6_stub->ipv6_dst_lookup_flow(net, skb->sk, &fl6, NULL); 236 + dst = ip6_dst_lookup_flow(net, skb->sk, &fl6, NULL); 241 237 if (IS_ERR(dst)) { 242 238 err = PTR_ERR(dst); 243 239 goto err;
-1
net/core/neighbour.c
··· 778 778 779 779 return NULL; 780 780 } 781 - EXPORT_IPV6_MOD(pneigh_lookup); 782 781 783 782 int pneigh_create(struct neigh_table *tbl, struct net *net, 784 783 const void *pkey, struct net_device *dev,
+4 -5
net/ipv4/Kconfig
··· 191 191 192 192 config NET_IPGRE 193 193 tristate "IP: GRE tunnels over IP" 194 - depends on (IPV6 || IPV6=n) && NET_IPGRE_DEMUX 194 + depends on NET_IPGRE_DEMUX 195 195 select NET_IP_TUNNEL 196 196 help 197 197 Tunneling means encapsulating data of one protocol type within ··· 303 303 304 304 config NET_IPVTI 305 305 tristate "Virtual (secure) IP: tunneling" 306 - depends on IPV6 || IPV6=n 307 306 select INET_TUNNEL 308 307 select NET_IP_TUNNEL 309 308 select XFRM ··· 438 439 439 440 config INET_UDP_DIAG 440 441 tristate "UDP: socket monitoring interface" 441 - depends on INET_DIAG && (IPV6 || IPV6=n) 442 + depends on INET_DIAG 442 443 default n 443 444 help 444 445 Support for UDP socket monitoring interface used by the ss tool. ··· 446 447 447 448 config INET_RAW_DIAG 448 449 tristate "RAW: socket monitoring interface" 449 - depends on INET_DIAG && (IPV6 || IPV6=n) 450 + depends on INET_DIAG 450 451 default n 451 452 help 452 453 Support for RAW socket monitoring interface used by the ss tool. ··· 749 750 select CRYPTO 750 751 select CRYPTO_LIB_UTILS 751 752 select TCP_SIGPOOL 752 - depends on 64BIT && IPV6 != m # seq-number extension needs WRITE_ONCE(u64) 753 + depends on 64BIT # seq-number extension needs WRITE_ONCE(u64) 753 754 help 754 755 TCP-AO specifies the use of stronger Message Authentication Codes (MACs), 755 756 protects against replays for long-lived TCP connections, and
+8 -8
net/ipv4/fib_semantics.c
··· 585 585 586 586 if (likely(nhc->nhc_gw_family == AF_INET)) 587 587 n = neigh_lookup(&arp_tbl, &nhc->nhc_gw.ipv4, nhc->nhc_dev); 588 - else if (nhc->nhc_gw_family == AF_INET6) 589 - n = neigh_lookup(ipv6_stub->nd_tbl, &nhc->nhc_gw.ipv6, 590 - nhc->nhc_dev); 588 + else if (IS_ENABLED(CONFIG_IPV6) && nhc->nhc_gw_family == AF_INET6) 589 + n = neigh_lookup(&nd_tbl, &nhc->nhc_gw.ipv6, nhc->nhc_dev); 591 590 else 592 591 n = NULL; 593 592 ··· 1082 1083 struct fib6_nh fib6_nh = {}; 1083 1084 int err; 1084 1085 1085 - err = ipv6_stub->fib6_nh_init(net, &fib6_nh, &cfg, GFP_KERNEL, extack); 1086 + err = fib6_nh_init(net, &fib6_nh, &cfg, GFP_KERNEL, extack); 1086 1087 if (!err) { 1087 1088 nh->fib_nh_dev = fib6_nh.fib_nh_dev; 1088 1089 netdev_hold(nh->fib_nh_dev, &nh->fib_nh_dev_tracker, ··· 1090 1091 nh->fib_nh_oif = nh->fib_nh_dev->ifindex; 1091 1092 nh->fib_nh_scope = RT_SCOPE_LINK; 1092 1093 1093 - ipv6_stub->fib6_nh_release(&fib6_nh); 1094 + fib6_nh_release(&fib6_nh); 1094 1095 } 1095 1096 1096 1097 return err; ··· 2146 2147 if (likely(nh->fib_nh_gw_family == AF_INET)) 2147 2148 n = __ipv4_neigh_lookup_noref(nh->fib_nh_dev, 2148 2149 (__force u32)nh->fib_nh_gw4); 2149 - else if (nh->fib_nh_gw_family == AF_INET6) 2150 - n = __ipv6_neigh_lookup_noref_stub(nh->fib_nh_dev, 2151 - &nh->fib_nh_gw6); 2150 + else if (IS_ENABLED(CONFIG_IPV6) && 2151 + nh->fib_nh_gw_family == AF_INET6) 2152 + n = __ipv6_neigh_lookup_noref(nh->fib_nh_dev, 2153 + &nh->fib_nh_gw6); 2152 2154 else 2153 2155 n = NULL; 2154 2156 if (n)
+1 -1
net/ipv4/icmp.c
··· 1344 1344 case ICMP_AFI_IP6: 1345 1345 if (iio->ident.addr.ctype3_hdr.addrlen != sizeof(struct in6_addr)) 1346 1346 goto send_mal_query; 1347 - dev = ipv6_stub->ipv6_dev_find(net, &iio->ident.addr.ip_addr.ipv6_addr, dev); 1347 + dev = ipv6_dev_find(net, &iio->ident.addr.ip_addr.ipv6_addr, dev); 1348 1348 dev_hold(dev); 1349 1349 break; 1350 1350 #endif
-2
net/ipv4/inet_connection_sock.c
··· 709 709 arg->err = error; 710 710 return NULL; 711 711 } 712 - EXPORT_IPV6_MOD(inet_csk_accept); 713 712 714 713 /* 715 714 * Using different timers for retransmit, delayed acks and probes ··· 1020 1021 inet_csk_reqsk_queue_drop(sk, req); 1021 1022 reqsk_put(req); 1022 1023 } 1023 - EXPORT_IPV6_MOD(inet_csk_reqsk_queue_drop_and_put); 1024 1024 1025 1025 static void reqsk_timer_handler(struct timer_list *t) 1026 1026 {
-5
net/ipv4/inet_hashtables.c
··· 758 758 } 759 759 return ok; 760 760 } 761 - EXPORT_IPV6_MOD(inet_ehash_nolisten); 762 761 763 762 static int inet_reuseport_add_sock(struct sock *sk, 764 763 struct inet_listen_hashbucket *ilb) ··· 825 826 826 827 return err; 827 828 } 828 - EXPORT_IPV6_MOD(inet_hash); 829 829 830 830 void inet_unhash(struct sock *sk) 831 831 { ··· 857 859 spin_unlock_bh(lock); 858 860 } 859 861 } 860 - EXPORT_IPV6_MOD(inet_unhash); 861 862 862 863 static bool inet_bind2_bucket_match(const struct inet_bind2_bucket *tb, 863 864 const struct net *net, unsigned short port, ··· 1019 1022 { 1020 1023 return __inet_bhash2_update_saddr(sk, saddr, family, false); 1021 1024 } 1022 - EXPORT_IPV6_MOD(inet_bhash2_update_saddr); 1023 1025 1024 1026 void inet_bhash2_reset_saddr(struct sock *sk) 1025 1027 { 1026 1028 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK)) 1027 1029 __inet_bhash2_update_saddr(sk, NULL, 0, true); 1028 1030 } 1029 - EXPORT_IPV6_MOD(inet_bhash2_reset_saddr); 1030 1031 1031 1032 /* RFC 6056 3.3.4. Algorithm 4: Double-Hash Port Selection Algorithm 1032 1033 * Note that we use 32bit integers (vs RFC 'short integers')
-4
net/ipv4/inetpeer.c
··· 59 59 seqlock_init(&bp->lock); 60 60 bp->total = 0; 61 61 } 62 - EXPORT_IPV6_MOD_GPL(inet_peer_base_init); 63 62 64 63 #define PEER_MAX_GC 32 65 64 ··· 216 217 217 218 return p; 218 219 } 219 - EXPORT_IPV6_MOD_GPL(inet_getpeer); 220 220 221 221 void inet_putpeer(struct inet_peer *p) 222 222 { ··· 266 268 WRITE_ONCE(peer->rate_tokens, token); 267 269 return rc; 268 270 } 269 - EXPORT_IPV6_MOD(inet_peer_xrlim_allow); 270 271 271 272 void inetpeer_invalidate_tree(struct inet_peer_base *base) 272 273 { ··· 282 285 283 286 base->total = 0; 284 287 } 285 - EXPORT_IPV6_MOD(inetpeer_invalidate_tree);
-1
net/ipv4/metrics.c
··· 88 88 89 89 return fib_metrics; 90 90 } 91 - EXPORT_IPV6_MOD_GPL(ip_fib_metrics_init);
+15 -13
net/ipv4/nexthop.c
··· 10 10 #include <linux/slab.h> 11 11 #include <linux/vmalloc.h> 12 12 #include <net/arp.h> 13 - #include <net/ipv6_stubs.h> 13 + #include <net/ip6_route.h> 14 14 #include <net/lwtunnel.h> 15 15 #include <net/ndisc.h> 16 16 #include <net/nexthop.h> ··· 510 510 fib_nh_release(nh->net, &nhi->fib_nh); 511 511 break; 512 512 case AF_INET6: 513 - ipv6_stub->fib6_nh_release(&nhi->fib6_nh); 513 + fib6_nh_release(&nhi->fib6_nh); 514 514 break; 515 515 } 516 516 kfree(nhi); ··· 1367 1367 1368 1368 rcu_read_lock(); 1369 1369 1370 - n = __ipv6_neigh_lookup_noref_stub(nh->fib_nh_dev, &nh->fib_nh_gw6); 1370 + n = __ipv6_neigh_lookup_noref(nh->fib_nh_dev, &nh->fib_nh_gw6); 1371 1371 if (n) 1372 1372 state = READ_ONCE(n->nud_state); 1373 1373 ··· 1401 1401 case AF_INET: 1402 1402 return ipv4_good_nh(&nhi->fib_nh); 1403 1403 case AF_INET6: 1404 - return ipv6_good_nh(&nhi->fib6_nh); 1404 + return IS_ENABLED(CONFIG_IPV6) && ipv6_good_nh(&nhi->fib6_nh); 1405 1405 } 1406 1406 1407 1407 return false; ··· 2151 2151 fib6_info_hold(f6i); 2152 2152 2153 2153 spin_unlock_bh(&nh->lock); 2154 - ipv6_stub->ip6_del_rt(net, f6i, 2155 - !READ_ONCE(net->ipv4.sysctl_nexthop_compat_mode)); 2154 + ip6_del_rt(net, f6i, 2155 + !READ_ONCE(net->ipv4.sysctl_nexthop_compat_mode)); 2156 2156 2157 2157 spin_lock_bh(&nh->lock); 2158 2158 } ··· 2208 2208 if (!list_empty(&nh->fi_list)) 2209 2209 rt_cache_flush(net); 2210 2210 2211 - list_for_each_entry(f6i, &nh->f6i_list, nh_list) 2212 - ipv6_stub->fib6_update_sernum(net, f6i); 2211 + list_for_each_entry(f6i, &nh->f6i_list, nh_list) { 2212 + spin_lock_bh(&f6i->fib6_table->tb6_lock); 2213 + fib6_update_sernum_upto_root(net, f6i); 2214 + spin_unlock_bh(&f6i->fib6_table->tb6_lock); 2215 + } 2213 2216 2214 2217 /* if an IPv6 group was replaced, we have to release all old 2215 2218 * dsts to make sure all refcounts are released ··· 2226 2223 struct nh_info *nhi = rtnl_dereference(nhge->nh->nh_info); 2227 2224 2228 2225 if (nhi->family == AF_INET6) 2229 - ipv6_stub->fib6_nh_release_dsts(&nhi->fib6_nh); 2226 + fib6_nh_release_dsts(&nhi->fib6_nh); 2230 2227 } 2231 2228 } 2232 2229 ··· 2507 2504 } 2508 2505 2509 2506 list_for_each_entry(f6i, &nh->f6i_list, nh_list) 2510 - ipv6_stub->fib6_rt_update(net, f6i, info); 2507 + fib6_rt_update(net, f6i, info); 2511 2508 } 2512 2509 2513 2510 /* send RTM_NEWROUTE with REPLACE flag set for all FIB entries ··· 2880 2877 fib6_cfg.fc_flags |= RTF_GATEWAY; 2881 2878 2882 2879 /* sets nh_dev if successful */ 2883 - err = ipv6_stub->fib6_nh_init(net, fib6_nh, &fib6_cfg, GFP_KERNEL, 2884 - extack); 2880 + err = fib6_nh_init(net, fib6_nh, &fib6_cfg, GFP_KERNEL, extack); 2885 2881 if (err) { 2886 2882 /* IPv6 is not enabled, don't call fib6_nh_release */ 2887 2883 if (err == -EAFNOSUPPORT) 2888 2884 goto out; 2889 - ipv6_stub->fib6_nh_release(fib6_nh); 2885 + fib6_nh_release(fib6_nh); 2890 2886 } else { 2891 2887 nh->nh_flags = fib6_nh->fib_nh_flags; 2892 2888 }
-16
net/ipv4/ping.c
··· 56 56 57 57 static struct ping_table ping_table; 58 58 struct pingv6_ops pingv6_ops; 59 - EXPORT_IPV6_MOD_GPL(pingv6_ops); 60 59 61 60 static inline u32 ping_hashfn(const struct net *net, u32 num, u32 mask) 62 61 { ··· 138 139 spin_unlock(&ping_table.lock); 139 140 return -EADDRINUSE; 140 141 } 141 - EXPORT_IPV6_MOD_GPL(ping_get_port); 142 142 143 143 void ping_unhash(struct sock *sk) 144 144 { ··· 152 154 } 153 155 spin_unlock(&ping_table.lock); 154 156 } 155 - EXPORT_IPV6_MOD_GPL(ping_unhash); 156 157 157 158 /* Called under rcu_read_lock() */ 158 159 static struct sock *ping_lookup(struct net *net, struct sk_buff *skb, u16 ident) ··· 275 278 put_group_info(group_info); 276 279 return ret; 277 280 } 278 - EXPORT_IPV6_MOD_GPL(ping_init_sock); 279 281 280 282 void ping_close(struct sock *sk, long timeout) 281 283 { ··· 284 288 285 289 sk_common_release(sk); 286 290 } 287 - EXPORT_IPV6_MOD_GPL(ping_close); 288 291 289 292 static int ping_pre_connect(struct sock *sk, struct sockaddr_unsized *uaddr, 290 293 int addr_len) ··· 463 468 pr_debug("ping_v4_bind -> %d\n", err); 464 469 return err; 465 470 } 466 - EXPORT_IPV6_MOD_GPL(ping_bind); 467 471 468 472 /* 469 473 * Is this a supported type of ICMP message? ··· 595 601 out: 596 602 return; 597 603 } 598 - EXPORT_IPV6_MOD_GPL(ping_err); 599 604 600 605 /* 601 606 * Copy and checksum an ICMP Echo packet from user space into a buffer ··· 624 631 625 632 return 0; 626 633 } 627 - EXPORT_IPV6_MOD_GPL(ping_getfrag); 628 634 629 635 static int ping_v4_push_pending_frames(struct sock *sk, struct pingfakehdr *pfh, 630 636 struct flowi4 *fl4) ··· 684 692 685 693 return 0; 686 694 } 687 - EXPORT_IPV6_MOD_GPL(ping_common_sendmsg); 688 695 689 696 static int ping_v4_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) 690 697 { ··· 927 936 pr_debug("ping_recvmsg -> %d\n", err); 928 937 return err; 929 938 } 930 - EXPORT_IPV6_MOD_GPL(ping_recvmsg); 931 939 932 940 static enum skb_drop_reason __ping_queue_rcv_skb(struct sock *sk, 933 941 struct sk_buff *skb) ··· 947 957 { 948 958 return __ping_queue_rcv_skb(sk, skb) ? -1 : 0; 949 959 } 950 - EXPORT_IPV6_MOD_GPL(ping_queue_rcv_skb); 951 960 952 961 953 962 /* ··· 974 985 kfree_skb_reason(skb, SKB_DROP_REASON_NO_SOCKET); 975 986 return SKB_DROP_REASON_NO_SOCKET; 976 987 } 977 - EXPORT_IPV6_MOD_GPL(ping_rcv); 978 988 979 989 struct proto ping_prot = { 980 990 .name = "PING", ··· 995 1007 .put_port = ping_unhash, 996 1008 .obj_size = sizeof(struct inet_sock), 997 1009 }; 998 - EXPORT_IPV6_MOD(ping_prot); 999 1010 1000 1011 #ifdef CONFIG_PROC_FS 1001 1012 ··· 1059 1072 1060 1073 return *pos ? ping_get_idx(seq, *pos-1) : SEQ_START_TOKEN; 1061 1074 } 1062 - EXPORT_IPV6_MOD_GPL(ping_seq_start); 1063 1075 1064 1076 static void *ping_v4_seq_start(struct seq_file *seq, loff_t *pos) 1065 1077 { ··· 1077 1091 ++*pos; 1078 1092 return sk; 1079 1093 } 1080 - EXPORT_IPV6_MOD_GPL(ping_seq_next); 1081 1094 1082 1095 void ping_seq_stop(struct seq_file *seq, void *v) 1083 1096 __releases(ping_table.lock) 1084 1097 { 1085 1098 spin_unlock(&ping_table.lock); 1086 1099 } 1087 - EXPORT_IPV6_MOD_GPL(ping_seq_stop); 1088 1100 1089 1101 static void ping_v4_format_sock(struct sock *sp, struct seq_file *f, 1090 1102 int bucket)
+2 -2
net/ipv4/route.c
··· 446 446 447 447 if (rt->rt_gw_family == AF_INET) { 448 448 pkey = (const __be32 *)&rt->rt_gw4; 449 - } else if (rt->rt_gw_family == AF_INET6) { 450 - return __ipv6_confirm_neigh_stub(dev, &rt->rt_gw6); 449 + } else if (IS_ENABLED(CONFIG_IPV6) && rt->rt_gw_family == AF_INET6) { 450 + return __ipv6_confirm_neigh(dev, &rt->rt_gw6); 451 451 } else if (!daddr || 452 452 (rt->rt_flags & 453 453 (RTCF_MULTICAST | RTCF_BROADCAST | RTCF_LOCAL))) {
-4
net/ipv4/syncookies.c
··· 223 223 224 224 return NULL; 225 225 } 226 - EXPORT_IPV6_MOD(tcp_get_cookie_sock); 227 226 228 227 /* 229 228 * when syncookies are in effect and tcp timestamps are enabled we stored ··· 259 260 260 261 return READ_ONCE(net->ipv4.sysctl_tcp_window_scaling) != 0; 261 262 } 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 312 311 313 return req; 312 314 } 313 - EXPORT_IPV6_MOD_GPL(cookie_bpf_check); 314 315 #endif 315 316 316 317 struct request_sock *cookie_tcp_reqsk_alloc(const struct request_sock_ops *ops, ··· 350 353 351 354 return req; 352 355 } 353 - EXPORT_IPV6_MOD_GPL(cookie_tcp_reqsk_alloc); 354 356 355 357 static struct request_sock *cookie_tcp_check(struct net *net, struct sock *sk, 356 358 struct sk_buff *skb)
-23
net/ipv4/tcp.c
··· 303 303 EXPORT_PER_CPU_SYMBOL_GPL(tcp_tw_isn); 304 304 305 305 long sysctl_tcp_mem[3] __read_mostly; 306 - EXPORT_IPV6_MOD(sysctl_tcp_mem); 307 306 308 307 DEFINE_PER_CPU(int, tcp_memory_per_cpu_fw_alloc); 309 308 EXPORT_PER_CPU_SYMBOL_GPL(tcp_memory_per_cpu_fw_alloc); ··· 316 317 * Current number of TCP sockets. 317 318 */ 318 319 struct percpu_counter tcp_sockets_allocated ____cacheline_aligned_in_smp; 319 - EXPORT_IPV6_MOD(tcp_sockets_allocated); 320 320 321 321 /* 322 322 * Pressure flag: try to collapse. ··· 339 341 if (!cmpxchg(&tcp_memory_pressure, 0, val)) 340 342 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES); 341 343 } 342 - EXPORT_IPV6_MOD_GPL(tcp_enter_memory_pressure); 343 344 344 345 void tcp_leave_memory_pressure(struct sock *sk) 345 346 { ··· 351 354 NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURESCHRONO, 352 355 jiffies_to_msecs(jiffies - val)); 353 356 } 354 - EXPORT_IPV6_MOD_GPL(tcp_leave_memory_pressure); 355 357 356 358 /* Convert seconds to retransmits based on initial and max timeout */ 357 359 static u8 secs_to_retrans(int seconds, int timeout, int rto_max) ··· 414 418 static_branch_slow_dec_deferred(&tcp_md5_needed); 415 419 } 416 420 } 417 - EXPORT_IPV6_MOD_GPL(tcp_md5_destruct_sock); 418 421 #endif 419 422 420 423 /* Address-family independent initialization for a tcp_sock. ··· 481 486 sk_sockets_allocated_inc(sk); 482 487 xa_init_flags(&sk->sk_user_frags, XA_FLAGS_ALLOC1); 483 488 } 484 - EXPORT_IPV6_MOD(tcp_init_sock); 485 489 486 490 static void tcp_tx_timestamp(struct sock *sk, struct sockcm_cookie *sockc) 487 491 { ··· 685 691 *karg = answ; 686 692 return 0; 687 693 } 688 - EXPORT_IPV6_MOD(tcp_ioctl); 689 694 690 695 void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb) 691 696 { ··· 901 908 902 909 return ret; 903 910 } 904 - EXPORT_IPV6_MOD(tcp_splice_read); 905 911 906 912 /* We allow to exceed memory limits for FIN packets to expedite 907 913 * connection tear down and (memory) recovery. ··· 1475 1483 tcp_push(sk, 0, mss_now, tp->nonagle, size_goal); 1476 1484 release_sock(sk); 1477 1485 } 1478 - EXPORT_IPV6_MOD_GPL(tcp_splice_eof); 1479 1486 1480 1487 /* 1481 1488 * Handle reading urgent data. BSD has very simple semantics for ··· 1786 1795 } 1787 1796 return copied; 1788 1797 } 1789 - EXPORT_IPV6_MOD(tcp_read_skb); 1790 1798 1791 1799 void tcp_read_done(struct sock *sk, size_t len) 1792 1800 { ··· 1830 1840 { 1831 1841 return tcp_inq(sock->sk); 1832 1842 } 1833 - EXPORT_IPV6_MOD(tcp_peek_len); 1834 1843 1835 1844 /* Make sure sk_rcvbuf is big enough to satisfy SO_RCVLOWAT hint */ 1836 1845 int tcp_set_rcvlowat(struct sock *sk, int val) ··· 1859 1870 } 1860 1871 return 0; 1861 1872 } 1862 - EXPORT_IPV6_MOD(tcp_set_rcvlowat); 1863 1873 1864 1874 #ifdef CONFIG_MMU 1865 1875 static const struct vm_operations_struct tcp_vm_ops = { ··· 1877 1889 vma->vm_ops = &tcp_vm_ops; 1878 1890 return 0; 1879 1891 } 1880 - EXPORT_IPV6_MOD(tcp_mmap); 1881 1892 1882 1893 static skb_frag_t *skb_advance_to_frag(struct sk_buff *skb, u32 offset_skb, 1883 1894 u32 *offset_frag) ··· 2961 2974 } 2962 2975 return ret; 2963 2976 } 2964 - EXPORT_IPV6_MOD(tcp_recvmsg); 2965 2977 2966 2978 void tcp_set_state(struct sock *sk, int state) 2967 2979 { ··· 3090 3104 tcp_send_fin(sk); 3091 3105 } 3092 3106 } 3093 - EXPORT_IPV6_MOD(tcp_shutdown); 3094 3107 3095 3108 int tcp_orphan_count_sum(void) 3096 3109 { ··· 3602 3617 } 3603 3618 3604 3619 DEFINE_STATIC_KEY_FALSE(tcp_tx_delay_enabled); 3605 - EXPORT_IPV6_MOD(tcp_tx_delay_enabled); 3606 3620 3607 3621 static void tcp_enable_tx_delay(struct sock *sk, int val) 3608 3622 { ··· 4186 4202 optval, optlen); 4187 4203 return do_tcp_setsockopt(sk, level, optname, optval, optlen); 4188 4204 } 4189 - EXPORT_IPV6_MOD(tcp_setsockopt); 4190 4205 4191 4206 static void tcp_get_info_chrono_stats(const struct tcp_sock *tp, 4192 4207 struct tcp_info *info) ··· 4848 4865 4849 4866 return false; 4850 4867 } 4851 - EXPORT_IPV6_MOD(tcp_bpf_bypass_getsockopt); 4852 4868 4853 4869 int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval, 4854 4870 int __user *optlen) ··· 4861 4879 return do_tcp_getsockopt(sk, level, optname, USER_SOCKPTR(optval), 4862 4880 USER_SOCKPTR(optlen)); 4863 4881 } 4864 - EXPORT_IPV6_MOD(tcp_getsockopt); 4865 4882 4866 4883 #ifdef CONFIG_TCP_MD5SIG 4867 4884 void tcp_md5_hash_skb_data(struct md5_ctx *ctx, const struct sk_buff *skb, ··· 4891 4910 skb_walk_frags(skb, frag_iter) 4892 4911 tcp_md5_hash_skb_data(ctx, frag_iter, 0); 4893 4912 } 4894 - EXPORT_IPV6_MOD(tcp_md5_hash_skb_data); 4895 4913 4896 4914 void tcp_md5_hash_key(struct md5_ctx *ctx, 4897 4915 const struct tcp_md5sig_key *key) ··· 4902 4922 */ 4903 4923 data_race(({ md5_update(ctx, key->key, keylen), 0; })); 4904 4924 } 4905 - EXPORT_IPV6_MOD(tcp_md5_hash_key); 4906 4925 4907 4926 /* Called with rcu_read_lock() */ 4908 4927 static enum skb_drop_reason ··· 5002 5023 } 5003 5024 return 0; 5004 5025 } 5005 - EXPORT_IPV6_MOD(tcp_do_parse_auth_options); 5006 5026 #endif 5007 5027 5008 5028 /* Called with rcu_read_lock() */ ··· 5070 5092 return tcp_inbound_md5_hash(sk, skb, saddr, daddr, family, 5071 5093 l3index, md5_location); 5072 5094 } 5073 - EXPORT_IPV6_MOD_GPL(tcp_inbound_hash); 5074 5095 5075 5096 void tcp_done(struct sock *sk) 5076 5097 {
-1
net/ipv4/tcp_fastopen.c
··· 559 559 } 560 560 return false; 561 561 } 562 - EXPORT_IPV6_MOD(tcp_fastopen_defer_connect); 563 562 564 563 /* 565 564 * The following code block is to deal with middle box issues with TFO:
-7
net/ipv4/tcp_input.c
··· 814 814 815 815 inet_csk(sk)->icsk_ack.rcv_mss = hint; 816 816 } 817 - EXPORT_IPV6_MOD(tcp_initialize_rcv_mss); 818 817 819 818 /* Receiver "autotuning" code. 820 819 * ··· 3171 3172 */ 3172 3173 tcp_non_congestion_loss_retransmit(sk); 3173 3174 } 3174 - EXPORT_IPV6_MOD(tcp_simple_retransmit); 3175 3175 3176 3176 void tcp_enter_recovery(struct sock *sk, bool ece_ack) 3177 3177 { ··· 4841 4843 if (!sock_flag(sk, SOCK_DEAD)) 4842 4844 sk_error_report(sk); 4843 4845 } 4844 - EXPORT_IPV6_MOD(tcp_done_with_error); 4845 4846 4846 4847 /* When we get a reset we do this. */ 4847 4848 void tcp_reset(struct sock *sk, struct sk_buff *skb) ··· 6662 6665 discard: 6663 6666 tcp_drop_reason(sk, skb, reason); 6664 6667 } 6665 - EXPORT_IPV6_MOD(tcp_rcv_established); 6666 6668 6667 6669 void tcp_init_transfer(struct sock *sk, int bpf_op, struct sk_buff *skb) 6668 6670 { ··· 7380 7384 __kfree_skb(skb); 7381 7385 return 0; 7382 7386 } 7383 - EXPORT_IPV6_MOD(tcp_rcv_state_process); 7384 7387 7385 7388 static inline void pr_drop_req(struct request_sock *req, __u16 port, int family) 7386 7389 { ··· 7577 7582 7578 7583 return mss; 7579 7584 } 7580 - EXPORT_IPV6_MOD_GPL(tcp_get_syncookie_mss); 7581 7585 7582 7586 int tcp_conn_request(struct request_sock_ops *rsk_ops, 7583 7587 const struct tcp_request_sock_ops *af_ops, ··· 7756 7762 tcp_listendrop(sk); 7757 7763 return 0; 7758 7764 } 7759 - EXPORT_IPV6_MOD(tcp_conn_request);
-21
net/ipv4/tcp_ipv4.c
··· 201 201 202 202 return 0; 203 203 } 204 - EXPORT_IPV6_MOD_GPL(tcp_twsk_unique); 205 204 206 205 static int tcp_v4_pre_connect(struct sock *sk, struct sockaddr_unsized *uaddr, 207 206 int addr_len) ··· 361 362 inet->inet_dport = 0; 362 363 return err; 363 364 } 364 - EXPORT_IPV6_MOD(tcp_v4_connect); 365 365 366 366 /* 367 367 * This routine reacts to ICMP_FRAG_NEEDED mtu indications as defined in RFC1191. ··· 400 402 tcp_simple_retransmit(sk); 401 403 } /* else let the usual retransmit timer handle it */ 402 404 } 403 - EXPORT_IPV6_MOD(tcp_v4_mtu_reduced); 404 405 405 406 static void do_redirect(struct sk_buff *skb, struct sock *sk) 406 407 { ··· 433 436 } 434 437 reqsk_put(req); 435 438 } 436 - EXPORT_IPV6_MOD(tcp_req_err); 437 439 438 440 /* TCP-LD (RFC 6069) logic */ 439 441 void tcp_ld_RTO_revert(struct sock *sk, u32 seq) ··· 471 475 tcp_retransmit_timer(sk); 472 476 } 473 477 } 474 - EXPORT_IPV6_MOD(tcp_ld_RTO_revert); 475 478 476 479 /* 477 480 * This routine is called by the ICMP module when it gets some ··· 1217 1222 */ 1218 1223 1219 1224 DEFINE_STATIC_KEY_DEFERRED_FALSE(tcp_md5_needed, HZ); 1220 - EXPORT_IPV6_MOD(tcp_md5_needed); 1221 1225 1222 1226 static bool better_md5_match(struct tcp_md5sig_key *old, struct tcp_md5sig_key *new) 1223 1227 { ··· 1275 1281 } 1276 1282 return best_match; 1277 1283 } 1278 - EXPORT_IPV6_MOD(__tcp_md5_do_lookup); 1279 1284 1280 1285 static struct tcp_md5sig_key *tcp_md5_do_lookup_exact(const struct sock *sk, 1281 1286 const union tcp_md5_addr *addr, ··· 1321 1328 addr = (const union tcp_md5_addr *)&addr_sk->sk_daddr; 1322 1329 return tcp_md5_do_lookup(sk, l3index, addr, AF_INET); 1323 1330 } 1324 - EXPORT_IPV6_MOD(tcp_v4_md5_lookup); 1325 1331 1326 1332 static int tcp_md5sig_info_add(struct sock *sk, gfp_t gfp) 1327 1333 { ··· 1415 1423 return __tcp_md5_do_add(sk, addr, family, prefixlen, l3index, flags, 1416 1424 newkey, newkeylen, GFP_KERNEL); 1417 1425 } 1418 - EXPORT_IPV6_MOD(tcp_md5_do_add); 1419 1426 1420 1427 int tcp_md5_key_copy(struct sock *sk, const union tcp_md5_addr *addr, 1421 1428 int family, u8 prefixlen, int l3index, ··· 1442 1451 key->flags, key->key, key->keylen, 1443 1452 sk_gfp_mask(sk, GFP_ATOMIC)); 1444 1453 } 1445 - EXPORT_IPV6_MOD(tcp_md5_key_copy); 1446 1454 1447 1455 int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family, 1448 1456 u8 prefixlen, int l3index, u8 flags) ··· 1456 1466 kfree_rcu(key, rcu); 1457 1467 return 0; 1458 1468 } 1459 - EXPORT_IPV6_MOD(tcp_md5_do_del); 1460 1469 1461 1470 void tcp_clear_md5_list(struct sock *sk) 1462 1471 { ··· 1593 1604 tcp_md5_hash_key(&ctx, key); 1594 1605 md5_final(&ctx, md5_hash); 1595 1606 } 1596 - EXPORT_IPV6_MOD(tcp_v4_md5_hash_skb); 1597 1607 1598 1608 #endif 1599 1609 ··· 1662 1674 tcp_listendrop(sk); 1663 1675 return 0; 1664 1676 } 1665 - EXPORT_IPV6_MOD(tcp_v4_conn_request); 1666 1677 1667 1678 1668 1679 /* ··· 1787 1800 tcp_done(newsk); 1788 1801 goto exit; 1789 1802 } 1790 - EXPORT_IPV6_MOD(tcp_v4_syn_recv_sock); 1791 1803 1792 1804 static struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb) 1793 1805 { ··· 2041 2055 } 2042 2056 return false; 2043 2057 } 2044 - EXPORT_IPV6_MOD(tcp_add_backlog); 2045 2058 2046 2059 static void tcp_v4_restore_cb(struct sk_buff *skb) 2047 2060 { ··· 2352 2367 sk->sk_rx_dst_ifindex = skb->skb_iif; 2353 2368 } 2354 2369 } 2355 - EXPORT_IPV6_MOD(inet_sk_rx_dst_set); 2356 2370 2357 2371 const struct inet_connection_sock_af_ops ipv4_specific = { 2358 2372 .queue_xmit = ip_queue_xmit, ··· 2364 2380 .getsockopt = ip_getsockopt, 2365 2381 .mtu_reduced = tcp_v4_mtu_reduced, 2366 2382 }; 2367 - EXPORT_IPV6_MOD(ipv4_specific); 2368 2383 2369 2384 #if defined(CONFIG_TCP_MD5SIG) || defined(CONFIG_TCP_AO) 2370 2385 static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = { ··· 2456 2473 2457 2474 sk_sockets_allocated_dec(sk); 2458 2475 } 2459 - EXPORT_IPV6_MOD(tcp_v4_destroy_sock); 2460 2476 2461 2477 #ifdef CONFIG_PROC_FS 2462 2478 /* Proc filesystem TCP sock list dumping. */ ··· 2691 2709 st->last_pos = *pos; 2692 2710 return rc; 2693 2711 } 2694 - EXPORT_IPV6_MOD(tcp_seq_start); 2695 2712 2696 2713 void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2697 2714 { ··· 2721 2740 st->last_pos = *pos; 2722 2741 return rc; 2723 2742 } 2724 - EXPORT_IPV6_MOD(tcp_seq_next); 2725 2743 2726 2744 void tcp_seq_stop(struct seq_file *seq, void *v) 2727 2745 { ··· 2738 2758 break; 2739 2759 } 2740 2760 } 2741 - EXPORT_IPV6_MOD(tcp_seq_stop); 2742 2761 2743 2762 static void get_openreq4(const struct request_sock *req, 2744 2763 struct seq_file *f, int i)
-4
net/ipv4/tcp_minisocks.c
··· 287 287 inet_twsk_put(tw); 288 288 return TCP_TW_SUCCESS; 289 289 } 290 - EXPORT_IPV6_MOD(tcp_timewait_state_process); 291 290 292 291 static void tcp_time_wait_init(struct sock *sk, struct tcp_timewait_sock *tcptw) 293 292 { ··· 522 523 523 524 tcp_set_ca_state(sk, TCP_CA_Open); 524 525 } 525 - EXPORT_IPV6_MOD_GPL(tcp_ca_openreq_child); 526 526 527 527 static void smc_check_reset_syn_req(const struct tcp_sock *oldtp, 528 528 struct request_sock *req, ··· 974 976 } 975 977 return NULL; 976 978 } 977 - EXPORT_IPV6_MOD(tcp_check_req); 978 979 979 980 /* 980 981 * Queue segment on the new socket if the new socket is active, ··· 1015 1018 sock_put(child); 1016 1019 return reason; 1017 1020 } 1018 - EXPORT_IPV6_MOD(tcp_child_process);
-6
net/ipv4/tcp_output.c
··· 272 272 WRITE_ONCE(*__window_clamp, 273 273 min_t(__u32, U16_MAX << (*rcv_wscale), window_clamp)); 274 274 } 275 - EXPORT_IPV6_MOD(tcp_select_initial_window); 276 275 277 276 /* Chose a new window to advertise, update state in tcp_sock for the 278 277 * socket, and return result with RFC1323 scaling applied. The return ··· 1360 1361 if ((flags & TCPF_ACK_DEFERRED) && inet_csk_ack_scheduled(sk)) 1361 1362 tcp_send_ack(sk); 1362 1363 } 1363 - EXPORT_IPV6_MOD(tcp_release_cb); 1364 1364 1365 1365 void __init tcp_tsq_work_init(void) 1366 1366 { ··· 2021 2023 return __tcp_mtu_to_mss(sk, pmtu) - 2022 2024 (tcp_sk(sk)->tcp_header_len - sizeof(struct tcphdr)); 2023 2025 } 2024 - EXPORT_IPV6_MOD(tcp_mtu_to_mss); 2025 2026 2026 2027 /* Inverse of above */ 2027 2028 int tcp_mss_to_mtu(struct sock *sk, int mss) ··· 2093 2096 2094 2097 return mss_now; 2095 2098 } 2096 - EXPORT_IPV6_MOD(tcp_sync_mss); 2097 2099 2098 2100 /* Compute the current effective MSS, taking SACKs and IP options, 2099 2101 * and even PMTU discovery events into account. ··· 4073 4077 4074 4078 return skb; 4075 4079 } 4076 - EXPORT_IPV6_MOD(tcp_make_synack); 4077 4080 4078 4081 static void tcp_ca_dst_init(struct sock *sk, const struct dst_entry *dst) 4079 4082 { ··· 4653 4658 } 4654 4659 return res; 4655 4660 } 4656 - EXPORT_IPV6_MOD(tcp_rtx_synack);
-1
net/ipv4/tcp_timer.c
··· 774 774 else if (!val) 775 775 tcp_delete_keepalive_timer(sk); 776 776 } 777 - EXPORT_IPV6_MOD_GPL(tcp_set_keepalive); 778 777 779 778 static void tcp_keepalive_timer(struct timer_list *t) 780 779 {
+2 -34
net/ipv4/udp.c
··· 118 118 #include <net/addrconf.h> 119 119 #include <net/udp_tunnel.h> 120 120 #include <net/gro.h> 121 - #if IS_ENABLED(CONFIG_IPV6) 122 - #include <net/ipv6_stubs.h> 123 - #endif 124 121 #include <net/rps.h> 125 122 126 123 struct udp_table udp_table __read_mostly; 127 124 128 125 long sysctl_udp_mem[3] __read_mostly; 129 - EXPORT_IPV6_MOD(sysctl_udp_mem); 130 126 131 127 DEFINE_PER_CPU(int, udp_memory_per_cpu_fw_alloc); 132 128 EXPORT_PER_CPU_SYMBOL_GPL(udp_memory_per_cpu_fw_alloc); ··· 345 349 fail: 346 350 return error; 347 351 } 348 - EXPORT_IPV6_MOD(udp_lib_get_port); 349 352 350 353 static int udp_v4_get_port(struct sock *sk, unsigned short snum) 351 354 { ··· 410 415 return __inet_ehashfn(laddr, lport, faddr, fport, 411 416 udp_ehash_secret + net_hash_mix(net)); 412 417 } 413 - EXPORT_IPV6_MOD(udp_ehashfn); 414 418 415 419 /** 416 420 * udp4_lib_lookup1() - Simplified lookup using primary hash (destination port) ··· 644 650 645 651 spin_unlock_bh(&hslot->lock); 646 652 } 647 - EXPORT_IPV6_MOD(udp_lib_hash4); 648 653 649 654 /* call with sock lock */ 650 655 void udp4_hash4(struct sock *sk) ··· 659 666 660 667 udp_lib_hash4(sk, hash); 661 668 } 662 - EXPORT_IPV6_MOD(udp4_hash4); 663 669 #endif /* CONFIG_BASE_SMALL */ 664 670 665 671 /* UDP is nearly always wildcards out the wazoo, it makes no sense to try ··· 794 802 } 795 803 796 804 DEFINE_STATIC_KEY_FALSE(udp_encap_needed_key); 797 - EXPORT_IPV6_MOD(udp_encap_needed_key); 798 805 799 806 #if IS_ENABLED(CONFIG_IPV6) 800 807 DEFINE_STATIC_KEY_FALSE(udpv6_encap_needed_key); 801 - EXPORT_IPV6_MOD(udpv6_encap_needed_key); 802 808 #endif 803 809 804 810 void udp_encap_enable(void) ··· 1016 1026 ip_flush_pending_frames(sk); 1017 1027 } 1018 1028 } 1019 - EXPORT_IPV6_MOD(udp_flush_pending_frames); 1020 1029 1021 1030 /** 1022 1031 * udp4_hwcsum - handle outgoing HW checksumming ··· 1193 1204 WRITE_ONCE(up->pending, 0); 1194 1205 return err; 1195 1206 } 1196 - EXPORT_IPV6_MOD(udp_push_pending_frames); 1197 1207 1198 1208 static int __udp_cmsg_send(struct cmsghdr *cmsg, u16 *gso_size) 1199 1209 { ··· 1229 1241 1230 1242 return need_ip; 1231 1243 } 1232 - EXPORT_IPV6_MOD_GPL(udp_cmsg_send); 1233 1244 1234 1245 int udp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) 1235 1246 { ··· 1519 1532 udp_push_pending_frames(sk); 1520 1533 release_sock(sk); 1521 1534 } 1522 - EXPORT_IPV6_MOD_GPL(udp_splice_eof); 1523 1535 1524 1536 #define UDP_SKB_IS_STATELESS 0x80000000 1525 1537 ··· 1633 1647 prefetch(&skb->data); 1634 1648 udp_rmem_release(sk, udp_skb_truesize(skb), 1, false); 1635 1649 } 1636 - EXPORT_IPV6_MOD(udp_skb_destructor); 1637 1650 1638 1651 /* as above, but the caller held the rx queue lock, too */ 1639 1652 static void udp_skb_dtor_locked(struct sock *sk, struct sk_buff *skb) ··· 1785 1800 udp_drops_inc(sk); 1786 1801 return err; 1787 1802 } 1788 - EXPORT_IPV6_MOD_GPL(__udp_enqueue_schedule_skb); 1789 1803 1790 1804 void udp_destruct_common(struct sock *sk) 1791 1805 { ··· 1801 1817 udp_rmem_release(sk, total, 0, true); 1802 1818 kfree(up->udp_prod_queue); 1803 1819 } 1804 - EXPORT_IPV6_MOD_GPL(udp_destruct_common); 1805 1820 1806 1821 static void udp_destruct_sock(struct sock *sk) 1807 1822 { ··· 1838 1855 skb_release_head_state(skb); 1839 1856 __consume_stateless_skb(skb); 1840 1857 } 1841 - EXPORT_IPV6_MOD_GPL(skb_consume_udp); 1842 1858 1843 1859 static struct sk_buff *__first_packet_length(struct sock *sk, 1844 1860 struct sk_buff_head *rcvq, ··· 1919 1937 1920 1938 return 0; 1921 1939 } 1922 - EXPORT_IPV6_MOD(udp_ioctl); 1923 1940 1924 1941 struct sk_buff *__skb_recv_udp(struct sock *sk, unsigned int flags, 1925 1942 int *off, int *err) ··· 2013 2032 WARN_ON_ONCE(!skb_set_owner_sk_safe(skb, sk)); 2014 2033 return recv_actor(sk, skb); 2015 2034 } 2016 - EXPORT_IPV6_MOD(udp_read_skb); 2017 2035 2018 2036 /* 2019 2037 * This should be easy, if there is something there we ··· 2134 2154 2135 2155 return BPF_CGROUP_RUN_PROG_INET4_CONNECT_LOCK(sk, uaddr, &addr_len); 2136 2156 } 2137 - EXPORT_IPV6_MOD(udp_pre_connect); 2138 2157 2139 2158 static int udp_connect(struct sock *sk, struct sockaddr_unsized *uaddr, 2140 2159 int addr_len) ··· 2183 2204 release_sock(sk); 2184 2205 return 0; 2185 2206 } 2186 - EXPORT_IPV6_MOD(udp_disconnect); 2187 2207 2188 2208 void udp_lib_unhash(struct sock *sk) 2189 2209 { ··· 2214 2236 spin_unlock_bh(&hslot->lock); 2215 2237 } 2216 2238 } 2217 - EXPORT_IPV6_MOD(udp_lib_unhash); 2218 2239 2219 2240 /* 2220 2241 * inet_rcv_saddr was changed, we must rehash secondary hash ··· 2283 2306 udp_sk(sk)->udp_portaddr_hash = newhash; 2284 2307 } 2285 2308 } 2286 - EXPORT_IPV6_MOD(udp_lib_rehash); 2287 2309 2288 2310 static void udp_v4_rehash(struct sock *sk) 2289 2311 { ··· 2446 2470 } 2447 2471 return false; 2448 2472 } 2449 - EXPORT_IPV6_MOD(udp_sk_rx_dst_set); 2450 2473 2451 2474 /* 2452 2475 * Multicasts and broadcasts go to each listener. ··· 2852 2877 2853 2878 if (udp_test_bit(GRO_ENABLED, sk) && encap_type == UDP_ENCAP_ESPINUDP) { 2854 2879 if (IS_ENABLED(CONFIG_IPV6) && family == AF_INET6) 2855 - new_gro_receive = ipv6_stub->xfrm6_gro_udp_encap_rcv; 2880 + new_gro_receive = xfrm6_gro_udp_encap_rcv; 2856 2881 else 2857 2882 new_gro_receive = xfrm4_gro_udp_encap_rcv; 2858 2883 ··· 2924 2949 #if IS_ENABLED(CONFIG_IPV6) 2925 2950 if (sk->sk_family == AF_INET6) 2926 2951 WRITE_ONCE(up->encap_rcv, 2927 - ipv6_stub->xfrm6_udp_encap_rcv); 2952 + xfrm6_udp_encap_rcv); 2928 2953 else 2929 2954 #endif 2930 2955 WRITE_ONCE(up->encap_rcv, ··· 2974 2999 2975 3000 return err; 2976 3001 } 2977 - EXPORT_IPV6_MOD(udp_lib_setsockopt); 2978 3002 2979 3003 static int udp_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval, 2980 3004 unsigned int optlen) ··· 3034 3060 return -EFAULT; 3035 3061 return 0; 3036 3062 } 3037 - EXPORT_IPV6_MOD(udp_lib_getsockopt); 3038 3063 3039 3064 static int udp_getsockopt(struct sock *sk, int level, int optname, 3040 3065 char __user *optval, int __user *optlen) ··· 3075 3102 return mask; 3076 3103 3077 3104 } 3078 - EXPORT_IPV6_MOD(udp_poll); 3079 3105 3080 3106 int udp_abort(struct sock *sk, int err) 3081 3107 { ··· 3097 3125 3098 3126 return 0; 3099 3127 } 3100 - EXPORT_IPV6_MOD_GPL(udp_abort); 3101 3128 3102 3129 struct proto udp_prot = { 3103 3130 .name = "UDP", ··· 3216 3245 3217 3246 return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN; 3218 3247 } 3219 - EXPORT_IPV6_MOD(udp_seq_start); 3220 3248 3221 3249 void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos) 3222 3250 { ··· 3229 3259 ++*pos; 3230 3260 return sk; 3231 3261 } 3232 - EXPORT_IPV6_MOD(udp_seq_next); 3233 3262 3234 3263 void udp_seq_stop(struct seq_file *seq, void *v) 3235 3264 { ··· 3240 3271 if (state->bucket <= udptable->mask) 3241 3272 spin_unlock_bh(&udptable->hash[state->bucket].lock); 3242 3273 } 3243 - EXPORT_IPV6_MOD(udp_seq_stop); 3244 3274 3245 3275 /* ------------------------------------------------------------------------ */ 3246 3276 static void udp4_format_sock(struct sock *sp, struct seq_file *f,
+1 -5
net/ipv6/Kconfig
··· 3 3 # IPv6 configuration 4 4 # 5 5 6 - # IPv6 as module will cause a CRASH if you try to unload it 7 6 menuconfig IPV6 8 - tristate "The IPv6 protocol" 7 + bool "The IPv6 protocol" 9 8 default y 10 9 select CRYPTO_LIB_SHA1 11 10 help ··· 15 16 For specific information about IPv6 under Linux, see 16 17 Documentation/networking/ipv6.rst and read the HOWTO at 17 18 <https://www.tldp.org/HOWTO/Linux+IPv6-HOWTO/> 18 - 19 - To compile this protocol support as a module, choose M here: the 20 - module will be called ipv6. 21 19 22 20 if IPV6 23 21
-91
net/ipv6/addrconf_core.c
··· 6 6 7 7 #include <linux/export.h> 8 8 #include <net/ipv6.h> 9 - #include <net/ipv6_stubs.h> 10 9 #include <net/addrconf.h> 11 10 #include <net/ip.h> 12 11 ··· 127 128 return blocking_notifier_call_chain(&inet6addr_validator_chain, val, v); 128 129 } 129 130 EXPORT_SYMBOL(inet6addr_validator_notifier_call_chain); 130 - 131 - static struct dst_entry *eafnosupport_ipv6_dst_lookup_flow(struct net *net, 132 - const struct sock *sk, 133 - struct flowi6 *fl6, 134 - const struct in6_addr *final_dst) 135 - { 136 - return ERR_PTR(-EAFNOSUPPORT); 137 - } 138 - 139 - static int eafnosupport_ipv6_route_input(struct sk_buff *skb) 140 - { 141 - return -EAFNOSUPPORT; 142 - } 143 - 144 - static struct fib6_table *eafnosupport_fib6_get_table(struct net *net, u32 id) 145 - { 146 - return NULL; 147 - } 148 - 149 - static int 150 - eafnosupport_fib6_table_lookup(struct net *net, struct fib6_table *table, 151 - int oif, struct flowi6 *fl6, 152 - struct fib6_result *res, int flags) 153 - { 154 - return -EAFNOSUPPORT; 155 - } 156 - 157 - static int 158 - eafnosupport_fib6_lookup(struct net *net, int oif, struct flowi6 *fl6, 159 - struct fib6_result *res, int flags) 160 - { 161 - return -EAFNOSUPPORT; 162 - } 163 - 164 - static void 165 - eafnosupport_fib6_select_path(const struct net *net, struct fib6_result *res, 166 - struct flowi6 *fl6, int oif, bool have_oif_match, 167 - const struct sk_buff *skb, int strict) 168 - { 169 - } 170 - 171 - static u32 172 - eafnosupport_ip6_mtu_from_fib6(const struct fib6_result *res, 173 - const struct in6_addr *daddr, 174 - const struct in6_addr *saddr) 175 - { 176 - return 0; 177 - } 178 - 179 - static int eafnosupport_fib6_nh_init(struct net *net, struct fib6_nh *fib6_nh, 180 - struct fib6_config *cfg, gfp_t gfp_flags, 181 - struct netlink_ext_ack *extack) 182 - { 183 - NL_SET_ERR_MSG(extack, "IPv6 support not enabled in kernel"); 184 - return -EAFNOSUPPORT; 185 - } 186 - 187 - static int eafnosupport_ip6_del_rt(struct net *net, struct fib6_info *rt, 188 - bool skip_notify) 189 - { 190 - return -EAFNOSUPPORT; 191 - } 192 - 193 - static int eafnosupport_ipv6_fragment(struct net *net, struct sock *sk, struct sk_buff *skb, 194 - int (*output)(struct net *, struct sock *, struct sk_buff *)) 195 - { 196 - kfree_skb(skb); 197 - return -EAFNOSUPPORT; 198 - } 199 - 200 - static struct net_device *eafnosupport_ipv6_dev_find(struct net *net, const struct in6_addr *addr, 201 - struct net_device *dev) 202 - { 203 - return ERR_PTR(-EAFNOSUPPORT); 204 - } 205 - 206 - const struct ipv6_stub *ipv6_stub __read_mostly = &(struct ipv6_stub) { 207 - .ipv6_dst_lookup_flow = eafnosupport_ipv6_dst_lookup_flow, 208 - .ipv6_route_input = eafnosupport_ipv6_route_input, 209 - .fib6_get_table = eafnosupport_fib6_get_table, 210 - .fib6_table_lookup = eafnosupport_fib6_table_lookup, 211 - .fib6_lookup = eafnosupport_fib6_lookup, 212 - .fib6_select_path = eafnosupport_fib6_select_path, 213 - .ip6_mtu_from_fib6 = eafnosupport_ip6_mtu_from_fib6, 214 - .fib6_nh_init = eafnosupport_fib6_nh_init, 215 - .ip6_del_rt = eafnosupport_ip6_del_rt, 216 - .ipv6_fragment = eafnosupport_ipv6_fragment, 217 - .ipv6_dev_find = eafnosupport_ipv6_dev_find, 218 - }; 219 - EXPORT_SYMBOL_GPL(ipv6_stub); 220 131 221 132 /* IPv6 Wildcard Address and Loopback Address defined by RFC2553 */ 222 133 const struct in6_addr in6addr_loopback __aligned(BITS_PER_LONG/8)
+3 -64
net/ipv6/af_inet6.c
··· 38 38 #include <linux/inet.h> 39 39 #include <linux/netdevice.h> 40 40 #include <linux/icmpv6.h> 41 - #include <linux/netfilter_ipv6.h> 42 41 43 42 #include <net/ip.h> 44 43 #include <net/ipv6.h> ··· 50 51 #include <net/transp_v6.h> 51 52 #include <net/ip6_route.h> 52 53 #include <net/addrconf.h> 53 - #include <net/ipv6_stubs.h> 54 54 #include <net/ndisc.h> 55 55 #ifdef CONFIG_IPV6_TUNNEL 56 56 #include <net/ip6_tunnel.h> ··· 67 69 #include <linux/mroute6.h> 68 70 69 71 #include "ip6_offload.h" 70 - 71 - MODULE_AUTHOR("Cast of dozens"); 72 - MODULE_DESCRIPTION("IPv6 protocol stack for Linux"); 73 - MODULE_LICENSE("GPL"); 74 72 75 73 /* The inetsw6 table contains everything that inet6_create needs to 76 74 * build a new socket. ··· 262 268 goto out; 263 269 } 264 270 265 - static int __inet6_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len, 266 - u32 flags) 271 + int __inet6_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len, 272 + u32 flags) 267 273 { 268 274 struct sockaddr_in6 *addr = (struct sockaddr_in6 *)uaddr; 269 275 struct inet_sock *inet = inet_sk(sk); ··· 994 1000 .exit = inet6_net_exit, 995 1001 }; 996 1002 997 - static int ipv6_route_input(struct sk_buff *skb) 998 - { 999 - ip6_route_input(skb); 1000 - return skb_dst(skb)->error; 1001 - } 1002 - 1003 - static const struct ipv6_stub ipv6_stub_impl = { 1004 - .ipv6_sock_mc_join = ipv6_sock_mc_join, 1005 - .ipv6_sock_mc_drop = ipv6_sock_mc_drop, 1006 - .ipv6_dst_lookup_flow = ip6_dst_lookup_flow, 1007 - .ipv6_route_input = ipv6_route_input, 1008 - .fib6_get_table = fib6_get_table, 1009 - .fib6_table_lookup = fib6_table_lookup, 1010 - .fib6_lookup = fib6_lookup, 1011 - .fib6_select_path = fib6_select_path, 1012 - .ip6_mtu_from_fib6 = ip6_mtu_from_fib6, 1013 - .fib6_nh_init = fib6_nh_init, 1014 - .fib6_nh_release = fib6_nh_release, 1015 - .fib6_nh_release_dsts = fib6_nh_release_dsts, 1016 - .fib6_update_sernum = fib6_update_sernum_stub, 1017 - .fib6_rt_update = fib6_rt_update, 1018 - .ip6_del_rt = ip6_del_rt, 1019 - .udpv6_encap_enable = udpv6_encap_enable, 1020 - .ndisc_send_na = ndisc_send_na, 1021 - #if IS_ENABLED(CONFIG_XFRM) 1022 - .xfrm6_local_rxpmtu = xfrm6_local_rxpmtu, 1023 - .xfrm6_udp_encap_rcv = xfrm6_udp_encap_rcv, 1024 - .xfrm6_gro_udp_encap_rcv = xfrm6_gro_udp_encap_rcv, 1025 - .xfrm6_rcv_encap = xfrm6_rcv_encap, 1026 - #endif 1027 - .nd_tbl = &nd_tbl, 1028 - .ipv6_fragment = ip6_fragment, 1029 - .ipv6_dev_find = ipv6_dev_find, 1030 - .ip6_xmit = ip6_xmit, 1031 - }; 1032 - 1033 - static const struct ipv6_bpf_stub ipv6_bpf_stub_impl = { 1034 - .inet6_bind = __inet6_bind, 1035 - .udp6_lib_lookup = __udp6_lib_lookup, 1036 - .ipv6_setsockopt = do_ipv6_setsockopt, 1037 - .ipv6_getsockopt = do_ipv6_getsockopt, 1038 - .ipv6_dev_get_saddr = ipv6_dev_get_saddr, 1039 - }; 1040 - 1041 1003 static int __init inet6_init(void) 1042 1004 { 1043 1005 struct list_head *r; ··· 1065 1115 if (err) 1066 1116 goto igmp_fail; 1067 1117 1068 - err = ipv6_netfilter_init(); 1069 - if (err) 1070 - goto netfilter_fail; 1071 1118 /* Create /proc/foo6 entries. */ 1072 1119 #ifdef CONFIG_PROC_FS 1073 1120 err = -ENOMEM; ··· 1147 1200 goto sysctl_fail; 1148 1201 #endif 1149 1202 1150 - /* ensure that ipv6 stubs are visible only after ipv6 is ready */ 1151 - wmb(); 1152 - ipv6_stub = &ipv6_stub_impl; 1153 - ipv6_bpf_stub = &ipv6_bpf_stub_impl; 1154 1203 out: 1155 1204 return err; 1156 1205 ··· 1195 1252 raw6_proc_exit(); 1196 1253 proc_raw6_fail: 1197 1254 #endif 1198 - ipv6_netfilter_fini(); 1199 - netfilter_fail: 1200 1255 igmp6_cleanup(); 1201 1256 igmp_fail: 1202 1257 ndisc_cleanup(); ··· 1219 1278 proto_unregister(&tcpv6_prot); 1220 1279 goto out; 1221 1280 } 1222 - module_init(inet6_init); 1223 - 1224 - MODULE_ALIAS_NETPROTO(PF_INET6); 1281 + device_initcall(inet6_init);
-6
net/ipv6/icmp.c
··· 1288 1288 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) 1289 1289 goto fail; 1290 1290 1291 - err = inet6_register_icmp_sender(icmp6_send); 1292 - if (err) 1293 - goto sender_reg_err; 1294 1291 return 0; 1295 1292 1296 - sender_reg_err: 1297 - inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6); 1298 1293 fail: 1299 1294 pr_err("Failed to register ICMP6 protocol\n"); 1300 1295 return err; ··· 1297 1302 1298 1303 void icmpv6_cleanup(void) 1299 1304 { 1300 - inet6_unregister_icmp_sender(icmp6_send); 1301 1305 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6); 1302 1306 } 1303 1307
+1 -9
net/ipv6/ip6_fib.c
··· 1408 1408 __fib6_update_sernum_upto_root(rt, fib6_new_sernum(net)); 1409 1409 } 1410 1410 1411 - /* allow ipv4 to update sernum via ipv6_stub */ 1412 - void fib6_update_sernum_stub(struct net *net, struct fib6_info *f6i) 1413 - { 1414 - spin_lock_bh(&f6i->fib6_table->tb6_lock); 1415 - fib6_update_sernum_upto_root(net, f6i); 1416 - spin_unlock_bh(&f6i->fib6_table->tb6_lock); 1417 - } 1418 - 1419 1411 /* 1420 1412 * Add routing information to the routing tree. 1421 1413 * <destination addr>/<source addr> ··· 2766 2774 rcu_read_unlock(); 2767 2775 } 2768 2776 2769 - #if IS_BUILTIN(CONFIG_IPV6) && defined(CONFIG_BPF_SYSCALL) 2777 + #if defined(CONFIG_BPF_SYSCALL) 2770 2778 static int ipv6_route_prog_seq_show(struct bpf_prog *prog, 2771 2779 struct bpf_iter_meta *meta, 2772 2780 void *v)
+3 -43
net/ipv6/ip6_icmp.c
··· 7 7 8 8 #include <net/ipv6.h> 9 9 10 - #if IS_ENABLED(CONFIG_IPV6) 10 + #if IS_ENABLED(CONFIG_IPV6) && IS_ENABLED(CONFIG_NF_NAT) 11 11 12 - #if !IS_BUILTIN(CONFIG_IPV6) 13 - 14 - static ip6_icmp_send_t __rcu *ip6_icmp_send; 15 - 16 - int inet6_register_icmp_sender(ip6_icmp_send_t *fn) 17 - { 18 - return (cmpxchg((ip6_icmp_send_t **)&ip6_icmp_send, NULL, fn) == NULL) ? 19 - 0 : -EBUSY; 20 - } 21 - EXPORT_SYMBOL(inet6_register_icmp_sender); 22 - 23 - int inet6_unregister_icmp_sender(ip6_icmp_send_t *fn) 24 - { 25 - int ret; 26 - 27 - ret = (cmpxchg((ip6_icmp_send_t **)&ip6_icmp_send, fn, NULL) == fn) ? 28 - 0 : -EINVAL; 29 - 30 - synchronize_net(); 31 - 32 - return ret; 33 - } 34 - EXPORT_SYMBOL(inet6_unregister_icmp_sender); 35 - 36 - void __icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info, 37 - const struct inet6_skb_parm *parm) 38 - { 39 - ip6_icmp_send_t *send; 40 - 41 - rcu_read_lock(); 42 - send = rcu_dereference(ip6_icmp_send); 43 - if (send) 44 - send(skb, type, code, info, NULL, parm); 45 - rcu_read_unlock(); 46 - } 47 - EXPORT_SYMBOL(__icmpv6_send); 48 - #endif 49 - 50 - #if IS_ENABLED(CONFIG_NF_NAT) 51 12 #include <net/netfilter/nf_conntrack.h> 52 13 void icmpv6_ndo_send(struct sk_buff *skb_in, u8 type, u8 code, __u32 info) 53 14 { ··· 21 60 22 61 ct = nf_ct_get(skb_in, &ctinfo); 23 62 if (!ct || !(READ_ONCE(ct->status) & IPS_NAT_MASK)) { 24 - __icmpv6_send(skb_in, type, code, info, &parm); 63 + icmp6_send(skb_in, type, code, info, NULL, &parm); 25 64 return; 26 65 } 27 66 ··· 37 76 orig_ip = ipv6_hdr(skb_in)->saddr; 38 77 dir = CTINFO2DIR(ctinfo); 39 78 ipv6_hdr(skb_in)->saddr = ct->tuplehash[dir].tuple.src.u3.in6; 40 - __icmpv6_send(skb_in, type, code, info, &parm); 79 + icmp6_send(skb_in, type, code, info, NULL, &parm); 41 80 ipv6_hdr(skb_in)->saddr = orig_ip; 42 81 out: 43 82 consume_skb(cloned_skb); 44 83 } 45 84 EXPORT_SYMBOL(icmpv6_ndo_send); 46 - #endif 47 85 #endif
+2 -2
net/ipv6/ip6_offload.c
··· 286 286 287 287 if (likely(proto == IPPROTO_TCP)) 288 288 pp = tcp6_gro_receive(head, skb); 289 - #if IS_BUILTIN(CONFIG_IPV6) 289 + #if IS_ENABLED(CONFIG_IPV6) 290 290 else if (likely(proto == IPPROTO_UDP)) 291 291 pp = udp6_gro_receive(head, skb); 292 292 #endif ··· 346 346 347 347 if (likely(ops == &net_hotdata.tcpv6_offload)) 348 348 return tcp6_gro_complete(skb, nhoff); 349 - #if IS_BUILTIN(CONFIG_IPV6) 349 + #if IS_ENABLED(CONFIG_IPV6) 350 350 if (ops == &net_hotdata.udpv6_offload) 351 351 return udp6_gro_complete(skb, nhoff); 352 352 #endif
+8
net/ipv6/ip6_output.c
··· 873 873 __be32 frag_id; 874 874 u8 *prevhdr, nexthdr = 0; 875 875 876 + if (!ipv6_mod_enabled()) { 877 + kfree_skb(skb); 878 + return -EAFNOSUPPORT; 879 + } 880 + 876 881 err = ip6_find_1stfragopt(skb, &prevhdr); 877 882 if (err < 0) 878 883 goto fail; ··· 1050 1045 kfree_skb(skb); 1051 1046 return err; 1052 1047 } 1048 + EXPORT_SYMBOL_GPL(ip6_fragment); 1053 1049 1054 1050 static inline int ip6_rt_check(const struct rt6key *rt_key, 1055 1051 const struct in6_addr *fl_addr, ··· 1262 1256 struct dst_entry *dst = NULL; 1263 1257 int err; 1264 1258 1259 + if (!ipv6_mod_enabled()) 1260 + return ERR_PTR(-EAFNOSUPPORT); 1265 1261 err = ip6_dst_lookup_tail(net, sk, &dst, fl6); 1266 1262 if (err) 1267 1263 return ERR_PTR(err);
+1 -2
net/ipv6/ip6_udp_tunnel.c
··· 162 162 fl6.fl6_dport = dport; 163 163 fl6.flowlabel = ip6_make_flowinfo(dsfield, key->label); 164 164 165 - dst = ipv6_stub->ipv6_dst_lookup_flow(net, sock->sk, &fl6, 166 - NULL); 165 + dst = ip6_dst_lookup_flow(net, sock->sk, &fl6, NULL); 167 166 if (IS_ERR(dst)) { 168 167 netdev_dbg(dev, "no route to %pI6\n", &fl6.daddr); 169 168 return ERR_PTR(-ENETUNREACH);
+1
net/ipv6/ndisc.c
··· 576 576 577 577 ndisc_send_skb(skb, daddr, src_addr); 578 578 } 579 + EXPORT_SYMBOL_GPL(ndisc_send_na); 579 580 580 581 static void ndisc_send_unsol_na(struct net_device *dev) 581 582 {
-48
net/ipv6/netfilter.c
··· 86 86 } 87 87 EXPORT_SYMBOL(ip6_route_me_harder); 88 88 89 - static int nf_ip6_reroute(struct sk_buff *skb, 90 - const struct nf_queue_entry *entry) 91 - { 92 - struct ip6_rt_info *rt_info = nf_queue_entry_reroute(entry); 93 - 94 - if (entry->state.hook == NF_INET_LOCAL_OUT) { 95 - const struct ipv6hdr *iph = ipv6_hdr(skb); 96 - if (!ipv6_addr_equal(&iph->daddr, &rt_info->daddr) || 97 - !ipv6_addr_equal(&iph->saddr, &rt_info->saddr) || 98 - skb->mark != rt_info->mark) 99 - return ip6_route_me_harder(entry->state.net, entry->state.sk, skb); 100 - } 101 - return 0; 102 - } 103 - 104 89 int __nf_ip6_route(struct net *net, struct dst_entry **dst, 105 90 struct flowi *fl, bool strict) 106 91 { ··· 228 243 return 0; 229 244 } 230 245 EXPORT_SYMBOL_GPL(br_ip6_fragment); 231 - 232 - static const struct nf_ipv6_ops ipv6ops = { 233 - #if IS_MODULE(CONFIG_IPV6) 234 - .chk_addr = ipv6_chk_addr, 235 - .route_me_harder = ip6_route_me_harder, 236 - .dev_get_saddr = ipv6_dev_get_saddr, 237 - .route = __nf_ip6_route, 238 - #if IS_ENABLED(CONFIG_SYN_COOKIES) 239 - .cookie_init_sequence = __cookie_v6_init_sequence, 240 - .cookie_v6_check = __cookie_v6_check, 241 - #endif 242 - #endif 243 - .route_input = ip6_route_input, 244 - .fragment = ip6_fragment, 245 - .reroute = nf_ip6_reroute, 246 - #if IS_MODULE(CONFIG_IPV6) 247 - .br_fragment = br_ip6_fragment, 248 - #endif 249 - }; 250 - 251 - int __init ipv6_netfilter_init(void) 252 - { 253 - RCU_INIT_POINTER(nf_ipv6_ops, &ipv6ops); 254 - return 0; 255 - } 256 - 257 - /* This can be called from inet6_init() on errors, so it cannot 258 - * be marked __exit. -DaveM 259 - */ 260 - void ipv6_netfilter_fini(void) 261 - { 262 - RCU_INIT_POINTER(nf_ipv6_ops, NULL); 263 - }
+6 -6
net/ipv6/route.c
··· 2655 2655 skb_dst_set_noref(skb, ip6_route_input_lookup(net, skb->dev, 2656 2656 &fl6, skb, flags)); 2657 2657 } 2658 + EXPORT_SYMBOL_GPL(ip6_route_input); 2658 2659 2659 2660 INDIRECT_CALLABLE_SCOPE struct rt6_info *ip6_pol_route_output(struct net *net, 2660 2661 struct fib6_table *table, ··· 3585 3584 struct net_device *dev = NULL; 3586 3585 struct inet6_dev *idev = NULL; 3587 3586 int err; 3587 + 3588 + if (!ipv6_mod_enabled()) { 3589 + NL_SET_ERR_MSG(extack, "IPv6 support not enabled in kernel"); 3590 + return -EAFNOSUPPORT; 3591 + } 3588 3592 3589 3593 fib6_nh->fib_nh_family = AF_INET6; 3590 3594 #ifdef CONFIG_IPV6_ROUTER_PREF ··· 6832 6826 #endif 6833 6827 } 6834 6828 6835 - #if IS_BUILTIN(CONFIG_IPV6) 6836 6829 #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_PROC_FS) 6837 6830 DEFINE_BPF_ITER_FUNC(ipv6_route, struct bpf_iter_meta *meta, struct fib6_info *rt) 6838 6831 ··· 6864 6859 { 6865 6860 bpf_iter_unreg_target(&ipv6_route_reg_info); 6866 6861 } 6867 - #endif 6868 6862 #endif 6869 6863 6870 6864 static const struct rtnl_msg_handler ip6_route_rtnl_msg_handlers[] __initconst_or_module = { ··· 6925 6921 if (ret) 6926 6922 goto out_register_late_subsys; 6927 6923 6928 - #if IS_BUILTIN(CONFIG_IPV6) 6929 6924 #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_PROC_FS) 6930 6925 ret = bpf_iter_register(); 6931 6926 if (ret) 6932 6927 goto out_register_late_subsys; 6933 - #endif 6934 6928 #endif 6935 6929 6936 6930 for_each_possible_cpu(cpu) { ··· 6963 6961 6964 6962 void ip6_route_cleanup(void) 6965 6963 { 6966 - #if IS_BUILTIN(CONFIG_IPV6) 6967 6964 #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_PROC_FS) 6968 6965 bpf_iter_unregister(); 6969 - #endif 6970 6966 #endif 6971 6967 unregister_netdevice_notifier(&ip6_route_dev_notifier); 6972 6968 unregister_pernet_subsys(&ip6_route_net_late_ops);
-1
net/l2tp/Kconfig
··· 5 5 6 6 menuconfig L2TP 7 7 tristate "Layer Two Tunneling Protocol (L2TP)" 8 - depends on (IPV6 || IPV6=n) 9 8 depends on INET 10 9 select NET_UDP_TUNNEL 11 10 help
+1 -2
net/mpls/af_mpls.c
··· 24 24 #if IS_ENABLED(CONFIG_IPV6) 25 25 #include <net/ipv6.h> 26 26 #endif 27 - #include <net/ipv6_stubs.h> 28 27 #include <net/rtnh.h> 29 28 #include "internal.h" 30 29 ··· 641 642 642 643 memset(&fl6, 0, sizeof(fl6)); 643 644 memcpy(&fl6.daddr, addr, sizeof(struct in6_addr)); 644 - dst = ipv6_stub->ipv6_dst_lookup_flow(net, NULL, &fl6, NULL); 645 + dst = ip6_dst_lookup_flow(net, NULL, &fl6, NULL); 645 646 if (IS_ERR(dst)) 646 647 return ERR_CAST(dst); 647 648
-8
net/netfilter/Kconfig
··· 249 249 250 250 config NF_CONNTRACK_H323 251 251 tristate "H.323 protocol support" 252 - depends on IPV6 || IPV6=n 253 252 depends on NETFILTER_ADVANCED 254 253 help 255 254 H.323 is a VoIP signalling protocol from ITU-T. As one of the most ··· 588 589 config NFT_REJECT 589 590 default m if NETFILTER_ADVANCED=n 590 591 tristate "Netfilter nf_tables reject support" 591 - depends on !NF_TABLES_INET || (IPV6!=m || m) 592 592 help 593 593 This option adds the "reject" expression that you can use to 594 594 explicitly deny and notify via TCP reset/ICMP informational errors ··· 634 636 635 637 config NFT_SOCKET 636 638 tristate "Netfilter nf_tables socket match support" 637 - depends on IPV6 || IPV6=n 638 639 select NF_SOCKET_IPV4 639 640 select NF_SOCKET_IPV6 if NF_TABLES_IPV6 640 641 help ··· 649 652 650 653 config NFT_TPROXY 651 654 tristate "Netfilter nf_tables tproxy support" 652 - depends on IPV6 || IPV6=n 653 655 select NF_DEFRAG_IPV4 654 656 select NF_DEFRAG_IPV6 if NF_TABLES_IPV6 655 657 select NF_TPROXY_IPV4 ··· 1067 1071 config NETFILTER_XT_TARGET_TEE 1068 1072 tristate '"TEE" - packet cloning to alternate destination' 1069 1073 depends on NETFILTER_ADVANCED 1070 - depends on IPV6 || IPV6=n 1071 1074 depends on !NF_CONNTRACK || NF_CONNTRACK 1072 1075 depends on IP6_NF_IPTABLES || !IP6_NF_IPTABLES 1073 1076 select NF_DUP_IPV4 ··· 1079 1084 tristate '"TPROXY" target transparent proxying support' 1080 1085 depends on NETFILTER_XTABLES 1081 1086 depends on NETFILTER_ADVANCED 1082 - depends on IPV6 || IPV6=n 1083 1087 depends on IP6_NF_IPTABLES || IP6_NF_IPTABLES=n 1084 1088 depends on IP_NF_MANGLE || NFT_COMPAT 1085 1089 select NF_DEFRAG_IPV4 ··· 1120 1126 1121 1127 config NETFILTER_XT_TARGET_TCPMSS 1122 1128 tristate '"TCPMSS" target support' 1123 - depends on IPV6 || IPV6=n 1124 1129 default m if NETFILTER_ADVANCED=n 1125 1130 help 1126 1131 This option adds a `TCPMSS' target, which allows you to alter the ··· 1574 1581 tristate '"socket" match support' 1575 1582 depends on NETFILTER_XTABLES 1576 1583 depends on NETFILTER_ADVANCED 1577 - depends on IPV6 || IPV6=n 1578 1584 depends on IP6_NF_IPTABLES || IP6_NF_IPTABLES=n 1579 1585 select NF_SOCKET_IPV4 1580 1586 select NF_SOCKET_IPV6 if IP6_NF_IPTABLES
-3
net/netfilter/core.c
··· 27 27 28 28 #include "nf_internals.h" 29 29 30 - const struct nf_ipv6_ops __rcu *nf_ipv6_ops __read_mostly; 31 - EXPORT_SYMBOL_GPL(nf_ipv6_ops); 32 - 33 30 #ifdef CONFIG_JUMP_LABEL 34 31 struct static_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS]; 35 32 EXPORT_SYMBOL(nf_hooks_needed);
+2 -19
net/netfilter/nf_nat_masquerade.c
··· 220 220 }; 221 221 222 222 #if IS_ENABLED(CONFIG_IPV6) 223 - static int 224 - nat_ipv6_dev_get_saddr(struct net *net, const struct net_device *dev, 225 - const struct in6_addr *daddr, unsigned int srcprefs, 226 - struct in6_addr *saddr) 227 - { 228 - #ifdef CONFIG_IPV6_MODULE 229 - const struct nf_ipv6_ops *v6_ops = nf_get_ipv6_ops(); 230 - 231 - if (!v6_ops) 232 - return -EHOSTUNREACH; 233 - 234 - return v6_ops->dev_get_saddr(net, dev, daddr, srcprefs, saddr); 235 - #else 236 - return ipv6_dev_get_saddr(net, dev, daddr, srcprefs, saddr); 237 - #endif 238 - } 239 - 240 223 unsigned int 241 224 nf_nat_masquerade_ipv6(struct sk_buff *skb, const struct nf_nat_range2 *range, 242 225 const struct net_device *out) ··· 234 251 WARN_ON(!(ct && (ctinfo == IP_CT_NEW || ctinfo == IP_CT_RELATED || 235 252 ctinfo == IP_CT_RELATED_REPLY))); 236 253 237 - if (nat_ipv6_dev_get_saddr(nf_ct_net(ct), out, 238 - &ipv6_hdr(skb)->daddr, 0, &src) < 0) 254 + if (ipv6_dev_get_saddr(nf_ct_net(ct), out, 255 + &ipv6_hdr(skb)->daddr, 0, &src) < 0) 239 256 return NF_DROP; 240 257 241 258 nat = nf_ct_nat_ext_add(ct);
-1
net/netfilter/utils.c
··· 163 163 int nf_route(struct net *net, struct dst_entry **dst, struct flowi *fl, 164 164 bool strict, unsigned short family) 165 165 { 166 - const struct nf_ipv6_ops *v6ops __maybe_unused; 167 166 int ret = 0; 168 167 169 168 switch (family) {
+2 -1
net/openvswitch/actions.c
··· 21 21 #include <net/ip.h> 22 22 #include <net/ipv6.h> 23 23 #include <net/ip6_fib.h> 24 + #include <net/ip6_route.h> 24 25 #include <net/checksum.h> 25 26 #include <net/dsfield.h> 26 27 #include <net/mpls.h> ··· 811 810 skb_dst_set_noref(skb, &ovs_rt.dst); 812 811 IP6CB(skb)->frag_max_size = mru; 813 812 814 - ipv6_stub->ipv6_fragment(net, skb->sk, skb, ovs_vport_output); 813 + ip6_fragment(net, skb->sk, skb, ovs_vport_output); 815 814 refdst_drop(orig_dst); 816 815 } else { 817 816 WARN_ONCE(1, "Failed fragment ->%s: eth=%04x, MRU=%d, MTU=%d.",
-1
net/psp/psp_sock.c
··· 291 291 skb->decrypted = 1; 292 292 rcu_read_unlock(); 293 293 } 294 - EXPORT_IPV6_MOD_GPL(psp_reply_set_decrypted);
+1 -1
net/rxrpc/Kconfig
··· 25 25 26 26 config AF_RXRPC_IPV6 27 27 bool "IPv6 support for RxRPC" 28 - depends on (IPV6 = m && AF_RXRPC = m) || (IPV6 = y && AF_RXRPC) 28 + depends on IPV6 29 29 help 30 30 Say Y here to allow AF_RXRPC to use IPV6 UDP as well as IPV4 UDP as 31 31 its network transport.
+2 -2
net/sched/sch_frag.c
··· 6 6 #include <net/dst.h> 7 7 #include <net/ip.h> 8 8 #include <net/ip6_fib.h> 9 + #include <net/ip6_route.h> 9 10 10 11 struct sch_frag_data { 11 12 unsigned long dst; ··· 128 127 skb_dst_set_noref(skb, &sch_frag_rt.dst); 129 128 IP6CB(skb)->frag_max_size = mru; 130 129 131 - ret = ipv6_stub->ipv6_fragment(net, skb->sk, skb, 132 - sch_frag_xmit); 130 + ret = ip6_fragment(net, skb->sk, skb, sch_frag_xmit); 133 131 local_unlock_nested_bh(&sch_frag_data_storage.bh_lock); 134 132 refdst_drop(orig_dst); 135 133 } else {
-1
net/sctp/Kconfig
··· 6 6 menuconfig IP_SCTP 7 7 tristate "The SCTP Protocol" 8 8 depends on INET 9 - depends on IPV6 || IPV6=n 10 9 select CRYPTO_LIB_SHA1 11 10 select CRYPTO_LIB_SHA256 12 11 select CRYPTO_LIB_UTILS
-1
net/tipc/Kconfig
··· 6 6 menuconfig TIPC 7 7 tristate "The TIPC Protocol" 8 8 depends on INET 9 - depends on IPV6 || IPV6=n 10 9 help 11 10 The Transparent Inter Process Communication (TIPC) protocol is 12 11 specially designed for intra cluster communication. This protocol
+3 -6
net/tipc/udp_media.c
··· 44 44 #include <net/sock.h> 45 45 #include <net/ip.h> 46 46 #include <net/udp_tunnel.h> 47 - #include <net/ipv6_stubs.h> 48 47 #include <linux/tipc_netlink.h> 49 48 #include "core.h" 50 49 #include "addr.h" ··· 206 207 .saddr = src->ipv6, 207 208 .flowi6_proto = IPPROTO_UDP 208 209 }; 209 - ndst = ipv6_stub->ipv6_dst_lookup_flow(net, 210 - ub->ubsock->sk, 211 - &fl6, NULL); 210 + ndst = ip6_dst_lookup_flow(net, ub->ubsock->sk, 211 + &fl6, NULL); 212 212 if (IS_ERR(ndst)) { 213 213 err = PTR_ERR(ndst); 214 214 goto tx_error; ··· 416 418 #if IS_ENABLED(CONFIG_IPV6) 417 419 } else { 418 420 lock_sock(sk); 419 - err = ipv6_stub->ipv6_sock_mc_join(sk, ub->ifindex, 420 - &remote->ipv6); 421 + err = ipv6_sock_mc_join(sk, ub->ifindex, &remote->ipv6); 421 422 release_sock(sk); 422 423 #endif 423 424 }
+1 -4
net/xfrm/espintcp.c
··· 7 7 #include <linux/skmsg.h> 8 8 #include <net/inet_common.h> 9 9 #include <trace/events/sock.h> 10 - #if IS_ENABLED(CONFIG_IPV6) 11 - #include <net/ipv6_stubs.h> 12 - #endif 13 10 #include <net/hotdata.h> 14 11 15 12 static void handle_nonesp(struct espintcp_ctx *ctx, struct sk_buff *skb, ··· 40 43 local_bh_disable(); 41 44 #if IS_ENABLED(CONFIG_IPV6) 42 45 if (sk->sk_family == AF_INET6) 43 - ipv6_stub->xfrm6_rcv_encap(skb, IPPROTO_ESP, 0, TCP_ENCAP_ESPINTCP); 46 + xfrm6_rcv_encap(skb, IPPROTO_ESP, 0, TCP_ENCAP_ESPINTCP); 44 47 else 45 48 #endif 46 49 xfrm4_rcv_encap(skb, IPPROTO_ESP, 0, TCP_ENCAP_ESPINTCP);
+2 -2
net/xfrm/xfrm_nat_keepalive.c
··· 98 98 local_lock_nested_bh(&nat_keepalive_sk_ipv6.bh_lock); 99 99 sk = this_cpu_read(nat_keepalive_sk_ipv6.sock); 100 100 sock_net_set(sk, net); 101 - dst = ipv6_stub->ipv6_dst_lookup_flow(net, sk, &fl6, NULL); 101 + dst = ip6_dst_lookup_flow(net, sk, &fl6, NULL); 102 102 if (IS_ERR(dst)) { 103 103 local_unlock_nested_bh(&nat_keepalive_sk_ipv6.bh_lock); 104 104 return PTR_ERR(dst); 105 105 } 106 106 107 107 skb_dst_set(skb, dst); 108 - err = ipv6_stub->ip6_xmit(sk, skb, &fl6, skb->mark, NULL, 0, 0); 108 + err = ip6_xmit(sk, skb, &fl6, skb->mark, NULL, 0, 0); 109 109 sock_net_set(sk, &init_net); 110 110 local_unlock_nested_bh(&nat_keepalive_sk_ipv6.bh_lock); 111 111 return err;
+1 -2
net/xfrm/xfrm_output.c
··· 20 20 21 21 #if IS_ENABLED(CONFIG_IPV6) 22 22 #include <net/ip6_route.h> 23 - #include <net/ipv6_stubs.h> 24 23 #endif 25 24 26 25 #include "xfrm_inout.h" ··· 899 900 skb->protocol = htons(ETH_P_IPV6); 900 901 901 902 if (xfrm6_local_dontfrag(sk)) 902 - ipv6_stub->xfrm6_local_rxpmtu(skb, mtu); 903 + xfrm6_local_rxpmtu(skb, mtu); 903 904 else if (sk) 904 905 xfrm_local_error(skb, mtu); 905 906 else