1 #!/bin/bash !! 1 #!/bin/sh
2 # SPDX-License-Identifier: GPL-2.0 2 # SPDX-License-Identifier: GPL-2.0
3 # 3 #
4 # Check that route PMTU values match expectati 4 # Check that route PMTU values match expectations, and that initial device MTU
5 # values are assigned correctly 5 # values are assigned correctly
6 # 6 #
7 # Tests currently implemented: 7 # Tests currently implemented:
8 # 8 #
9 # - pmtu_ipv4 9 # - pmtu_ipv4
10 # Set up two namespaces, A and B, with t 10 # Set up two namespaces, A and B, with two paths between them over routers
11 # R1 and R2 (also implemented with names 11 # R1 and R2 (also implemented with namespaces), with different MTUs:
12 # 12 #
13 # segment a_r1 segment b_r1 13 # segment a_r1 segment b_r1 a_r1: 2000
14 # .--------------R1--------------. !! 14 # .--------------R1--------------. a_r2: 1500
15 # A B !! 15 # A B a_r3: 2000
16 # '--------------R2--------------' !! 16 # '--------------R2--------------' a_r4: 1400
17 # segment a_r2 segment b_r2 17 # segment a_r2 segment b_r2
18 # 18 #
19 # Check that PMTU exceptions with the co 19 # Check that PMTU exceptions with the correct PMTU are created. Then
20 # decrease and increase the MTU of the l 20 # decrease and increase the MTU of the local link for one of the paths,
21 # A to R1, checking that route exception 21 # A to R1, checking that route exception PMTU changes accordingly over
22 # this path. Also check that locked exce 22 # this path. Also check that locked exceptions are created when an ICMP
23 # message advertising a PMTU smaller tha 23 # message advertising a PMTU smaller than net.ipv4.route.min_pmtu is
24 # received 24 # received
25 # 25 #
26 # - pmtu_ipv6 26 # - pmtu_ipv6
27 # Same as pmtu_ipv4, except for locked P 27 # Same as pmtu_ipv4, except for locked PMTU tests, using IPv6
28 # 28 #
29 # - pmtu_ipv4_dscp_icmp_exception <<
30 # Set up the same network topology as pm <<
31 # routing table in A. A fib-rule is used <<
32 # based on DSCP. Send ICMPv4 packets wit <<
33 # verify that ECN doesn't interfere with <<
34 # <<
35 # - pmtu_ipv4_dscp_udp_exception <<
36 # Same as pmtu_ipv4_dscp_icmp_exception, <<
37 # <<
38 # - pmtu_ipv4_vxlan4_exception 29 # - pmtu_ipv4_vxlan4_exception
39 # Set up the same network topology as pm 30 # Set up the same network topology as pmtu_ipv4, create a VXLAN tunnel
40 # over IPv4 between A and B, routed via 31 # over IPv4 between A and B, routed via R1. On the link between R1 and B,
41 # set a MTU lower than the VXLAN MTU and 32 # set a MTU lower than the VXLAN MTU and the MTU on the link between A and
42 # R1. Send IPv4 packets, exceeding the M 33 # R1. Send IPv4 packets, exceeding the MTU between R1 and B, over VXLAN
43 # from A to B and check that the PMTU ex 34 # from A to B and check that the PMTU exception is created with the right
44 # value on A 35 # value on A
45 # 36 #
46 # - pmtu_ipv6_vxlan4_exception 37 # - pmtu_ipv6_vxlan4_exception
47 # Same as pmtu_ipv4_vxlan4_exception, bu 38 # Same as pmtu_ipv4_vxlan4_exception, but send IPv6 packets from A to B
48 # 39 #
49 # - pmtu_ipv4_vxlan6_exception 40 # - pmtu_ipv4_vxlan6_exception
50 # Same as pmtu_ipv4_vxlan4_exception, bu 41 # Same as pmtu_ipv4_vxlan4_exception, but use IPv6 transport from A to B
51 # 42 #
52 # - pmtu_ipv6_vxlan6_exception 43 # - pmtu_ipv6_vxlan6_exception
53 # Same as pmtu_ipv4_vxlan6_exception, bu 44 # Same as pmtu_ipv4_vxlan6_exception, but send IPv6 packets from A to B
54 # 45 #
55 # - pmtu_ipv4_geneve4_exception 46 # - pmtu_ipv4_geneve4_exception
56 # Same as pmtu_ipv4_vxlan4_exception, bu 47 # Same as pmtu_ipv4_vxlan4_exception, but using a GENEVE tunnel instead of
57 # VXLAN 48 # VXLAN
58 # 49 #
59 # - pmtu_ipv6_geneve4_exception 50 # - pmtu_ipv6_geneve4_exception
60 # Same as pmtu_ipv6_vxlan4_exception, bu 51 # Same as pmtu_ipv6_vxlan4_exception, but using a GENEVE tunnel instead of
61 # VXLAN 52 # VXLAN
62 # 53 #
63 # - pmtu_ipv4_geneve6_exception 54 # - pmtu_ipv4_geneve6_exception
64 # Same as pmtu_ipv4_vxlan6_exception, bu 55 # Same as pmtu_ipv4_vxlan6_exception, but using a GENEVE tunnel instead of
65 # VXLAN 56 # VXLAN
66 # 57 #
67 # - pmtu_ipv6_geneve6_exception 58 # - pmtu_ipv6_geneve6_exception
68 # Same as pmtu_ipv6_vxlan6_exception, bu 59 # Same as pmtu_ipv6_vxlan6_exception, but using a GENEVE tunnel instead of
69 # VXLAN 60 # VXLAN
70 # 61 #
71 # - pmtu_ipv{4,6}_br_vxlan{4,6}_exception <<
72 # Set up three namespaces, A, B, and C, <<
73 # R1. R2 is unused in these tests. A has <<
74 # connected to B via a VXLAN endpoint, w <<
75 # MTU on the B-R1 link is lower than oth <<
76 # <<
77 # Check that both C and A are able to co <<
78 # tunnel, and that PMTU exceptions with <<
79 # <<
80 # segment a_r1 segm <<
81 # .--------------R1----- <<
82 # C---veth A <<
83 # ' bridge <<
84 # '---- - - - - - VXLAN - - <<
85 # <<
86 # - pmtu_ipv{4,6}_br_geneve{4,6}_exception <<
87 # Same as pmtu_ipv{4,6}_br_vxlan{4,6}_ex <<
88 # instead. <<
89 # <<
90 # - pmtu_ipv{4,6}_ovs_vxlan{4,6}_exception <<
91 # Set up two namespaces, B, and C, with <<
92 # and B over R1. A and R2 are unused in <<
93 # has a veth connection to C, and is con <<
94 # which is handled by Open vSwitch and b <<
95 # is lower than other MTUs. <<
96 # <<
97 # Check that C is able to communicate wi <<
98 # that PMTU exceptions with the correct <<
99 # <<
100 # segment a_r1 segm <<
101 # .--------------R1----- <<
102 # C---veth init <<
103 # '- ovs <<
104 # '---- - - - - - VXLAN - - <<
105 # <<
106 # - pmtu_ipv{4,6}_ovs_geneve{4,6}_exception <<
107 # Same as pmtu_ipv{4,6}_ovs_vxlan{4,6}_e <<
108 # instead. <<
109 # <<
110 # - pmtu_ipv{4,6}_fou{4,6}_exception 62 # - pmtu_ipv{4,6}_fou{4,6}_exception
111 # Same as pmtu_ipv4_vxlan4, but using a 63 # Same as pmtu_ipv4_vxlan4, but using a direct IPv4/IPv6 encapsulation
112 # (FoU) over IPv4/IPv6, instead of VXLAN 64 # (FoU) over IPv4/IPv6, instead of VXLAN
113 # 65 #
114 # - pmtu_ipv{4,6}_fou{4,6}_exception 66 # - pmtu_ipv{4,6}_fou{4,6}_exception
115 # Same as pmtu_ipv4_vxlan4, but using a 67 # Same as pmtu_ipv4_vxlan4, but using a generic UDP IPv4/IPv6
116 # encapsulation (GUE) over IPv4/IPv6, in 68 # encapsulation (GUE) over IPv4/IPv6, instead of VXLAN
117 # 69 #
118 # - pmtu_ipv{4,6}_ipv{4,6}_exception <<
119 # Same as pmtu_ipv4_vxlan4, but using a <<
120 # instead of VXLAN <<
121 # <<
122 # - pmtu_vti4_exception 70 # - pmtu_vti4_exception
123 # Set up vti tunnel on top of veth, with 71 # Set up vti tunnel on top of veth, with xfrm states and policies, in two
124 # namespaces with matching endpoints. Ch 72 # namespaces with matching endpoints. Check that route exception is not
125 # created if link layer MTU is not excee 73 # created if link layer MTU is not exceeded, then exceed it and check that
126 # exception is created with the expected 74 # exception is created with the expected PMTU. The approach described
127 # below for IPv6 doesn't apply here, bec 75 # below for IPv6 doesn't apply here, because, on IPv4, administrative MTU
128 # changes alone won't affect PMTU 76 # changes alone won't affect PMTU
129 # 77 #
130 # - pmtu_vti4_udp_exception <<
131 # Same as pmtu_vti4_exception, but using <<
132 # <<
133 # - pmtu_vti4_udp_routed_exception <<
134 # Set up vti tunnel on top of veth conne <<
135 # add xfrm states and policies with ESP- <<
136 # route exception is not created if link <<
137 # lower MTU on second part of routed env <<
138 # is created with the expected PMTU. <<
139 # <<
140 # - pmtu_vti6_exception 78 # - pmtu_vti6_exception
141 # Set up vti6 tunnel on top of veth, wit 79 # Set up vti6 tunnel on top of veth, with xfrm states and policies, in two
142 # namespaces with matching endpoints. Ch 80 # namespaces with matching endpoints. Check that route exception is
143 # created by exceeding link layer MTU wi 81 # created by exceeding link layer MTU with ping to other endpoint. Then
144 # decrease and increase MTU of tunnel, c 82 # decrease and increase MTU of tunnel, checking that route exception PMTU
145 # changes accordingly 83 # changes accordingly
146 # 84 #
147 # - pmtu_vti6_udp_exception <<
148 # Same as pmtu_vti6_exception, but using <<
149 # <<
150 # - pmtu_vti6_udp_routed_exception <<
151 # Same as pmtu_vti6_udp_routed_exception <<
152 # endpoints <<
153 # <<
154 # - pmtu_vti4_default_mtu 85 # - pmtu_vti4_default_mtu
155 # Set up vti4 tunnel on top of veth, in 86 # Set up vti4 tunnel on top of veth, in two namespaces with matching
156 # endpoints. Check that MTU assigned to 87 # endpoints. Check that MTU assigned to vti interface is the MTU of the
157 # lower layer (veth) minus additional lo 88 # lower layer (veth) minus additional lower layer headers (zero, for veth)
158 # minus IPv4 header length 89 # minus IPv4 header length
159 # 90 #
160 # - pmtu_vti6_default_mtu 91 # - pmtu_vti6_default_mtu
161 # Same as above, for IPv6 92 # Same as above, for IPv6
162 # 93 #
163 # - pmtu_vti4_link_add_mtu 94 # - pmtu_vti4_link_add_mtu
164 # Set up vti4 interface passing MTU valu 95 # Set up vti4 interface passing MTU value at link creation, check MTU is
165 # configured, and that link is not creat 96 # configured, and that link is not created with invalid MTU values
166 # 97 #
167 # - pmtu_vti6_link_add_mtu 98 # - pmtu_vti6_link_add_mtu
168 # Same as above, for IPv6 99 # Same as above, for IPv6
169 # 100 #
170 # - pmtu_vti6_link_change_mtu 101 # - pmtu_vti6_link_change_mtu
171 # Set up two dummy interfaces with diffe 102 # Set up two dummy interfaces with different MTUs, create a vti6 tunnel
172 # and check that configured MTU is used 103 # and check that configured MTU is used on link creation and changes, and
173 # that MTU is properly calculated instea 104 # that MTU is properly calculated instead when MTU is not configured from
174 # userspace 105 # userspace
175 # 106 #
176 # - cleanup_ipv4_exception 107 # - cleanup_ipv4_exception
177 # Similar to pmtu_ipv4_vxlan4_exception, 108 # Similar to pmtu_ipv4_vxlan4_exception, but explicitly generate PMTU
178 # exceptions on multiple CPUs and check 109 # exceptions on multiple CPUs and check that the veth device tear-down
179 # happens in a timely manner 110 # happens in a timely manner
180 # 111 #
181 # - cleanup_ipv6_exception 112 # - cleanup_ipv6_exception
182 # Same as above, but use IPv6 transport 113 # Same as above, but use IPv6 transport from A to B
183 # 114 #
184 # - list_flush_ipv4_exception 115 # - list_flush_ipv4_exception
185 # Using the same topology as in pmtu_ipv 116 # Using the same topology as in pmtu_ipv4, create exceptions, and check
186 # they are shown when listing exception 117 # they are shown when listing exception caches, gone after flushing them
187 # 118 #
188 # - list_flush_ipv6_exception 119 # - list_flush_ipv6_exception
189 # Using the same topology as in pmtu_ipv 120 # Using the same topology as in pmtu_ipv6, create exceptions, and check
190 # they are shown when listing exception 121 # they are shown when listing exception caches, gone after flushing them
191 # <<
192 # - pmtu_ipv4_route_change <<
193 # Use the same topology as in pmtu_ipv4, <<
194 # command and delete the corresponding d <<
195 # proper cleanup of the PMTU exceptions <<
196 # Device unregistration should complete <<
197 # <<
198 # - pmtu_ipv6_route_change <<
199 # Same as above but with IPv6 <<
200 122
201 source lib.sh !! 123
202 source net_helper.sh !! 124 # Kselftest framework requirement - SKIP code is 4.
>> 125 ksft_skip=4
203 126
204 PAUSE_ON_FAIL=no 127 PAUSE_ON_FAIL=no
205 VERBOSE=0 128 VERBOSE=0
206 TRACING=0 129 TRACING=0
207 130
208 # Some systems don't have a ping6 binary anymo 131 # Some systems don't have a ping6 binary anymore
209 which ping6 > /dev/null 2>&1 && ping6=$(which 132 which ping6 > /dev/null 2>&1 && ping6=$(which ping6) || ping6=$(which ping)
210 133
211 # Name 134 # Name Description re-run with nh
212 tests=" 135 tests="
213 pmtu_ipv4_exception ipv4: 136 pmtu_ipv4_exception ipv4: PMTU exceptions 1
214 pmtu_ipv6_exception ipv6: 137 pmtu_ipv6_exception ipv6: PMTU exceptions 1
215 pmtu_ipv4_dscp_icmp_exception ICMPv4 <<
216 pmtu_ipv4_dscp_udp_exception UDPv4 <<
217 pmtu_ipv4_vxlan4_exception IPv4 o 138 pmtu_ipv4_vxlan4_exception IPv4 over vxlan4: PMTU exceptions 1
218 pmtu_ipv6_vxlan4_exception IPv6 o 139 pmtu_ipv6_vxlan4_exception IPv6 over vxlan4: PMTU exceptions 1
219 pmtu_ipv4_vxlan6_exception IPv4 o 140 pmtu_ipv4_vxlan6_exception IPv4 over vxlan6: PMTU exceptions 1
220 pmtu_ipv6_vxlan6_exception IPv6 o 141 pmtu_ipv6_vxlan6_exception IPv6 over vxlan6: PMTU exceptions 1
221 pmtu_ipv4_geneve4_exception IPv4 o 142 pmtu_ipv4_geneve4_exception IPv4 over geneve4: PMTU exceptions 1
222 pmtu_ipv6_geneve4_exception IPv6 o 143 pmtu_ipv6_geneve4_exception IPv6 over geneve4: PMTU exceptions 1
223 pmtu_ipv4_geneve6_exception IPv4 o 144 pmtu_ipv4_geneve6_exception IPv4 over geneve6: PMTU exceptions 1
224 pmtu_ipv6_geneve6_exception IPv6 o 145 pmtu_ipv6_geneve6_exception IPv6 over geneve6: PMTU exceptions 1
225 pmtu_ipv4_br_vxlan4_exception IPv4, <<
226 pmtu_ipv6_br_vxlan4_exception IPv6, <<
227 pmtu_ipv4_br_vxlan6_exception IPv4, <<
228 pmtu_ipv6_br_vxlan6_exception IPv6, <<
229 pmtu_ipv4_br_geneve4_exception IPv4, <<
230 pmtu_ipv6_br_geneve4_exception IPv6, <<
231 pmtu_ipv4_br_geneve6_exception IPv4, <<
232 pmtu_ipv6_br_geneve6_exception IPv6, <<
233 pmtu_ipv4_ovs_vxlan4_exception IPv4, <<
234 pmtu_ipv6_ovs_vxlan4_exception IPv6, <<
235 pmtu_ipv4_ovs_vxlan6_exception IPv4, <<
236 pmtu_ipv6_ovs_vxlan6_exception IPv6, <<
237 pmtu_ipv4_ovs_geneve4_exception IPv4, <<
238 pmtu_ipv6_ovs_geneve4_exception IPv6, <<
239 pmtu_ipv4_ovs_geneve6_exception IPv4, <<
240 pmtu_ipv6_ovs_geneve6_exception IPv6, <<
241 pmtu_ipv4_fou4_exception IPv4 o 146 pmtu_ipv4_fou4_exception IPv4 over fou4: PMTU exceptions 1
242 pmtu_ipv6_fou4_exception IPv6 o 147 pmtu_ipv6_fou4_exception IPv6 over fou4: PMTU exceptions 1
243 pmtu_ipv4_fou6_exception IPv4 o 148 pmtu_ipv4_fou6_exception IPv4 over fou6: PMTU exceptions 1
244 pmtu_ipv6_fou6_exception IPv6 o 149 pmtu_ipv6_fou6_exception IPv6 over fou6: PMTU exceptions 1
245 pmtu_ipv4_gue4_exception IPv4 o 150 pmtu_ipv4_gue4_exception IPv4 over gue4: PMTU exceptions 1
246 pmtu_ipv6_gue4_exception IPv6 o 151 pmtu_ipv6_gue4_exception IPv6 over gue4: PMTU exceptions 1
247 pmtu_ipv4_gue6_exception IPv4 o 152 pmtu_ipv4_gue6_exception IPv4 over gue6: PMTU exceptions 1
248 pmtu_ipv6_gue6_exception IPv6 o 153 pmtu_ipv6_gue6_exception IPv6 over gue6: PMTU exceptions 1
249 pmtu_ipv4_ipv4_exception IPv4 o <<
250 pmtu_ipv6_ipv4_exception IPv6 o <<
251 pmtu_ipv4_ipv6_exception IPv4 o <<
252 pmtu_ipv6_ipv6_exception IPv6 o <<
253 pmtu_vti6_exception vti6: 154 pmtu_vti6_exception vti6: PMTU exceptions 0
254 pmtu_vti4_exception vti4: 155 pmtu_vti4_exception vti4: PMTU exceptions 0
255 pmtu_vti6_udp_exception vti6: <<
256 pmtu_vti4_udp_exception vti4: <<
257 pmtu_vti6_udp_routed_exception vti6: <<
258 pmtu_vti4_udp_routed_exception vti4: <<
259 pmtu_vti4_default_mtu vti4: 156 pmtu_vti4_default_mtu vti4: default MTU assignment 0
260 pmtu_vti6_default_mtu vti6: 157 pmtu_vti6_default_mtu vti6: default MTU assignment 0
261 pmtu_vti4_link_add_mtu vti4: 158 pmtu_vti4_link_add_mtu vti4: MTU setting on link creation 0
262 pmtu_vti6_link_add_mtu vti6: 159 pmtu_vti6_link_add_mtu vti6: MTU setting on link creation 0
263 pmtu_vti6_link_change_mtu vti6: 160 pmtu_vti6_link_change_mtu vti6: MTU changes on link changes 0
264 cleanup_ipv4_exception ipv4: 161 cleanup_ipv4_exception ipv4: cleanup of cached exceptions 1
265 cleanup_ipv6_exception ipv6: 162 cleanup_ipv6_exception ipv6: cleanup of cached exceptions 1
266 list_flush_ipv4_exception ipv4: 163 list_flush_ipv4_exception ipv4: list and flush cached exceptions 1
267 list_flush_ipv6_exception ipv6: !! 164 list_flush_ipv6_exception ipv6: list and flush cached exceptions 1"
268 pmtu_ipv4_route_change ipv4: !! 165
269 pmtu_ipv6_route_change ipv6: !! 166 NS_A="ns-A"
>> 167 NS_B="ns-B"
>> 168 NS_R1="ns-R1"
>> 169 NS_R2="ns-R2"
>> 170 ns_a="ip netns exec ${NS_A}"
>> 171 ns_b="ip netns exec ${NS_B}"
>> 172 ns_r1="ip netns exec ${NS_R1}"
>> 173 ns_r2="ip netns exec ${NS_R2}"
270 174
271 # Addressing and routing for tests with router 175 # Addressing and routing for tests with routers: four network segments, with
272 # index SEGMENT between 1 and 4, a common pref 176 # index SEGMENT between 1 and 4, a common prefix (PREFIX4 or PREFIX6) and an
273 # identifier ID, which is 1 for hosts (A and B 177 # identifier ID, which is 1 for hosts (A and B), 2 for routers (R1 and R2).
274 # Addresses are: 178 # Addresses are:
275 # - IPv4: PREFIX4.SEGMENT.ID (/24) 179 # - IPv4: PREFIX4.SEGMENT.ID (/24)
276 # - IPv6: PREFIX6:SEGMENT::ID (/64) 180 # - IPv6: PREFIX6:SEGMENT::ID (/64)
277 prefix4="10.0" 181 prefix4="10.0"
278 prefix6="fc00" 182 prefix6="fc00"
279 a_r1=1 183 a_r1=1
280 a_r2=2 184 a_r2=2
281 b_r1=3 185 b_r1=3
282 b_r2=4 186 b_r2=4
283 # ns peer segment 187 # ns peer segment
284 routing_addrs=" 188 routing_addrs="
285 A R1 ${a_r1} 189 A R1 ${a_r1}
286 A R2 ${a_r2} 190 A R2 ${a_r2}
287 B R1 ${b_r1} 191 B R1 ${b_r1}
288 B R2 ${b_r2} 192 B R2 ${b_r2}
289 " 193 "
290 # Traffic from A to B goes through R1 by defau 194 # Traffic from A to B goes through R1 by default, and through R2, if destined to
291 # B's address on the b_r2 segment. 195 # B's address on the b_r2 segment.
292 # Traffic from B to A goes through R1. 196 # Traffic from B to A goes through R1.
293 # ns destination gatewa 197 # ns destination gateway
294 routes=" 198 routes="
295 A default ${pref 199 A default ${prefix4}.${a_r1}.2
296 A ${prefix4}.${b_r2}.1 ${pref 200 A ${prefix4}.${b_r2}.1 ${prefix4}.${a_r2}.2
297 B default ${pref 201 B default ${prefix4}.${b_r1}.2
298 202
299 A default ${pref 203 A default ${prefix6}:${a_r1}::2
300 A ${prefix6}:${b_r2}::1 ${pref 204 A ${prefix6}:${b_r2}::1 ${prefix6}:${a_r2}::2
301 B default ${pref 205 B default ${prefix6}:${b_r1}::2
302 " 206 "
>> 207
303 USE_NH="no" 208 USE_NH="no"
304 # ns family nh id destination 209 # ns family nh id destination gateway
305 nexthops=" 210 nexthops="
306 A 4 41 ${prefix4}.${a 211 A 4 41 ${prefix4}.${a_r1}.2 veth_A-R1
307 A 4 42 ${prefix4}.${a 212 A 4 42 ${prefix4}.${a_r2}.2 veth_A-R2
308 B 4 41 ${prefix4}.${b 213 B 4 41 ${prefix4}.${b_r1}.2 veth_B-R1
309 214
310 A 6 61 ${prefix6}:${a 215 A 6 61 ${prefix6}:${a_r1}::2 veth_A-R1
311 A 6 62 ${prefix6}:${a 216 A 6 62 ${prefix6}:${a_r2}::2 veth_A-R2
312 B 6 61 ${prefix6}:${b 217 B 6 61 ${prefix6}:${b_r1}::2 veth_B-R1
313 " 218 "
314 219
315 # nexthop id correlates to id in nexthops conf 220 # nexthop id correlates to id in nexthops config above
316 # ns family prefix 221 # ns family prefix nh id
317 routes_nh=" 222 routes_nh="
318 A 4 default 223 A 4 default 41
319 A 4 ${prefix4}.${b_r2}.1 224 A 4 ${prefix4}.${b_r2}.1 42
320 B 4 default 225 B 4 default 41
321 226
322 A 6 default 227 A 6 default 61
323 A 6 ${prefix6}:${b_r2}::1 228 A 6 ${prefix6}:${b_r2}::1 62
324 B 6 default 229 B 6 default 61
325 " 230 "
326 231
327 policy_mark=0x04 <<
328 rt_table=main <<
329 <<
330 veth4_a_addr="192.168.1.1" 232 veth4_a_addr="192.168.1.1"
331 veth4_b_addr="192.168.1.2" 233 veth4_b_addr="192.168.1.2"
332 veth4_c_addr="192.168.2.10" <<
333 veth4_mask="24" 234 veth4_mask="24"
334 veth6_a_addr="fd00:1::a" 235 veth6_a_addr="fd00:1::a"
335 veth6_b_addr="fd00:1::b" 236 veth6_b_addr="fd00:1::b"
336 veth6_c_addr="fd00:2::c" <<
337 veth6_mask="64" 237 veth6_mask="64"
338 238
339 tunnel4_a_addr="192.168.2.1" 239 tunnel4_a_addr="192.168.2.1"
340 tunnel4_b_addr="192.168.2.2" 240 tunnel4_b_addr="192.168.2.2"
341 tunnel4_mask="24" 241 tunnel4_mask="24"
342 tunnel6_a_addr="fd00:2::a" 242 tunnel6_a_addr="fd00:2::a"
343 tunnel6_b_addr="fd00:2::b" 243 tunnel6_b_addr="fd00:2::b"
344 tunnel6_mask="64" 244 tunnel6_mask="64"
345 245
346 dummy6_0_prefix="fc00:1000::" 246 dummy6_0_prefix="fc00:1000::"
347 dummy6_1_prefix="fc00:1001::" 247 dummy6_1_prefix="fc00:1001::"
348 dummy6_mask="64" 248 dummy6_mask="64"
349 249
350 err_buf= 250 err_buf=
351 tcpdump_pids= 251 tcpdump_pids=
352 nettest_pids= <<
353 socat_pids= <<
354 tmpoutfile= <<
355 252
356 err() { 253 err() {
357 err_buf="${err_buf}${1} 254 err_buf="${err_buf}${1}
358 " 255 "
359 } 256 }
360 257
361 err_flush() { 258 err_flush() {
362 echo -n "${err_buf}" 259 echo -n "${err_buf}"
363 err_buf= 260 err_buf=
364 } 261 }
365 262
366 run_cmd() { 263 run_cmd() {
367 cmd="$*" 264 cmd="$*"
368 265
369 if [ "$VERBOSE" = "1" ]; then 266 if [ "$VERBOSE" = "1" ]; then
370 printf " COMMAND: $cmd\n" 267 printf " COMMAND: $cmd\n"
371 fi 268 fi
372 269
373 out="$($cmd 2>&1)" 270 out="$($cmd 2>&1)"
374 rc=$? 271 rc=$?
375 if [ "$VERBOSE" = "1" -a -n "$out" ]; 272 if [ "$VERBOSE" = "1" -a -n "$out" ]; then
376 echo " $out" 273 echo " $out"
377 echo 274 echo
378 fi 275 fi
379 276
380 return $rc 277 return $rc
381 } 278 }
382 279
383 run_cmd_bg() { <<
384 cmd="$*" <<
385 <<
386 if [ "$VERBOSE" = "1" ]; then <<
387 printf " COMMAND: %s &\n" " <<
388 fi <<
389 <<
390 $cmd 2>&1 & <<
391 } <<
392 <<
393 # Find the auto-generated name for this namesp 280 # Find the auto-generated name for this namespace
394 nsname() { 281 nsname() {
395 eval echo \$NS_$1 282 eval echo \$NS_$1
396 } 283 }
397 284
398 setup_fou_or_gue() { 285 setup_fou_or_gue() {
399 outer="${1}" 286 outer="${1}"
400 inner="${2}" 287 inner="${2}"
401 encap="${3}" 288 encap="${3}"
402 289
403 if [ "${outer}" = "4" ]; then 290 if [ "${outer}" = "4" ]; then
404 modprobe fou || return $ksft_s !! 291 modprobe fou || return 2
405 a_addr="${prefix4}.${a_r1}.1" 292 a_addr="${prefix4}.${a_r1}.1"
406 b_addr="${prefix4}.${b_r1}.1" 293 b_addr="${prefix4}.${b_r1}.1"
407 if [ "${inner}" = "4" ]; then 294 if [ "${inner}" = "4" ]; then
408 type="ipip" 295 type="ipip"
409 ipproto="4" 296 ipproto="4"
410 else 297 else
411 type="sit" 298 type="sit"
412 ipproto="41" 299 ipproto="41"
413 fi 300 fi
414 else 301 else
415 modprobe fou6 || return $ksft_ !! 302 modprobe fou6 || return 2
416 a_addr="${prefix6}:${a_r1}::1" 303 a_addr="${prefix6}:${a_r1}::1"
417 b_addr="${prefix6}:${b_r1}::1" 304 b_addr="${prefix6}:${b_r1}::1"
418 if [ "${inner}" = "4" ]; then 305 if [ "${inner}" = "4" ]; then
419 type="ip6tnl" 306 type="ip6tnl"
420 mode="mode ipip6" 307 mode="mode ipip6"
421 ipproto="4 -6" 308 ipproto="4 -6"
422 else 309 else
423 type="ip6tnl" 310 type="ip6tnl"
424 mode="mode ip6ip6" 311 mode="mode ip6ip6"
425 ipproto="41 -6" 312 ipproto="41 -6"
426 fi 313 fi
427 fi 314 fi
428 315
429 run_cmd ${ns_a} ip fou add port 5555 i !! 316 run_cmd ${ns_a} ip fou add port 5555 ipproto ${ipproto} || return 2
430 run_cmd ${ns_a} ip link add ${encap}_a !! 317 run_cmd ${ns_a} ip link add ${encap}_a type ${type} ${mode} local ${a_addr} remote ${b_addr} encap ${encap} encap-sport auto encap-dport 5556 || return 2
431 318
432 run_cmd ${ns_b} ip fou add port 5556 i 319 run_cmd ${ns_b} ip fou add port 5556 ipproto ${ipproto}
433 run_cmd ${ns_b} ip link add ${encap}_b 320 run_cmd ${ns_b} ip link add ${encap}_b type ${type} ${mode} local ${b_addr} remote ${a_addr} encap ${encap} encap-sport auto encap-dport 5555
434 321
435 if [ "${inner}" = "4" ]; then 322 if [ "${inner}" = "4" ]; then
436 run_cmd ${ns_a} ip addr add ${ 323 run_cmd ${ns_a} ip addr add ${tunnel4_a_addr}/${tunnel4_mask} dev ${encap}_a
437 run_cmd ${ns_b} ip addr add ${ 324 run_cmd ${ns_b} ip addr add ${tunnel4_b_addr}/${tunnel4_mask} dev ${encap}_b
438 else 325 else
439 run_cmd ${ns_a} ip addr add ${ 326 run_cmd ${ns_a} ip addr add ${tunnel6_a_addr}/${tunnel6_mask} dev ${encap}_a
440 run_cmd ${ns_b} ip addr add ${ 327 run_cmd ${ns_b} ip addr add ${tunnel6_b_addr}/${tunnel6_mask} dev ${encap}_b
441 fi 328 fi
442 329
443 run_cmd ${ns_a} ip link set ${encap}_a 330 run_cmd ${ns_a} ip link set ${encap}_a up
444 run_cmd ${ns_b} ip link set ${encap}_b 331 run_cmd ${ns_b} ip link set ${encap}_b up
445 } 332 }
446 333
447 setup_fou44() { 334 setup_fou44() {
448 setup_fou_or_gue 4 4 fou 335 setup_fou_or_gue 4 4 fou
449 } 336 }
450 337
451 setup_fou46() { 338 setup_fou46() {
452 setup_fou_or_gue 4 6 fou 339 setup_fou_or_gue 4 6 fou
453 } 340 }
454 341
455 setup_fou64() { 342 setup_fou64() {
456 setup_fou_or_gue 6 4 fou 343 setup_fou_or_gue 6 4 fou
457 } 344 }
458 345
459 setup_fou66() { 346 setup_fou66() {
460 setup_fou_or_gue 6 6 fou 347 setup_fou_or_gue 6 6 fou
461 } 348 }
462 349
463 setup_gue44() { 350 setup_gue44() {
464 setup_fou_or_gue 4 4 gue 351 setup_fou_or_gue 4 4 gue
465 } 352 }
466 353
467 setup_gue46() { 354 setup_gue46() {
468 setup_fou_or_gue 4 6 gue 355 setup_fou_or_gue 4 6 gue
469 } 356 }
470 357
471 setup_gue64() { 358 setup_gue64() {
472 setup_fou_or_gue 6 4 gue 359 setup_fou_or_gue 6 4 gue
473 } 360 }
474 361
475 setup_gue66() { 362 setup_gue66() {
476 setup_fou_or_gue 6 6 gue 363 setup_fou_or_gue 6 6 gue
477 } 364 }
478 365
479 setup_ipvX_over_ipvY() { <<
480 inner=${1} <<
481 outer=${2} <<
482 <<
483 if [ "${outer}" -eq 4 ]; then <<
484 a_addr="${prefix4}.${a_r1}.1" <<
485 b_addr="${prefix4}.${b_r1}.1" <<
486 if [ "${inner}" -eq 4 ]; then <<
487 type="ipip" <<
488 mode="ipip" <<
489 else <<
490 type="sit" <<
491 mode="ip6ip" <<
492 fi <<
493 else <<
494 a_addr="${prefix6}:${a_r1}::1" <<
495 b_addr="${prefix6}:${b_r1}::1" <<
496 type="ip6tnl" <<
497 if [ "${inner}" -eq 4 ]; then <<
498 mode="ipip6" <<
499 else <<
500 mode="ip6ip6" <<
501 fi <<
502 fi <<
503 <<
504 run_cmd ${ns_a} ip link add ip_a type <<
505 run_cmd ${ns_b} ip link add ip_b type <<
506 <<
507 run_cmd ${ns_a} ip link set ip_a up <<
508 run_cmd ${ns_b} ip link set ip_b up <<
509 <<
510 if [ "${inner}" = "4" ]; then <<
511 run_cmd ${ns_a} ip addr add ${ <<
512 run_cmd ${ns_b} ip addr add ${ <<
513 else <<
514 run_cmd ${ns_a} ip addr add ${ <<
515 run_cmd ${ns_b} ip addr add ${ <<
516 fi <<
517 } <<
518 <<
519 setup_ip4ip4() { <<
520 setup_ipvX_over_ipvY 4 4 <<
521 } <<
522 <<
523 setup_ip6ip4() { <<
524 setup_ipvX_over_ipvY 6 4 <<
525 } <<
526 <<
527 setup_ip4ip6() { <<
528 setup_ipvX_over_ipvY 4 6 <<
529 } <<
530 <<
531 setup_ip6ip6() { <<
532 setup_ipvX_over_ipvY 6 6 <<
533 } <<
534 <<
535 setup_namespaces() { 366 setup_namespaces() {
536 setup_ns NS_A NS_B NS_C NS_R1 NS_R2 !! 367 for n in ${NS_A} ${NS_B} ${NS_R1} ${NS_R2}; do
537 for n in ${NS_A} ${NS_B} ${NS_C} ${NS_ !! 368 ip netns add ${n} || return 1
>> 369
538 # Disable DAD, so that we don' 370 # Disable DAD, so that we don't have to wait to use the
539 # configured IPv6 addresses 371 # configured IPv6 addresses
540 ip netns exec ${n} sysctl -q n 372 ip netns exec ${n} sysctl -q net/ipv6/conf/default/accept_dad=0
541 done 373 done
542 ns_a="ip netns exec ${NS_A}" <<
543 ns_b="ip netns exec ${NS_B}" <<
544 ns_c="ip netns exec ${NS_C}" <<
545 ns_r1="ip netns exec ${NS_R1}" <<
546 ns_r2="ip netns exec ${NS_R2}" <<
547 } 374 }
548 375
549 setup_veth() { 376 setup_veth() {
550 run_cmd ${ns_a} ip link add veth_a typ 377 run_cmd ${ns_a} ip link add veth_a type veth peer name veth_b || return 1
551 run_cmd ${ns_a} ip link set veth_b net 378 run_cmd ${ns_a} ip link set veth_b netns ${NS_B}
552 379
553 run_cmd ${ns_a} ip addr add ${veth4_a_ 380 run_cmd ${ns_a} ip addr add ${veth4_a_addr}/${veth4_mask} dev veth_a
554 run_cmd ${ns_b} ip addr add ${veth4_b_ 381 run_cmd ${ns_b} ip addr add ${veth4_b_addr}/${veth4_mask} dev veth_b
555 382
556 run_cmd ${ns_a} ip addr add ${veth6_a_ 383 run_cmd ${ns_a} ip addr add ${veth6_a_addr}/${veth6_mask} dev veth_a
557 run_cmd ${ns_b} ip addr add ${veth6_b_ 384 run_cmd ${ns_b} ip addr add ${veth6_b_addr}/${veth6_mask} dev veth_b
558 385
559 run_cmd ${ns_a} ip link set veth_a up 386 run_cmd ${ns_a} ip link set veth_a up
560 run_cmd ${ns_b} ip link set veth_b up 387 run_cmd ${ns_b} ip link set veth_b up
561 } 388 }
562 389
563 setup_vti() { 390 setup_vti() {
564 proto=${1} 391 proto=${1}
565 veth_a_addr="${2}" 392 veth_a_addr="${2}"
566 veth_b_addr="${3}" 393 veth_b_addr="${3}"
567 vti_a_addr="${4}" 394 vti_a_addr="${4}"
568 vti_b_addr="${5}" 395 vti_b_addr="${5}"
569 vti_mask=${6} 396 vti_mask=${6}
570 397
571 [ ${proto} -eq 6 ] && vti_type="vti6" 398 [ ${proto} -eq 6 ] && vti_type="vti6" || vti_type="vti"
572 399
573 run_cmd ${ns_a} ip link add vti${proto 400 run_cmd ${ns_a} ip link add vti${proto}_a type ${vti_type} local ${veth_a_addr} remote ${veth_b_addr} key 10 || return 1
574 run_cmd ${ns_b} ip link add vti${proto 401 run_cmd ${ns_b} ip link add vti${proto}_b type ${vti_type} local ${veth_b_addr} remote ${veth_a_addr} key 10
575 402
576 run_cmd ${ns_a} ip addr add ${vti_a_ad 403 run_cmd ${ns_a} ip addr add ${vti_a_addr}/${vti_mask} dev vti${proto}_a
577 run_cmd ${ns_b} ip addr add ${vti_b_ad 404 run_cmd ${ns_b} ip addr add ${vti_b_addr}/${vti_mask} dev vti${proto}_b
578 405
579 run_cmd ${ns_a} ip link set vti${proto 406 run_cmd ${ns_a} ip link set vti${proto}_a up
580 run_cmd ${ns_b} ip link set vti${proto 407 run_cmd ${ns_b} ip link set vti${proto}_b up
581 } 408 }
582 409
583 setup_vti4() { 410 setup_vti4() {
584 setup_vti 4 ${veth4_a_addr} ${veth4_b_ 411 setup_vti 4 ${veth4_a_addr} ${veth4_b_addr} ${tunnel4_a_addr} ${tunnel4_b_addr} ${tunnel4_mask}
585 } 412 }
586 413
587 setup_vti6() { 414 setup_vti6() {
588 setup_vti 6 ${veth6_a_addr} ${veth6_b_ 415 setup_vti 6 ${veth6_a_addr} ${veth6_b_addr} ${tunnel6_a_addr} ${tunnel6_b_addr} ${tunnel6_mask}
589 } 416 }
590 417
591 setup_vti4routed() { <<
592 setup_vti 4 ${prefix4}.${a_r1}.1 ${pre <<
593 } <<
594 <<
595 setup_vti6routed() { <<
596 setup_vti 6 ${prefix6}:${a_r1}::1 ${pr <<
597 } <<
598 <<
599 setup_vxlan_or_geneve() { 418 setup_vxlan_or_geneve() {
600 type="${1}" 419 type="${1}"
601 a_addr="${2}" 420 a_addr="${2}"
602 b_addr="${3}" 421 b_addr="${3}"
603 opts="${4}" 422 opts="${4}"
604 br_if_a="${5}" <<
605 423
606 if [ "${type}" = "vxlan" ]; then 424 if [ "${type}" = "vxlan" ]; then
607 opts="${opts} ttl 64 dstport 4 425 opts="${opts} ttl 64 dstport 4789"
608 opts_a="local ${a_addr}" 426 opts_a="local ${a_addr}"
609 opts_b="local ${b_addr}" 427 opts_b="local ${b_addr}"
610 else 428 else
611 opts_a="" 429 opts_a=""
612 opts_b="" 430 opts_b=""
613 fi 431 fi
614 432
615 run_cmd ${ns_a} ip link add ${type}_a 433 run_cmd ${ns_a} ip link add ${type}_a type ${type} id 1 ${opts_a} remote ${b_addr} ${opts} || return 1
616 run_cmd ${ns_b} ip link add ${type}_b 434 run_cmd ${ns_b} ip link add ${type}_b type ${type} id 1 ${opts_b} remote ${a_addr} ${opts}
617 435
618 if [ -n "${br_if_a}" ]; then !! 436 run_cmd ${ns_a} ip addr add ${tunnel4_a_addr}/${tunnel4_mask} dev ${type}_a
619 run_cmd ${ns_a} ip addr add ${ <<
620 run_cmd ${ns_a} ip addr add ${ <<
621 run_cmd ${ns_a} ip link set ${ <<
622 else <<
623 run_cmd ${ns_a} ip addr add ${ <<
624 run_cmd ${ns_a} ip addr add ${ <<
625 fi <<
626 <<
627 run_cmd ${ns_b} ip addr add ${tunnel4_ 437 run_cmd ${ns_b} ip addr add ${tunnel4_b_addr}/${tunnel4_mask} dev ${type}_b
>> 438
>> 439 run_cmd ${ns_a} ip addr add ${tunnel6_a_addr}/${tunnel6_mask} dev ${type}_a
628 run_cmd ${ns_b} ip addr add ${tunnel6_ 440 run_cmd ${ns_b} ip addr add ${tunnel6_b_addr}/${tunnel6_mask} dev ${type}_b
629 441
630 run_cmd ${ns_a} ip link set ${type}_a 442 run_cmd ${ns_a} ip link set ${type}_a up
631 run_cmd ${ns_b} ip link set ${type}_b 443 run_cmd ${ns_b} ip link set ${type}_b up
632 } 444 }
633 445
634 setup_geneve4() { 446 setup_geneve4() {
635 setup_vxlan_or_geneve geneve ${prefix4 447 setup_vxlan_or_geneve geneve ${prefix4}.${a_r1}.1 ${prefix4}.${b_r1}.1 "df set"
636 } 448 }
637 449
638 setup_vxlan4() { 450 setup_vxlan4() {
639 setup_vxlan_or_geneve vxlan ${prefix4 451 setup_vxlan_or_geneve vxlan ${prefix4}.${a_r1}.1 ${prefix4}.${b_r1}.1 "df set"
640 } 452 }
641 453
642 setup_geneve6() { 454 setup_geneve6() {
643 setup_vxlan_or_geneve geneve ${prefix6 !! 455 setup_vxlan_or_geneve geneve ${prefix6}:${a_r1}::1 ${prefix6}:${b_r1}::1
644 } 456 }
645 457
646 setup_vxlan6() { 458 setup_vxlan6() {
647 setup_vxlan_or_geneve vxlan ${prefix6 !! 459 setup_vxlan_or_geneve vxlan ${prefix6}:${a_r1}::1 ${prefix6}:${b_r1}::1
648 } <<
649 <<
650 setup_bridged_geneve4() { <<
651 setup_vxlan_or_geneve geneve ${prefix4 <<
652 } <<
653 <<
654 setup_bridged_vxlan4() { <<
655 setup_vxlan_or_geneve vxlan ${prefix4 <<
656 } <<
657 <<
658 setup_bridged_geneve6() { <<
659 setup_vxlan_or_geneve geneve ${prefix6 <<
660 } <<
661 <<
662 setup_bridged_vxlan6() { <<
663 setup_vxlan_or_geneve vxlan ${prefix6 <<
664 } 460 }
665 461
666 setup_xfrm() { 462 setup_xfrm() {
667 proto=${1} 463 proto=${1}
668 veth_a_addr="${2}" 464 veth_a_addr="${2}"
669 veth_b_addr="${3}" 465 veth_b_addr="${3}"
670 encap=${4} <<
671 466
672 run_cmd ${ns_a} ip -${proto} xfrm stat !! 467 run_cmd ${ns_a} ip -${proto} xfrm state add src ${veth_a_addr} dst ${veth_b_addr} spi 0x1000 proto esp aead 'rfc4106(gcm(aes))' 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f 128 mode tunnel || return 1
673 run_cmd ${ns_a} ip -${proto} xfrm stat !! 468 run_cmd ${ns_a} ip -${proto} xfrm state add src ${veth_b_addr} dst ${veth_a_addr} spi 0x1001 proto esp aead 'rfc4106(gcm(aes))' 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f 128 mode tunnel
674 run_cmd ${ns_a} ip -${proto} xfrm poli 469 run_cmd ${ns_a} ip -${proto} xfrm policy add dir out mark 10 tmpl src ${veth_a_addr} dst ${veth_b_addr} proto esp mode tunnel
675 run_cmd ${ns_a} ip -${proto} xfrm poli 470 run_cmd ${ns_a} ip -${proto} xfrm policy add dir in mark 10 tmpl src ${veth_b_addr} dst ${veth_a_addr} proto esp mode tunnel
676 471
677 run_cmd ${ns_b} ip -${proto} xfrm stat !! 472 run_cmd ${ns_b} ip -${proto} xfrm state add src ${veth_a_addr} dst ${veth_b_addr} spi 0x1000 proto esp aead 'rfc4106(gcm(aes))' 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f 128 mode tunnel
678 run_cmd ${ns_b} ip -${proto} xfrm stat !! 473 run_cmd ${ns_b} ip -${proto} xfrm state add src ${veth_b_addr} dst ${veth_a_addr} spi 0x1001 proto esp aead 'rfc4106(gcm(aes))' 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f 128 mode tunnel
679 run_cmd ${ns_b} ip -${proto} xfrm poli 474 run_cmd ${ns_b} ip -${proto} xfrm policy add dir out mark 10 tmpl src ${veth_b_addr} dst ${veth_a_addr} proto esp mode tunnel
680 run_cmd ${ns_b} ip -${proto} xfrm poli 475 run_cmd ${ns_b} ip -${proto} xfrm policy add dir in mark 10 tmpl src ${veth_a_addr} dst ${veth_b_addr} proto esp mode tunnel
681 } 476 }
682 477
683 setup_nettest_xfrm() { <<
684 if ! which nettest >/dev/null; then <<
685 PATH=$PWD:$PATH <<
686 if ! which nettest >/dev/null; <<
687 echo "'nettest' comman <<
688 return 1 <<
689 fi <<
690 fi <<
691 <<
692 [ ${1} -eq 6 ] && proto="-6" || proto= <<
693 port=${2} <<
694 <<
695 run_cmd_bg "${ns_a}" nettest "${proto} <<
696 nettest_pids="${nettest_pids} $!" <<
697 <<
698 run_cmd_bg "${ns_b}" nettest "${proto} <<
699 nettest_pids="${nettest_pids} $!" <<
700 } <<
701 <<
702 setup_xfrm4() { 478 setup_xfrm4() {
703 setup_xfrm 4 ${veth4_a_addr} ${veth4_b 479 setup_xfrm 4 ${veth4_a_addr} ${veth4_b_addr}
704 } 480 }
705 481
706 setup_xfrm6() { 482 setup_xfrm6() {
707 setup_xfrm 6 ${veth6_a_addr} ${veth6_b 483 setup_xfrm 6 ${veth6_a_addr} ${veth6_b_addr}
708 } 484 }
709 485
710 setup_xfrm4udp() { <<
711 setup_xfrm 4 ${veth4_a_addr} ${veth4_b <<
712 setup_nettest_xfrm 4 4500 <<
713 } <<
714 <<
715 setup_xfrm6udp() { <<
716 setup_xfrm 6 ${veth6_a_addr} ${veth6_b <<
717 setup_nettest_xfrm 6 4500 <<
718 } <<
719 <<
720 setup_xfrm4udprouted() { <<
721 setup_xfrm 4 ${prefix4}.${a_r1}.1 ${pr <<
722 setup_nettest_xfrm 4 4500 <<
723 } <<
724 <<
725 setup_xfrm6udprouted() { <<
726 setup_xfrm 6 ${prefix6}:${a_r1}::1 ${p <<
727 setup_nettest_xfrm 6 4500 <<
728 } <<
729 <<
730 setup_routing_old() { 486 setup_routing_old() {
731 for i in ${routes}; do 487 for i in ${routes}; do
732 [ "${ns}" = "" ] && ns= 488 [ "${ns}" = "" ] && ns="${i}" && continue
733 [ "${addr}" = "" ] && add 489 [ "${addr}" = "" ] && addr="${i}" && continue
734 [ "${gw}" = "" ] && gw= 490 [ "${gw}" = "" ] && gw="${i}"
735 491
736 ns_name="$(nsname ${ns})" 492 ns_name="$(nsname ${ns})"
737 493
738 ip -n "${ns_name}" route add " !! 494 ip -n ${ns_name} route add ${addr} via ${gw}
739 495
740 ns=""; addr=""; gw="" 496 ns=""; addr=""; gw=""
741 done 497 done
742 } 498 }
743 499
744 setup_routing_new() { 500 setup_routing_new() {
745 for i in ${nexthops}; do 501 for i in ${nexthops}; do
746 [ "${ns}" = "" ] && ns= 502 [ "${ns}" = "" ] && ns="${i}" && continue
747 [ "${fam}" = "" ] && fam 503 [ "${fam}" = "" ] && fam="${i}" && continue
748 [ "${nhid}" = "" ] && nhi 504 [ "${nhid}" = "" ] && nhid="${i}" && continue
749 [ "${gw}" = "" ] && gw= 505 [ "${gw}" = "" ] && gw="${i}" && continue
750 [ "${dev}" = "" ] && dev 506 [ "${dev}" = "" ] && dev="${i}"
751 507
752 ns_name="$(nsname ${ns})" 508 ns_name="$(nsname ${ns})"
753 509
754 ip -n ${ns_name} -${fam} nexth 510 ip -n ${ns_name} -${fam} nexthop add id ${nhid} via ${gw} dev ${dev}
755 511
756 ns=""; fam=""; nhid=""; gw=""; 512 ns=""; fam=""; nhid=""; gw=""; dev=""
757 513
758 done 514 done
759 515
760 for i in ${routes_nh}; do 516 for i in ${routes_nh}; do
761 [ "${ns}" = "" ] && ns= 517 [ "${ns}" = "" ] && ns="${i}" && continue
762 [ "${fam}" = "" ] && fam 518 [ "${fam}" = "" ] && fam="${i}" && continue
763 [ "${addr}" = "" ] && add 519 [ "${addr}" = "" ] && addr="${i}" && continue
764 [ "${nhid}" = "" ] && nhi 520 [ "${nhid}" = "" ] && nhid="${i}"
765 521
766 ns_name="$(nsname ${ns})" 522 ns_name="$(nsname ${ns})"
767 523
768 ip -n "${ns_name}" -"${fam}" r !! 524 ip -n ${ns_name} -${fam} route add ${addr} nhid ${nhid}
769 525
770 ns=""; fam=""; addr=""; nhid=" 526 ns=""; fam=""; addr=""; nhid=""
771 done 527 done
772 } 528 }
773 529
774 setup_routing() { 530 setup_routing() {
775 for i in ${NS_R1} ${NS_R2}; do 531 for i in ${NS_R1} ${NS_R2}; do
776 ip netns exec ${i} sysctl -q n 532 ip netns exec ${i} sysctl -q net/ipv4/ip_forward=1
777 ip netns exec ${i} sysctl -q n 533 ip netns exec ${i} sysctl -q net/ipv6/conf/all/forwarding=1
778 done 534 done
779 535
780 for i in ${routing_addrs}; do 536 for i in ${routing_addrs}; do
781 [ "${ns}" = "" ] && ns= 537 [ "${ns}" = "" ] && ns="${i}" && continue
782 [ "${peer}" = "" ] && pee 538 [ "${peer}" = "" ] && peer="${i}" && continue
783 [ "${segment}" = "" ] && seg 539 [ "${segment}" = "" ] && segment="${i}"
784 540
785 ns_name="$(nsname ${ns})" 541 ns_name="$(nsname ${ns})"
786 peer_name="$(nsname ${peer})" 542 peer_name="$(nsname ${peer})"
787 if="veth_${ns}-${peer}" 543 if="veth_${ns}-${peer}"
788 ifpeer="veth_${peer}-${ns}" 544 ifpeer="veth_${peer}-${ns}"
789 545
790 # Create veth links 546 # Create veth links
791 ip link add ${if} up netns ${n 547 ip link add ${if} up netns ${ns_name} type veth peer name ${ifpeer} netns ${peer_name} || return 1
792 ip -n ${peer_name} link set de 548 ip -n ${peer_name} link set dev ${ifpeer} up
793 549
794 # Add addresses 550 # Add addresses
795 ip -n ${ns_name} addr add ${ 551 ip -n ${ns_name} addr add ${prefix4}.${segment}.1/24 dev ${if}
796 ip -n ${ns_name} addr add ${ 552 ip -n ${ns_name} addr add ${prefix6}:${segment}::1/64 dev ${if}
797 553
798 ip -n ${peer_name} addr add ${ 554 ip -n ${peer_name} addr add ${prefix4}.${segment}.2/24 dev ${ifpeer}
799 ip -n ${peer_name} addr add ${ 555 ip -n ${peer_name} addr add ${prefix6}:${segment}::2/64 dev ${ifpeer}
800 556
801 ns=""; peer=""; segment="" 557 ns=""; peer=""; segment=""
802 done 558 done
803 559
804 if [ "$USE_NH" = "yes" ]; then 560 if [ "$USE_NH" = "yes" ]; then
805 setup_routing_new 561 setup_routing_new
806 else 562 else
807 setup_routing_old 563 setup_routing_old
808 fi 564 fi
809 565
810 return 0 566 return 0
811 } 567 }
812 568
813 setup_policy_routing() { <<
814 setup_routing <<
815 <<
816 ip -netns "${NS_A}" -4 rule add dsfiel <<
817 table "${rt_table}" <<
818 <<
819 # Set the IPv4 Don't Fragment bit with <<
820 # have an option do to it. <<
821 tc -netns "${NS_A}" qdisc replace dev <<
822 tc -netns "${NS_A}" qdisc replace dev <<
823 tc -netns "${NS_A}" filter add dev vet <<
824 protocol ipv4 flower ip_proto <<
825 action pedit ex munge ip df se <<
826 tc -netns "${NS_A}" filter add dev vet <<
827 protocol ipv4 flower ip_proto <<
828 action pedit ex munge ip df se <<
829 } <<
830 <<
831 setup_bridge() { <<
832 run_cmd ${ns_a} ip link add br0 type b <<
833 run_cmd ${ns_a} ip link set br0 up <<
834 <<
835 run_cmd ${ns_c} ip link add veth_C-A t <<
836 run_cmd ${ns_c} ip link set veth_A-C n <<
837 <<
838 run_cmd ${ns_a} ip link set veth_A-C u <<
839 run_cmd ${ns_c} ip link set veth_C-A u <<
840 run_cmd ${ns_c} ip addr add ${veth4_c_ <<
841 run_cmd ${ns_c} ip addr add ${veth6_c_ <<
842 run_cmd ${ns_a} ip link set veth_A-C m <<
843 } <<
844 <<
845 setup_ovs_via_internal_utility() { <<
846 type="${1}" <<
847 a_addr="${2}" <<
848 b_addr="${3}" <<
849 dport="${4}" <<
850 <<
851 run_cmd python3 ./openvswitch/ovs-dpct <<
852 <<
853 ports=$(python3 ./openvswitch/ovs-dpct <<
854 br0_port=$(echo "$ports" | grep -E "\s <<
855 type_a_port=$(echo "$ports" | grep ${t <<
856 veth_a_port=$(echo "$ports" | grep vet <<
857 <<
858 v4_a_tun="${prefix4}.${a_r1}.1" <<
859 v4_b_tun="${prefix4}.${b_r1}.1" <<
860 <<
861 v6_a_tun="${prefix6}:${a_r1}::1" <<
862 v6_b_tun="${prefix6}:${b_r1}::1" <<
863 <<
864 if [ "${v4_a_tun}" = "${a_addr}" ]; th <<
865 run_cmd python3 ./openvswitch/ <<
866 "recirc_id(0),in_port(${ve <<
867 "set(tunnel(tun_id=1,dst=$ <<
868 run_cmd python3 ./openvswitch/ <<
869 "recirc_id(0),in_port(${ve <<
870 "set(tunnel(tun_id=1,dst=$ <<
871 run_cmd python3 ./openvswitch/ <<
872 "recirc_id(0),tunnel(tun_i <<
873 "${veth_a_port}" <<
874 run_cmd python3 ./openvswitch/ <<
875 "recirc_id(0),tunnel(tun_i <<
876 "${veth_a_port}" <<
877 run_cmd python3 ./openvswitch/ <<
878 "recirc_id(0),tunnel(tun_i <<
879 "${veth_a_port}" <<
880 run_cmd python3 ./openvswitch/ <<
881 "recirc_id(0),in_port(${ve <<
882 "set(tunnel(tun_id=1,dst=$ <<
883 else <<
884 run_cmd python3 ./openvswitch/ <<
885 "recirc_id(0),in_port(${ve <<
886 "set(tunnel(tun_id=1,ipv6_ <<
887 run_cmd python3 ./openvswitch/ <<
888 "recirc_id(0),in_port(${ve <<
889 "set(tunnel(tun_id=1,ipv6_ <<
890 run_cmd python3 ./openvswitch/ <<
891 "recirc_id(0),tunnel(tun_i <<
892 "${veth_a_port}" <<
893 run_cmd python3 ./openvswitch/ <<
894 "recirc_id(0),tunnel(tun_i <<
895 "${veth_a_port}" <<
896 run_cmd python3 ./openvswitch/ <<
897 "recirc_id(0),tunnel(tun_i <<
898 "${veth_a_port}" <<
899 run_cmd python3 ./openvswitch/ <<
900 "recirc_id(0),in_port(${ve <<
901 "set(tunnel(tun_id=1,ipv6_ <<
902 fi <<
903 } <<
904 <<
905 setup_ovs_via_vswitchd() { <<
906 type="${1}" <<
907 b_addr="${2}" <<
908 <<
909 run_cmd ovs-vsctl add-port ovs_br0 ${t <<
910 set interface ${type}_a type=$ <<
911 options:remote_ip=${b_addr} op <<
912 } <<
913 <<
914 setup_ovs_vxlan_or_geneve() { <<
915 type="${1}" <<
916 a_addr="${2}" <<
917 b_addr="${3}" <<
918 dport="6081" <<
919 <<
920 if [ "${type}" = "vxlan" ]; then <<
921 dport="4789" <<
922 opts="${opts} ttl 64 dstport 4 <<
923 opts_b="local ${b_addr}" <<
924 fi <<
925 <<
926 setup_ovs_via_internal_utility "${type <<
927 "${dpor <<
928 setup_ovs_via_vswitchd "${type}" " <<
929 <<
930 run_cmd ${ns_b} ip link add ${type}_b <<
931 <<
932 run_cmd ${ns_b} ip addr add ${tunnel4_ <<
933 run_cmd ${ns_b} ip addr add ${tunnel6_ <<
934 <<
935 run_cmd ip link set ${type}_a up <<
936 run_cmd ${ns_b} ip link set ${type}_b <<
937 } <<
938 <<
939 setup_ovs_geneve4() { <<
940 setup_ovs_vxlan_or_geneve geneve ${pre <<
941 } <<
942 <<
943 setup_ovs_vxlan4() { <<
944 setup_ovs_vxlan_or_geneve vxlan ${pre <<
945 } <<
946 <<
947 setup_ovs_geneve6() { <<
948 setup_ovs_vxlan_or_geneve geneve ${pre <<
949 } <<
950 <<
951 setup_ovs_vxlan6() { <<
952 setup_ovs_vxlan_or_geneve vxlan ${pre <<
953 } <<
954 <<
955 setup_ovs_br_internal() { <<
956 run_cmd python3 ./openvswitch/ovs-dpct <<
957 return 1 <<
958 } <<
959 <<
960 setup_ovs_br_vswitchd() { <<
961 run_cmd ovs-vsctl add-br ovs_br0 || re <<
962 } <<
963 <<
964 setup_ovs_add_if() { <<
965 ifname="${1}" <<
966 run_cmd python3 ./openvswitch/ovs-dpct <<
967 "${ifname}" || \ <<
968 run_cmd ovs-vsctl add-port ovs <<
969 } <<
970 <<
971 setup_ovs_bridge() { <<
972 setup_ovs_br_internal || setup_ovs_br_ <<
973 run_cmd ip link set ovs_br0 up <<
974 <<
975 run_cmd ${ns_c} ip link add veth_C-A t <<
976 run_cmd ${ns_c} ip link set veth_A-C n <<
977 <<
978 run_cmd ip link set veth_A-C u <<
979 run_cmd ${ns_c} ip link set veth_C-A u <<
980 run_cmd ${ns_c} ip addr add ${veth4_c_ <<
981 run_cmd ${ns_c} ip addr add ${veth6_c_ <<
982 setup_ovs_add_if veth_A-C <<
983 <<
984 # Move veth_A-R1 to init <<
985 run_cmd ${ns_a} ip link set veth_A-R1 <<
986 run_cmd ip addr add ${prefix4}.${a_r1} <<
987 run_cmd ip addr add ${prefix6}:${a_r1} <<
988 run_cmd ip link set veth_A-R1 up <<
989 run_cmd ip route add ${prefix4}.${b_r1 <<
990 run_cmd ip route add ${prefix6}:${b_r1 <<
991 } <<
992 <<
993 setup() { 569 setup() {
994 [ "$(id -u)" -ne 0 ] && echo " need t 570 [ "$(id -u)" -ne 0 ] && echo " need to run as root" && return $ksft_skip
995 571
>> 572 cleanup
996 for arg do 573 for arg do
997 eval setup_${arg} || { echo " 574 eval setup_${arg} || { echo " ${arg} not supported"; return 1; }
998 done 575 done
999 } 576 }
1000 577
1001 trace() { 578 trace() {
1002 [ $TRACING -eq 0 ] && return 579 [ $TRACING -eq 0 ] && return
1003 580
1004 for arg do 581 for arg do
1005 [ "${ns_cmd}" = "" ] && ns_cm 582 [ "${ns_cmd}" = "" ] && ns_cmd="${arg}" && continue
1006 ${ns_cmd} tcpdump --immediate !! 583 ${ns_cmd} tcpdump -s 0 -i "${arg}" -w "${name}_${arg}.pcap" 2> /dev/null &
1007 tcpdump_pids="${tcpdump_pids} 584 tcpdump_pids="${tcpdump_pids} $!"
1008 ns_cmd= 585 ns_cmd=
1009 done 586 done
1010 sleep 1 587 sleep 1
1011 } 588 }
1012 589
1013 cleanup_del_ovs_internal() { <<
1014 # squelch the output of the del-if co <<
1015 python3 ./openvswitch/ovs-dpctl.py de <<
1016 python3 ./openvswitch/ovs-dpctl.py de <<
1017 python3 ./openvswitch/ovs-dpctl.py de <<
1018 } <<
1019 <<
1020 cleanup_del_ovs_vswitchd() { <<
1021 ovs-vsctl --if-exists del-port vxlan_ <<
1022 ovs-vsctl --if-exists del-br ovs_br0 <<
1023 } <<
1024 <<
1025 cleanup() { 590 cleanup() {
1026 for pid in ${tcpdump_pids}; do 591 for pid in ${tcpdump_pids}; do
1027 kill ${pid} 592 kill ${pid}
1028 done 593 done
1029 tcpdump_pids= 594 tcpdump_pids=
1030 595
1031 for pid in ${nettest_pids}; do !! 596 for n in ${NS_A} ${NS_B} ${NS_R1} ${NS_R2}; do
1032 kill ${pid} !! 597 ip netns del ${n} 2> /dev/null
1033 done <<
1034 nettest_pids= <<
1035 <<
1036 for pid in ${socat_pids}; do <<
1037 kill "${pid}" <<
1038 done 598 done
1039 socat_pids= <<
1040 <<
1041 cleanup_all_ns <<
1042 <<
1043 ip link del veth_A-C 2>/de <<
1044 ip link del veth_A-R1 2>/de <<
1045 cleanup_del_ovs_internal <<
1046 cleanup_del_ovs_vswitchd <<
1047 rm -f "$tmpoutfile" <<
1048 } 599 }
1049 600
1050 mtu() { 601 mtu() {
1051 ns_cmd="${1}" 602 ns_cmd="${1}"
1052 dev="${2}" 603 dev="${2}"
1053 mtu="${3}" 604 mtu="${3}"
1054 605
1055 ${ns_cmd} ip link set dev ${dev} mtu 606 ${ns_cmd} ip link set dev ${dev} mtu ${mtu}
1056 } 607 }
1057 608
1058 mtu_parse() { 609 mtu_parse() {
1059 input="${1}" 610 input="${1}"
1060 611
1061 next=0 612 next=0
1062 for i in ${input}; do 613 for i in ${input}; do
1063 [ ${next} -eq 1 -a "${i}" = " 614 [ ${next} -eq 1 -a "${i}" = "lock" ] && next=2 && continue
1064 [ ${next} -eq 1 ] && echo "${ 615 [ ${next} -eq 1 ] && echo "${i}" && return
1065 [ ${next} -eq 2 ] && echo "lo 616 [ ${next} -eq 2 ] && echo "lock ${i}" && return
1066 [ "${i}" = "mtu" ] && next=1 617 [ "${i}" = "mtu" ] && next=1
1067 done 618 done
1068 } 619 }
1069 620
1070 link_get() { 621 link_get() {
1071 ns_cmd="${1}" 622 ns_cmd="${1}"
1072 name="${2}" 623 name="${2}"
1073 624
1074 ${ns_cmd} ip link show dev "${name}" 625 ${ns_cmd} ip link show dev "${name}"
1075 } 626 }
1076 627
1077 link_get_mtu() { 628 link_get_mtu() {
1078 ns_cmd="${1}" 629 ns_cmd="${1}"
1079 name="${2}" 630 name="${2}"
1080 631
1081 mtu_parse "$(link_get "${ns_cmd}" ${n 632 mtu_parse "$(link_get "${ns_cmd}" ${name})"
1082 } 633 }
1083 634
1084 route_get_dst_exception() { 635 route_get_dst_exception() {
1085 ns_cmd="${1}" 636 ns_cmd="${1}"
1086 dst="${2}" 637 dst="${2}"
1087 dsfield="${3}" <<
1088 <<
1089 if [ -z "${dsfield}" ]; then <<
1090 dsfield=0 <<
1091 fi <<
1092 638
1093 ${ns_cmd} ip route get "${dst}" dsfie !! 639 ${ns_cmd} ip route get "${dst}"
1094 } 640 }
1095 641
1096 route_get_dst_pmtu_from_exception() { 642 route_get_dst_pmtu_from_exception() {
1097 ns_cmd="${1}" 643 ns_cmd="${1}"
1098 dst="${2}" 644 dst="${2}"
1099 dsfield="${3}" <<
1100 645
1101 mtu_parse "$(route_get_dst_exception !! 646 mtu_parse "$(route_get_dst_exception "${ns_cmd}" ${dst})"
1102 } 647 }
1103 648
1104 check_pmtu_value() { 649 check_pmtu_value() {
1105 expected="${1}" 650 expected="${1}"
1106 value="${2}" 651 value="${2}"
1107 event="${3}" 652 event="${3}"
1108 653
1109 [ "${expected}" = "any" ] && [ -n "${ 654 [ "${expected}" = "any" ] && [ -n "${value}" ] && return 0
1110 [ "${value}" = "${expected}" ] && ret 655 [ "${value}" = "${expected}" ] && return 0
1111 [ -z "${value}" ] && err " PMTU e 656 [ -z "${value}" ] && err " PMTU exception wasn't created after ${event}" && return 1
1112 [ -z "${expected}" ] && err " PMTU e 657 [ -z "${expected}" ] && err " PMTU exception shouldn't exist after ${event}" && return 1
1113 err " found PMTU exception with inco 658 err " found PMTU exception with incorrect MTU ${value}, expected ${expected}, after ${event}"
1114 return 1 659 return 1
1115 } 660 }
1116 661
1117 test_pmtu_ipvX() { 662 test_pmtu_ipvX() {
1118 family=${1} 663 family=${1}
1119 664
1120 setup namespaces routing || return $k !! 665 setup namespaces routing || return 2
1121 trace "${ns_a}" veth_A-R1 "${ns_r 666 trace "${ns_a}" veth_A-R1 "${ns_r1}" veth_R1-A \
1122 "${ns_r1}" veth_R1-B "${ns_b 667 "${ns_r1}" veth_R1-B "${ns_b}" veth_B-R1 \
1123 "${ns_a}" veth_A-R2 "${ns_r 668 "${ns_a}" veth_A-R2 "${ns_r2}" veth_R2-A \
1124 "${ns_r2}" veth_R2-B "${ns_b 669 "${ns_r2}" veth_R2-B "${ns_b}" veth_B-R2
1125 670
1126 if [ ${family} -eq 4 ]; then 671 if [ ${family} -eq 4 ]; then
1127 ping=ping 672 ping=ping
1128 dst1="${prefix4}.${b_r1}.1" 673 dst1="${prefix4}.${b_r1}.1"
1129 dst2="${prefix4}.${b_r2}.1" 674 dst2="${prefix4}.${b_r2}.1"
1130 else 675 else
1131 ping=${ping6} 676 ping=${ping6}
1132 dst1="${prefix6}:${b_r1}::1" 677 dst1="${prefix6}:${b_r1}::1"
1133 dst2="${prefix6}:${b_r2}::1" 678 dst2="${prefix6}:${b_r2}::1"
1134 fi 679 fi
1135 680
1136 # Set up initial MTU values 681 # Set up initial MTU values
1137 mtu "${ns_a}" veth_A-R1 2000 682 mtu "${ns_a}" veth_A-R1 2000
1138 mtu "${ns_r1}" veth_R1-A 2000 683 mtu "${ns_r1}" veth_R1-A 2000
1139 mtu "${ns_r1}" veth_R1-B 1400 684 mtu "${ns_r1}" veth_R1-B 1400
1140 mtu "${ns_b}" veth_B-R1 1400 685 mtu "${ns_b}" veth_B-R1 1400
1141 686
1142 mtu "${ns_a}" veth_A-R2 2000 687 mtu "${ns_a}" veth_A-R2 2000
1143 mtu "${ns_r2}" veth_R2-A 2000 688 mtu "${ns_r2}" veth_R2-A 2000
1144 mtu "${ns_r2}" veth_R2-B 1500 689 mtu "${ns_r2}" veth_R2-B 1500
1145 mtu "${ns_b}" veth_B-R2 1500 690 mtu "${ns_b}" veth_B-R2 1500
1146 691
1147 # Create route exceptions 692 # Create route exceptions
1148 run_cmd ${ns_a} ${ping} -q -M want -i 693 run_cmd ${ns_a} ${ping} -q -M want -i 0.1 -w 1 -s 1800 ${dst1}
1149 run_cmd ${ns_a} ${ping} -q -M want -i 694 run_cmd ${ns_a} ${ping} -q -M want -i 0.1 -w 1 -s 1800 ${dst2}
1150 695
1151 # Check that exceptions have been cre 696 # Check that exceptions have been created with the correct PMTU
1152 pmtu_1="$(route_get_dst_pmtu_from_exc 697 pmtu_1="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst1})"
1153 check_pmtu_value "1400" "${pmtu_1}" " 698 check_pmtu_value "1400" "${pmtu_1}" "exceeding MTU" || return 1
1154 pmtu_2="$(route_get_dst_pmtu_from_exc 699 pmtu_2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst2})"
1155 check_pmtu_value "1500" "${pmtu_2}" " 700 check_pmtu_value "1500" "${pmtu_2}" "exceeding MTU" || return 1
1156 701
1157 # Decrease local MTU below PMTU, chec 702 # Decrease local MTU below PMTU, check for PMTU decrease in route exception
1158 mtu "${ns_a}" veth_A-R1 1300 703 mtu "${ns_a}" veth_A-R1 1300
1159 mtu "${ns_r1}" veth_R1-A 1300 704 mtu "${ns_r1}" veth_R1-A 1300
1160 pmtu_1="$(route_get_dst_pmtu_from_exc 705 pmtu_1="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst1})"
1161 check_pmtu_value "1300" "${pmtu_1}" " 706 check_pmtu_value "1300" "${pmtu_1}" "decreasing local MTU" || return 1
1162 # Second exception shouldn't be modif 707 # Second exception shouldn't be modified
1163 pmtu_2="$(route_get_dst_pmtu_from_exc 708 pmtu_2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst2})"
1164 check_pmtu_value "1500" "${pmtu_2}" " 709 check_pmtu_value "1500" "${pmtu_2}" "changing local MTU on a link not on this path" || return 1
1165 710
1166 # Increase MTU, check for PMTU increa 711 # Increase MTU, check for PMTU increase in route exception
1167 mtu "${ns_a}" veth_A-R1 1700 712 mtu "${ns_a}" veth_A-R1 1700
1168 mtu "${ns_r1}" veth_R1-A 1700 713 mtu "${ns_r1}" veth_R1-A 1700
1169 pmtu_1="$(route_get_dst_pmtu_from_exc 714 pmtu_1="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst1})"
1170 check_pmtu_value "1700" "${pmtu_1}" " 715 check_pmtu_value "1700" "${pmtu_1}" "increasing local MTU" || return 1
1171 # Second exception shouldn't be modif 716 # Second exception shouldn't be modified
1172 pmtu_2="$(route_get_dst_pmtu_from_exc 717 pmtu_2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst2})"
1173 check_pmtu_value "1500" "${pmtu_2}" " 718 check_pmtu_value "1500" "${pmtu_2}" "changing local MTU on a link not on this path" || return 1
1174 719
1175 # Skip PMTU locking tests for IPv6 720 # Skip PMTU locking tests for IPv6
1176 [ $family -eq 6 ] && return 0 721 [ $family -eq 6 ] && return 0
1177 722
1178 # Decrease remote MTU on path via R2, 723 # Decrease remote MTU on path via R2, get new exception
1179 mtu "${ns_r2}" veth_R2-B 400 724 mtu "${ns_r2}" veth_R2-B 400
1180 mtu "${ns_b}" veth_B-R2 400 725 mtu "${ns_b}" veth_B-R2 400
1181 run_cmd ${ns_a} ${ping} -q -M want -i 726 run_cmd ${ns_a} ${ping} -q -M want -i 0.1 -w 1 -s 1400 ${dst2}
1182 pmtu_2="$(route_get_dst_pmtu_from_exc 727 pmtu_2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst2})"
1183 check_pmtu_value "lock 552" "${pmtu_2 728 check_pmtu_value "lock 552" "${pmtu_2}" "exceeding MTU, with MTU < min_pmtu" || return 1
1184 729
1185 # Decrease local MTU below PMTU 730 # Decrease local MTU below PMTU
1186 mtu "${ns_a}" veth_A-R2 500 731 mtu "${ns_a}" veth_A-R2 500
1187 mtu "${ns_r2}" veth_R2-A 500 732 mtu "${ns_r2}" veth_R2-A 500
1188 pmtu_2="$(route_get_dst_pmtu_from_exc 733 pmtu_2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst2})"
1189 check_pmtu_value "500" "${pmtu_2}" "d 734 check_pmtu_value "500" "${pmtu_2}" "decreasing local MTU" || return 1
1190 735
1191 # Increase local MTU 736 # Increase local MTU
1192 mtu "${ns_a}" veth_A-R2 1500 737 mtu "${ns_a}" veth_A-R2 1500
1193 mtu "${ns_r2}" veth_R2-A 1500 738 mtu "${ns_r2}" veth_R2-A 1500
1194 pmtu_2="$(route_get_dst_pmtu_from_exc 739 pmtu_2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst2})"
1195 check_pmtu_value "1500" "${pmtu_2}" " 740 check_pmtu_value "1500" "${pmtu_2}" "increasing local MTU" || return 1
1196 741
1197 # Get new exception 742 # Get new exception
1198 run_cmd ${ns_a} ${ping} -q -M want -i 743 run_cmd ${ns_a} ${ping} -q -M want -i 0.1 -w 1 -s 1400 ${dst2}
1199 pmtu_2="$(route_get_dst_pmtu_from_exc 744 pmtu_2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst2})"
1200 check_pmtu_value "lock 552" "${pmtu_2 745 check_pmtu_value "lock 552" "${pmtu_2}" "exceeding MTU, with MTU < min_pmtu" || return 1
1201 } 746 }
1202 747
1203 test_pmtu_ipv4_exception() { 748 test_pmtu_ipv4_exception() {
1204 test_pmtu_ipvX 4 749 test_pmtu_ipvX 4
1205 } 750 }
1206 751
1207 test_pmtu_ipv6_exception() { 752 test_pmtu_ipv6_exception() {
1208 test_pmtu_ipvX 6 753 test_pmtu_ipvX 6
1209 } 754 }
1210 755
1211 test_pmtu_ipv4_dscp_icmp_exception() { <<
1212 rt_table=100 <<
1213 <<
1214 setup namespaces policy_routing || re <<
1215 trace "${ns_a}" veth_A-R1 "${ns_r <<
1216 "${ns_r1}" veth_R1-B "${ns_b <<
1217 "${ns_a}" veth_A-R2 "${ns_r <<
1218 "${ns_r2}" veth_R2-B "${ns_b <<
1219 <<
1220 # Set up initial MTU values <<
1221 mtu "${ns_a}" veth_A-R1 2000 <<
1222 mtu "${ns_r1}" veth_R1-A 2000 <<
1223 mtu "${ns_r1}" veth_R1-B 1400 <<
1224 mtu "${ns_b}" veth_B-R1 1400 <<
1225 <<
1226 mtu "${ns_a}" veth_A-R2 2000 <<
1227 mtu "${ns_r2}" veth_R2-A 2000 <<
1228 mtu "${ns_r2}" veth_R2-B 1500 <<
1229 mtu "${ns_b}" veth_B-R2 1500 <<
1230 <<
1231 len=$((2000 - 20 - 8)) # Fills MTU of <<
1232 <<
1233 dst1="${prefix4}.${b_r1}.1" <<
1234 dst2="${prefix4}.${b_r2}.1" <<
1235 <<
1236 # Create route exceptions <<
1237 dsfield=${policy_mark} # No ECN bit s <<
1238 run_cmd "${ns_a}" ping -q -M want -Q <<
1239 <<
1240 dsfield=$(printf "%#x" $((policy_mark <<
1241 run_cmd "${ns_a}" ping -q -M want -Q <<
1242 <<
1243 # Check that exceptions have been cre <<
1244 pmtu_1="$(route_get_dst_pmtu_from_exc <<
1245 check_pmtu_value "1400" "${pmtu_1}" " <<
1246 <<
1247 pmtu_2="$(route_get_dst_pmtu_from_exc <<
1248 check_pmtu_value "1500" "${pmtu_2}" " <<
1249 } <<
1250 <<
1251 test_pmtu_ipv4_dscp_udp_exception() { <<
1252 rt_table=100 <<
1253 <<
1254 if ! which socat > /dev/null 2>&1; th <<
1255 echo "'socat' command not fou <<
1256 return $ksft_skip <<
1257 fi <<
1258 <<
1259 setup namespaces policy_routing || re <<
1260 trace "${ns_a}" veth_A-R1 "${ns_r <<
1261 "${ns_r1}" veth_R1-B "${ns_b <<
1262 "${ns_a}" veth_A-R2 "${ns_r <<
1263 "${ns_r2}" veth_R2-B "${ns_b <<
1264 <<
1265 # Set up initial MTU values <<
1266 mtu "${ns_a}" veth_A-R1 2000 <<
1267 mtu "${ns_r1}" veth_R1-A 2000 <<
1268 mtu "${ns_r1}" veth_R1-B 1400 <<
1269 mtu "${ns_b}" veth_B-R1 1400 <<
1270 <<
1271 mtu "${ns_a}" veth_A-R2 2000 <<
1272 mtu "${ns_r2}" veth_R2-A 2000 <<
1273 mtu "${ns_r2}" veth_R2-B 1500 <<
1274 mtu "${ns_b}" veth_B-R2 1500 <<
1275 <<
1276 len=$((2000 - 20 - 8)) # Fills MTU of <<
1277 <<
1278 dst1="${prefix4}.${b_r1}.1" <<
1279 dst2="${prefix4}.${b_r2}.1" <<
1280 <<
1281 # Create route exceptions <<
1282 run_cmd_bg "${ns_b}" socat UDP-LISTEN <<
1283 socat_pids="${socat_pids} $!" <<
1284 <<
1285 dsfield=${policy_mark} # No ECN bit s <<
1286 run_cmd "${ns_a}" socat OPEN:/dev/zer <<
1287 UDP:"${dst1}":50000,tos="${ds <<
1288 <<
1289 dsfield=$(printf "%#x" $((policy_mark <<
1290 run_cmd "${ns_a}" socat OPEN:/dev/zer <<
1291 UDP:"${dst2}":50000,tos="${ds <<
1292 <<
1293 # Check that exceptions have been cre <<
1294 pmtu_1="$(route_get_dst_pmtu_from_exc <<
1295 check_pmtu_value "1400" "${pmtu_1}" " <<
1296 pmtu_2="$(route_get_dst_pmtu_from_exc <<
1297 check_pmtu_value "1500" "${pmtu_2}" " <<
1298 } <<
1299 <<
1300 test_pmtu_ipvX_over_vxlanY_or_geneveY_excepti 756 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception() {
1301 type=${1} 757 type=${1}
1302 family=${2} 758 family=${2}
1303 outer_family=${3} 759 outer_family=${3}
1304 ll_mtu=4000 760 ll_mtu=4000
1305 761
1306 if [ ${outer_family} -eq 4 ]; then 762 if [ ${outer_family} -eq 4 ]; then
1307 setup namespaces routing ${ty !! 763 setup namespaces routing ${type}4 || return 2
1308 # IPv4 h 764 # IPv4 header UDP header VXLAN/GENEVE header Ethernet header
1309 exp_mtu=$((${ll_mtu} - 20 765 exp_mtu=$((${ll_mtu} - 20 - 8 - 8 - 14))
1310 else 766 else
1311 setup namespaces routing ${ty !! 767 setup namespaces routing ${type}6 || return 2
1312 # IPv6 h 768 # IPv6 header UDP header VXLAN/GENEVE header Ethernet header
1313 exp_mtu=$((${ll_mtu} - 40 769 exp_mtu=$((${ll_mtu} - 40 - 8 - 8 - 14))
1314 fi 770 fi
1315 771
1316 trace "${ns_a}" ${type}_a "${ns_b} 772 trace "${ns_a}" ${type}_a "${ns_b}" ${type}_b \
1317 "${ns_a}" veth_A-R1 "${ns_r1 773 "${ns_a}" veth_A-R1 "${ns_r1}" veth_R1-A \
1318 "${ns_b}" veth_B-R1 "${ns_r1 774 "${ns_b}" veth_B-R1 "${ns_r1}" veth_R1-B
1319 775
1320 if [ ${family} -eq 4 ]; then 776 if [ ${family} -eq 4 ]; then
1321 ping=ping 777 ping=ping
1322 dst=${tunnel4_b_addr} 778 dst=${tunnel4_b_addr}
1323 else 779 else
1324 ping=${ping6} 780 ping=${ping6}
1325 dst=${tunnel6_b_addr} 781 dst=${tunnel6_b_addr}
1326 fi 782 fi
1327 783
1328 # Create route exception by exceeding 784 # Create route exception by exceeding link layer MTU
1329 mtu "${ns_a}" veth_A-R1 $((${ll_mtu} 785 mtu "${ns_a}" veth_A-R1 $((${ll_mtu} + 1000))
1330 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} 786 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} + 1000))
1331 mtu "${ns_b}" veth_B-R1 ${ll_mtu} 787 mtu "${ns_b}" veth_B-R1 ${ll_mtu}
1332 mtu "${ns_r1}" veth_R1-B ${ll_mtu} 788 mtu "${ns_r1}" veth_R1-B ${ll_mtu}
1333 789
1334 mtu "${ns_a}" ${type}_a $((${ll_mtu} 790 mtu "${ns_a}" ${type}_a $((${ll_mtu} + 1000))
1335 mtu "${ns_b}" ${type}_b $((${ll_mtu} 791 mtu "${ns_b}" ${type}_b $((${ll_mtu} + 1000))
1336 run_cmd ${ns_a} ${ping} -q -M want -i 792 run_cmd ${ns_a} ${ping} -q -M want -i 0.1 -w 1 -s $((${ll_mtu} + 500)) ${dst}
1337 793
1338 # Check that exception was created 794 # Check that exception was created
1339 pmtu="$(route_get_dst_pmtu_from_excep 795 pmtu="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst})"
1340 check_pmtu_value ${exp_mtu} "${pmtu}" 796 check_pmtu_value ${exp_mtu} "${pmtu}" "exceeding link layer MTU on ${type} interface"
1341 } 797 }
1342 798
1343 test_pmtu_ipv4_vxlan4_exception() { 799 test_pmtu_ipv4_vxlan4_exception() {
1344 test_pmtu_ipvX_over_vxlanY_or_geneveY 800 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception vxlan 4 4
1345 } 801 }
1346 802
1347 test_pmtu_ipv6_vxlan4_exception() { 803 test_pmtu_ipv6_vxlan4_exception() {
1348 test_pmtu_ipvX_over_vxlanY_or_geneveY 804 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception vxlan 6 4
1349 } 805 }
1350 806
1351 test_pmtu_ipv4_geneve4_exception() { 807 test_pmtu_ipv4_geneve4_exception() {
1352 test_pmtu_ipvX_over_vxlanY_or_geneveY 808 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception geneve 4 4
1353 } 809 }
1354 810
1355 test_pmtu_ipv6_geneve4_exception() { 811 test_pmtu_ipv6_geneve4_exception() {
1356 test_pmtu_ipvX_over_vxlanY_or_geneveY 812 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception geneve 6 4
1357 } 813 }
1358 814
1359 test_pmtu_ipv4_vxlan6_exception() { 815 test_pmtu_ipv4_vxlan6_exception() {
1360 test_pmtu_ipvX_over_vxlanY_or_geneveY 816 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception vxlan 4 6
1361 } 817 }
1362 818
1363 test_pmtu_ipv6_vxlan6_exception() { 819 test_pmtu_ipv6_vxlan6_exception() {
1364 test_pmtu_ipvX_over_vxlanY_or_geneveY 820 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception vxlan 6 6
1365 } 821 }
1366 822
1367 test_pmtu_ipv4_geneve6_exception() { 823 test_pmtu_ipv4_geneve6_exception() {
1368 test_pmtu_ipvX_over_vxlanY_or_geneveY 824 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception geneve 4 6
1369 } 825 }
1370 826
1371 test_pmtu_ipv6_geneve6_exception() { 827 test_pmtu_ipv6_geneve6_exception() {
1372 test_pmtu_ipvX_over_vxlanY_or_geneveY 828 test_pmtu_ipvX_over_vxlanY_or_geneveY_exception geneve 6 6
1373 } 829 }
1374 830
1375 test_pmtu_ipvX_over_bridged_vxlanY_or_geneveY <<
1376 type=${1} <<
1377 family=${2} <<
1378 outer_family=${3} <<
1379 ll_mtu=4000 <<
1380 <<
1381 if [ ${outer_family} -eq 4 ]; then <<
1382 setup namespaces routing brid <<
1383 # IPv4 h <<
1384 exp_mtu=$((${ll_mtu} - 20 <<
1385 else <<
1386 setup namespaces routing brid <<
1387 # IPv6 h <<
1388 exp_mtu=$((${ll_mtu} - 40 <<
1389 fi <<
1390 <<
1391 trace "${ns_a}" ${type}_a "${ns_b} <<
1392 "${ns_a}" veth_A-R1 "${ns_r1 <<
1393 "${ns_b}" veth_B-R1 "${ns_r1 <<
1394 "${ns_a}" br0 "${ns_a} <<
1395 "${ns_c}" veth_C-A <<
1396 <<
1397 if [ ${family} -eq 4 ]; then <<
1398 ping=ping <<
1399 dst=${tunnel4_b_addr} <<
1400 else <<
1401 ping=${ping6} <<
1402 dst=${tunnel6_b_addr} <<
1403 fi <<
1404 <<
1405 # Create route exception by exceeding <<
1406 mtu "${ns_a}" veth_A-R1 $((${ll_mtu} <<
1407 mtu "${ns_a}" br0 $((${ll_mtu} <<
1408 mtu "${ns_a}" veth_A-C $((${ll_mtu} <<
1409 mtu "${ns_c}" veth_C-A $((${ll_mtu} <<
1410 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} <<
1411 mtu "${ns_b}" veth_B-R1 ${ll_mtu} <<
1412 mtu "${ns_r1}" veth_R1-B ${ll_mtu} <<
1413 <<
1414 mtu "${ns_a}" ${type}_a $((${ll_mtu} <<
1415 mtu "${ns_b}" ${type}_b $((${ll_mtu} <<
1416 <<
1417 run_cmd ${ns_c} ${ping} -q -M want -i <<
1418 run_cmd ${ns_a} ${ping} -q -M want -i <<
1419 <<
1420 # Check that exceptions were created <<
1421 pmtu="$(route_get_dst_pmtu_from_excep <<
1422 check_pmtu_value ${exp_mtu} "${pmtu}" <<
1423 pmtu="$(route_get_dst_pmtu_from_excep <<
1424 check_pmtu_value ${exp_mtu} "${pmtu}" <<
1425 <<
1426 tmpoutfile=$(mktemp) <<
1427 <<
1428 # Flush Exceptions, retry with TCP <<
1429 run_cmd ${ns_a} ip route flush cached <<
1430 run_cmd ${ns_b} ip route flush cached <<
1431 run_cmd ${ns_c} ip route flush cached <<
1432 <<
1433 for target in "${ns_a}" "${ns_c}" ; d <<
1434 if [ ${family} -eq 4 ]; then <<
1435 TCPDST=TCP:${dst}:500 <<
1436 else <<
1437 TCPDST="TCP:[${dst}]: <<
1438 fi <<
1439 ${ns_b} socat -T 3 -u -6 TCP- <<
1440 local socat_pid=$! <<
1441 <<
1442 wait_local_port_listen ${NS_B <<
1443 <<
1444 dd if=/dev/zero status=none b <<
1445 <<
1446 wait ${socat_pid} <<
1447 size=$(du -sb $tmpoutfile) <<
1448 size=${size%%/tmp/*} <<
1449 <<
1450 [ $size -ne 1048576 ] && err <<
1451 done <<
1452 <<
1453 rm -f "$tmpoutfile" <<
1454 <<
1455 # Check that exceptions were created <<
1456 pmtu="$(route_get_dst_pmtu_from_excep <<
1457 check_pmtu_value ${exp_mtu} "${pmtu}" <<
1458 pmtu="$(route_get_dst_pmtu_from_excep <<
1459 check_pmtu_value ${exp_mtu} "${pmtu}" <<
1460 } <<
1461 <<
1462 test_pmtu_ipv4_br_vxlan4_exception() { <<
1463 test_pmtu_ipvX_over_bridged_vxlanY_or <<
1464 } <<
1465 <<
1466 test_pmtu_ipv6_br_vxlan4_exception() { <<
1467 test_pmtu_ipvX_over_bridged_vxlanY_or <<
1468 } <<
1469 <<
1470 test_pmtu_ipv4_br_geneve4_exception() { <<
1471 test_pmtu_ipvX_over_bridged_vxlanY_or <<
1472 } <<
1473 <<
1474 test_pmtu_ipv6_br_geneve4_exception() { <<
1475 test_pmtu_ipvX_over_bridged_vxlanY_or <<
1476 } <<
1477 <<
1478 test_pmtu_ipv4_br_vxlan6_exception() { <<
1479 test_pmtu_ipvX_over_bridged_vxlanY_or <<
1480 } <<
1481 <<
1482 test_pmtu_ipv6_br_vxlan6_exception() { <<
1483 test_pmtu_ipvX_over_bridged_vxlanY_or <<
1484 } <<
1485 <<
1486 test_pmtu_ipv4_br_geneve6_exception() { <<
1487 test_pmtu_ipvX_over_bridged_vxlanY_or <<
1488 } <<
1489 <<
1490 test_pmtu_ipv6_br_geneve6_exception() { <<
1491 test_pmtu_ipvX_over_bridged_vxlanY_or <<
1492 } <<
1493 <<
1494 test_pmtu_ipvX_over_ovs_vxlanY_or_geneveY_exc <<
1495 type=${1} <<
1496 family=${2} <<
1497 outer_family=${3} <<
1498 ll_mtu=4000 <<
1499 <<
1500 if [ "${type}" = "vxlan" ]; then <<
1501 tun_a="vxlan_sys_4789" <<
1502 elif [ "${type}" = "geneve" ]; then <<
1503 tun_a="genev_sys_6081" <<
1504 fi <<
1505 <<
1506 if [ ${outer_family} -eq 4 ]; then <<
1507 setup namespaces routing ovs_ <<
1508 # IPv4 h <<
1509 exp_mtu=$((${ll_mtu} - 20 <<
1510 else <<
1511 setup namespaces routing ovs_ <<
1512 # IPv6 h <<
1513 exp_mtu=$((${ll_mtu} - 40 <<
1514 fi <<
1515 <<
1516 trace "" ${type}_a "${ns_b} <<
1517 "" veth_A-R1 "${ns_r1 <<
1518 "${ns_b}" veth_B-R1 "${ns_r1 <<
1519 "" ovs_br0 "" <<
1520 "${ns_c}" veth_C-A "" <<
1521 <<
1522 if [ ${family} -eq 4 ]; then <<
1523 ping=ping <<
1524 dst=${tunnel4_b_addr} <<
1525 else <<
1526 ping=${ping6} <<
1527 dst=${tunnel6_b_addr} <<
1528 fi <<
1529 <<
1530 # Create route exception by exceeding <<
1531 mtu "" veth_A-R1 $((${ll_mtu} <<
1532 mtu "" ovs_br0 $((${ll_mtu} <<
1533 mtu "" veth_A-C $((${ll_mtu} <<
1534 mtu "${ns_c}" veth_C-A $((${ll_mtu} <<
1535 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} <<
1536 mtu "${ns_b}" veth_B-R1 ${ll_mtu} <<
1537 mtu "${ns_r1}" veth_R1-B ${ll_mtu} <<
1538 <<
1539 mtu "" ${tun_a} $((${ll_mtu} <<
1540 mtu "" ${type}_a $(($ <<
1541 mtu "${ns_b}" ${type}_b $((${ll_mtu} <<
1542 <<
1543 run_cmd ${ns_c} ${ping} -q -M want -i <<
1544 <<
1545 # Check that exceptions were created <<
1546 pmtu="$(route_get_dst_pmtu_from_excep <<
1547 check_pmtu_value ${exp_mtu} "${pmtu}" <<
1548 } <<
1549 <<
1550 test_pmtu_ipv4_ovs_vxlan4_exception() { <<
1551 test_pmtu_ipvX_over_ovs_vxlanY_or_gen <<
1552 } <<
1553 <<
1554 test_pmtu_ipv6_ovs_vxlan4_exception() { <<
1555 test_pmtu_ipvX_over_ovs_vxlanY_or_gen <<
1556 } <<
1557 <<
1558 test_pmtu_ipv4_ovs_geneve4_exception() { <<
1559 test_pmtu_ipvX_over_ovs_vxlanY_or_gen <<
1560 } <<
1561 <<
1562 test_pmtu_ipv6_ovs_geneve4_exception() { <<
1563 test_pmtu_ipvX_over_ovs_vxlanY_or_gen <<
1564 } <<
1565 <<
1566 test_pmtu_ipv4_ovs_vxlan6_exception() { <<
1567 test_pmtu_ipvX_over_ovs_vxlanY_or_gen <<
1568 } <<
1569 <<
1570 test_pmtu_ipv6_ovs_vxlan6_exception() { <<
1571 test_pmtu_ipvX_over_ovs_vxlanY_or_gen <<
1572 } <<
1573 <<
1574 test_pmtu_ipv4_ovs_geneve6_exception() { <<
1575 test_pmtu_ipvX_over_ovs_vxlanY_or_gen <<
1576 } <<
1577 <<
1578 test_pmtu_ipv6_ovs_geneve6_exception() { <<
1579 test_pmtu_ipvX_over_ovs_vxlanY_or_gen <<
1580 } <<
1581 <<
1582 test_pmtu_ipvX_over_fouY_or_gueY() { 831 test_pmtu_ipvX_over_fouY_or_gueY() {
1583 inner_family=${1} 832 inner_family=${1}
1584 outer_family=${2} 833 outer_family=${2}
1585 encap=${3} 834 encap=${3}
1586 ll_mtu=4000 835 ll_mtu=4000
1587 836
1588 setup namespaces routing ${encap}${ou !! 837 setup namespaces routing ${encap}${outer_family}${inner_family} || return 2
1589 trace "${ns_a}" ${encap}_a "${ns_b} 838 trace "${ns_a}" ${encap}_a "${ns_b}" ${encap}_b \
1590 "${ns_a}" veth_A-R1 "${ns_r1 839 "${ns_a}" veth_A-R1 "${ns_r1}" veth_R1-A \
1591 "${ns_b}" veth_B-R1 "${ns_r1 840 "${ns_b}" veth_B-R1 "${ns_r1}" veth_R1-B
1592 841
1593 if [ ${inner_family} -eq 4 ]; then 842 if [ ${inner_family} -eq 4 ]; then
1594 ping=ping 843 ping=ping
1595 dst=${tunnel4_b_addr} 844 dst=${tunnel4_b_addr}
1596 else 845 else
1597 ping=${ping6} 846 ping=${ping6}
1598 dst=${tunnel6_b_addr} 847 dst=${tunnel6_b_addr}
1599 fi 848 fi
1600 849
1601 if [ "${encap}" = "gue" ]; then 850 if [ "${encap}" = "gue" ]; then
1602 encap_overhead=4 851 encap_overhead=4
1603 else 852 else
1604 encap_overhead=0 853 encap_overhead=0
1605 fi 854 fi
1606 855
1607 if [ ${outer_family} -eq 4 ]; then 856 if [ ${outer_family} -eq 4 ]; then
1608 # IPv4 h 857 # IPv4 header UDP header
1609 exp_mtu=$((${ll_mtu} - 20 858 exp_mtu=$((${ll_mtu} - 20 - 8 - ${encap_overhead}))
1610 else 859 else
1611 # IPv6 h 860 # IPv6 header Option 4 UDP header
1612 exp_mtu=$((${ll_mtu} - 40 861 exp_mtu=$((${ll_mtu} - 40 - 8 - 8 - ${encap_overhead}))
1613 fi 862 fi
1614 863
1615 # Create route exception by exceeding 864 # Create route exception by exceeding link layer MTU
1616 mtu "${ns_a}" veth_A-R1 $((${ll_mtu} 865 mtu "${ns_a}" veth_A-R1 $((${ll_mtu} + 1000))
1617 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} 866 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} + 1000))
1618 mtu "${ns_b}" veth_B-R1 ${ll_mtu} 867 mtu "${ns_b}" veth_B-R1 ${ll_mtu}
1619 mtu "${ns_r1}" veth_R1-B ${ll_mtu} 868 mtu "${ns_r1}" veth_R1-B ${ll_mtu}
1620 869
1621 mtu "${ns_a}" ${encap}_a $((${ll_mtu} 870 mtu "${ns_a}" ${encap}_a $((${ll_mtu} + 1000))
1622 mtu "${ns_b}" ${encap}_b $((${ll_mtu} 871 mtu "${ns_b}" ${encap}_b $((${ll_mtu} + 1000))
1623 run_cmd ${ns_a} ${ping} -q -M want -i 872 run_cmd ${ns_a} ${ping} -q -M want -i 0.1 -w 1 -s $((${ll_mtu} + 500)) ${dst}
1624 873
1625 # Check that exception was created 874 # Check that exception was created
1626 pmtu="$(route_get_dst_pmtu_from_excep 875 pmtu="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst})"
1627 check_pmtu_value ${exp_mtu} "${pmtu}" 876 check_pmtu_value ${exp_mtu} "${pmtu}" "exceeding link layer MTU on ${encap} interface"
1628 } 877 }
1629 878
1630 test_pmtu_ipv4_fou4_exception() { 879 test_pmtu_ipv4_fou4_exception() {
1631 test_pmtu_ipvX_over_fouY_or_gueY 4 4 880 test_pmtu_ipvX_over_fouY_or_gueY 4 4 fou
1632 } 881 }
1633 882
1634 test_pmtu_ipv6_fou4_exception() { 883 test_pmtu_ipv6_fou4_exception() {
1635 test_pmtu_ipvX_over_fouY_or_gueY 6 4 884 test_pmtu_ipvX_over_fouY_or_gueY 6 4 fou
1636 } 885 }
1637 886
1638 test_pmtu_ipv4_fou6_exception() { 887 test_pmtu_ipv4_fou6_exception() {
1639 test_pmtu_ipvX_over_fouY_or_gueY 4 6 888 test_pmtu_ipvX_over_fouY_or_gueY 4 6 fou
1640 } 889 }
1641 890
1642 test_pmtu_ipv6_fou6_exception() { 891 test_pmtu_ipv6_fou6_exception() {
1643 test_pmtu_ipvX_over_fouY_or_gueY 6 6 892 test_pmtu_ipvX_over_fouY_or_gueY 6 6 fou
1644 } 893 }
1645 894
1646 test_pmtu_ipv4_gue4_exception() { 895 test_pmtu_ipv4_gue4_exception() {
1647 test_pmtu_ipvX_over_fouY_or_gueY 4 4 896 test_pmtu_ipvX_over_fouY_or_gueY 4 4 gue
1648 } 897 }
1649 898
1650 test_pmtu_ipv6_gue4_exception() { 899 test_pmtu_ipv6_gue4_exception() {
1651 test_pmtu_ipvX_over_fouY_or_gueY 6 4 900 test_pmtu_ipvX_over_fouY_or_gueY 6 4 gue
1652 } 901 }
1653 902
1654 test_pmtu_ipv4_gue6_exception() { 903 test_pmtu_ipv4_gue6_exception() {
1655 test_pmtu_ipvX_over_fouY_or_gueY 4 6 904 test_pmtu_ipvX_over_fouY_or_gueY 4 6 gue
1656 } 905 }
1657 906
1658 test_pmtu_ipv6_gue6_exception() { 907 test_pmtu_ipv6_gue6_exception() {
1659 test_pmtu_ipvX_over_fouY_or_gueY 6 6 908 test_pmtu_ipvX_over_fouY_or_gueY 6 6 gue
1660 } 909 }
1661 910
1662 test_pmtu_ipvX_over_ipvY_exception() { <<
1663 inner=${1} <<
1664 outer=${2} <<
1665 ll_mtu=4000 <<
1666 <<
1667 setup namespaces routing ip${inner}ip <<
1668 <<
1669 trace "${ns_a}" ip_a "${ns_b} <<
1670 "${ns_a}" veth_A-R1 "${ns_r1 <<
1671 "${ns_b}" veth_B-R1 "${ns_r1 <<
1672 <<
1673 if [ ${inner} -eq 4 ]; then <<
1674 ping=ping <<
1675 dst=${tunnel4_b_addr} <<
1676 else <<
1677 ping=${ping6} <<
1678 dst=${tunnel6_b_addr} <<
1679 fi <<
1680 <<
1681 if [ ${outer} -eq 4 ]; then <<
1682 # IPv4 h <<
1683 exp_mtu=$((${ll_mtu} - 20)) <<
1684 else <<
1685 # IPv6 h <<
1686 exp_mtu=$((${ll_mtu} - 40 <<
1687 fi <<
1688 <<
1689 # Create route exception by exceeding <<
1690 mtu "${ns_a}" veth_A-R1 $((${ll_mtu} <<
1691 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} <<
1692 mtu "${ns_b}" veth_B-R1 ${ll_mtu} <<
1693 mtu "${ns_r1}" veth_R1-B ${ll_mtu} <<
1694 <<
1695 mtu "${ns_a}" ip_a $((${ll_mtu} + 100 <<
1696 mtu "${ns_b}" ip_b $((${ll_mtu} + 100 <<
1697 run_cmd ${ns_a} ${ping} -q -M want -i <<
1698 <<
1699 # Check that exception was created <<
1700 pmtu="$(route_get_dst_pmtu_from_excep <<
1701 check_pmtu_value ${exp_mtu} "${pmtu}" <<
1702 } <<
1703 <<
1704 test_pmtu_ipv4_ipv4_exception() { <<
1705 test_pmtu_ipvX_over_ipvY_exception 4 <<
1706 } <<
1707 <<
1708 test_pmtu_ipv6_ipv4_exception() { <<
1709 test_pmtu_ipvX_over_ipvY_exception 6 <<
1710 } <<
1711 <<
1712 test_pmtu_ipv4_ipv6_exception() { <<
1713 test_pmtu_ipvX_over_ipvY_exception 4 <<
1714 } <<
1715 <<
1716 test_pmtu_ipv6_ipv6_exception() { <<
1717 test_pmtu_ipvX_over_ipvY_exception 6 <<
1718 } <<
1719 <<
1720 test_pmtu_vti4_exception() { 911 test_pmtu_vti4_exception() {
1721 setup namespaces veth vti4 xfrm4 || r !! 912 setup namespaces veth vti4 xfrm4 || return 2
1722 trace "${ns_a}" veth_a "${ns_b}" v 913 trace "${ns_a}" veth_a "${ns_b}" veth_b \
1723 "${ns_a}" vti4_a "${ns_b}" v 914 "${ns_a}" vti4_a "${ns_b}" vti4_b
1724 915
1725 veth_mtu=1500 916 veth_mtu=1500
1726 vti_mtu=$((veth_mtu - 20)) 917 vti_mtu=$((veth_mtu - 20))
1727 918
1728 # SPI 919 # SPI SN IV ICV pad length next header
1729 esp_payload_rfc4106=$((vti_mtu - 4 920 esp_payload_rfc4106=$((vti_mtu - 4 - 4 - 8 - 16 - 1 - 1))
1730 ping_payload=$((esp_payload_rfc4106 - 921 ping_payload=$((esp_payload_rfc4106 - 28))
1731 922
1732 mtu "${ns_a}" veth_a ${veth_mtu} 923 mtu "${ns_a}" veth_a ${veth_mtu}
1733 mtu "${ns_b}" veth_b ${veth_mtu} 924 mtu "${ns_b}" veth_b ${veth_mtu}
1734 mtu "${ns_a}" vti4_a ${vti_mtu} 925 mtu "${ns_a}" vti4_a ${vti_mtu}
1735 mtu "${ns_b}" vti4_b ${vti_mtu} 926 mtu "${ns_b}" vti4_b ${vti_mtu}
1736 927
1737 # Send DF packet without exceeding li 928 # Send DF packet without exceeding link layer MTU, check that no
1738 # exception is created 929 # exception is created
1739 run_cmd ${ns_a} ping -q -M want -i 0. 930 run_cmd ${ns_a} ping -q -M want -i 0.1 -w 1 -s ${ping_payload} ${tunnel4_b_addr}
1740 pmtu="$(route_get_dst_pmtu_from_excep 931 pmtu="$(route_get_dst_pmtu_from_exception "${ns_a}" ${tunnel4_b_addr})"
1741 check_pmtu_value "" "${pmtu}" "sendin 932 check_pmtu_value "" "${pmtu}" "sending packet smaller than PMTU (IP payload length ${esp_payload_rfc4106})" || return 1
1742 933
1743 # Now exceed link layer MTU by one by 934 # Now exceed link layer MTU by one byte, check that exception is created
1744 # with the right PMTU value 935 # with the right PMTU value
1745 run_cmd ${ns_a} ping -q -M want -i 0. 936 run_cmd ${ns_a} ping -q -M want -i 0.1 -w 1 -s $((ping_payload + 1)) ${tunnel4_b_addr}
1746 pmtu="$(route_get_dst_pmtu_from_excep 937 pmtu="$(route_get_dst_pmtu_from_exception "${ns_a}" ${tunnel4_b_addr})"
1747 check_pmtu_value "${esp_payload_rfc41 938 check_pmtu_value "${esp_payload_rfc4106}" "${pmtu}" "exceeding PMTU (IP payload length $((esp_payload_rfc4106 + 1)))"
1748 } 939 }
1749 940
1750 test_pmtu_vti6_exception() { 941 test_pmtu_vti6_exception() {
1751 setup namespaces veth vti6 xfrm6 || r !! 942 setup namespaces veth vti6 xfrm6 || return 2
1752 trace "${ns_a}" veth_a "${ns_b}" v <<
1753 "${ns_a}" vti6_a "${ns_b}" v <<
1754 fail=0 <<
1755 <<
1756 # Create route exception by exceeding <<
1757 mtu "${ns_a}" veth_a 4000 <<
1758 mtu "${ns_b}" veth_b 4000 <<
1759 mtu "${ns_a}" vti6_a 5000 <<
1760 mtu "${ns_b}" vti6_b 5000 <<
1761 run_cmd ${ns_a} ${ping6} -q -i 0.1 -w <<
1762 <<
1763 # Check that exception was created <<
1764 pmtu="$(route_get_dst_pmtu_from_excep <<
1765 check_pmtu_value any "${pmtu}" "creat <<
1766 <<
1767 # Decrease tunnel MTU, check for PMTU <<
1768 mtu "${ns_a}" vti6_a 3000 <<
1769 pmtu="$(route_get_dst_pmtu_from_excep <<
1770 check_pmtu_value "3000" "${pmtu}" "de <<
1771 <<
1772 # Increase tunnel MTU, check for PMTU <<
1773 mtu "${ns_a}" vti6_a 9000 <<
1774 pmtu="$(route_get_dst_pmtu_from_excep <<
1775 check_pmtu_value "9000" "${pmtu}" "in <<
1776 <<
1777 return ${fail} <<
1778 } <<
1779 <<
1780 test_pmtu_vti4_udp_exception() { <<
1781 setup namespaces veth vti4 xfrm4udp | <<
1782 trace "${ns_a}" veth_a "${ns_b}" v <<
1783 "${ns_a}" vti4_a "${ns_b}" v <<
1784 <<
1785 veth_mtu=1500 <<
1786 vti_mtu=$((veth_mtu - 20)) <<
1787 <<
1788 # UDP <<
1789 esp_payload_rfc4106=$((vti_mtu - 8 <<
1790 ping_payload=$((esp_payload_rfc4106 - <<
1791 <<
1792 mtu "${ns_a}" veth_a ${veth_mtu} <<
1793 mtu "${ns_b}" veth_b ${veth_mtu} <<
1794 mtu "${ns_a}" vti4_a ${vti_mtu} <<
1795 mtu "${ns_b}" vti4_b ${vti_mtu} <<
1796 <<
1797 # Send DF packet without exceeding li <<
1798 # exception is created <<
1799 run_cmd ${ns_a} ping -q -M want -i 0. <<
1800 pmtu="$(route_get_dst_pmtu_from_excep <<
1801 check_pmtu_value "" "${pmtu}" "sendin <<
1802 <<
1803 # Now exceed link layer MTU by one by <<
1804 # with the right PMTU value <<
1805 run_cmd ${ns_a} ping -q -M want -i 0. <<
1806 pmtu="$(route_get_dst_pmtu_from_excep <<
1807 check_pmtu_value "${esp_payload_rfc41 <<
1808 } <<
1809 <<
1810 test_pmtu_vti6_udp_exception() { <<
1811 setup namespaces veth vti6 xfrm6udp | <<
1812 trace "${ns_a}" veth_a "${ns_b}" v 943 trace "${ns_a}" veth_a "${ns_b}" veth_b \
1813 "${ns_a}" vti6_a "${ns_b}" v 944 "${ns_a}" vti6_a "${ns_b}" vti6_b
1814 fail=0 945 fail=0
1815 946
1816 # Create route exception by exceeding 947 # Create route exception by exceeding link layer MTU
1817 mtu "${ns_a}" veth_a 4000 948 mtu "${ns_a}" veth_a 4000
1818 mtu "${ns_b}" veth_b 4000 949 mtu "${ns_b}" veth_b 4000
1819 mtu "${ns_a}" vti6_a 5000 950 mtu "${ns_a}" vti6_a 5000
1820 mtu "${ns_b}" vti6_b 5000 951 mtu "${ns_b}" vti6_b 5000
1821 run_cmd ${ns_a} ${ping6} -q -i 0.1 -w 952 run_cmd ${ns_a} ${ping6} -q -i 0.1 -w 1 -s 60000 ${tunnel6_b_addr}
1822 953
1823 # Check that exception was created 954 # Check that exception was created
1824 pmtu="$(route_get_dst_pmtu_from_excep 955 pmtu="$(route_get_dst_pmtu_from_exception "${ns_a}" ${tunnel6_b_addr})"
1825 check_pmtu_value any "${pmtu}" "creat 956 check_pmtu_value any "${pmtu}" "creating tunnel exceeding link layer MTU" || return 1
1826 957
1827 # Decrease tunnel MTU, check for PMTU 958 # Decrease tunnel MTU, check for PMTU decrease in route exception
1828 mtu "${ns_a}" vti6_a 3000 959 mtu "${ns_a}" vti6_a 3000
1829 pmtu="$(route_get_dst_pmtu_from_excep 960 pmtu="$(route_get_dst_pmtu_from_exception "${ns_a}" ${tunnel6_b_addr})"
1830 check_pmtu_value "3000" "${pmtu}" "de 961 check_pmtu_value "3000" "${pmtu}" "decreasing tunnel MTU" || fail=1
1831 962
1832 # Increase tunnel MTU, check for PMTU 963 # Increase tunnel MTU, check for PMTU increase in route exception
1833 mtu "${ns_a}" vti6_a 9000 964 mtu "${ns_a}" vti6_a 9000
1834 pmtu="$(route_get_dst_pmtu_from_excep 965 pmtu="$(route_get_dst_pmtu_from_exception "${ns_a}" ${tunnel6_b_addr})"
1835 check_pmtu_value "9000" "${pmtu}" "in 966 check_pmtu_value "9000" "${pmtu}" "increasing tunnel MTU" || fail=1
1836 967
1837 return ${fail} 968 return ${fail}
1838 } 969 }
1839 970
1840 test_pmtu_vti4_udp_routed_exception() { <<
1841 setup namespaces routing vti4routed x <<
1842 trace "${ns_a}" veth_A-R1 "${ns_b} <<
1843 "${ns_a}" vti4_a "${ns_b} <<
1844 <<
1845 veth_mtu=1500 <<
1846 vti_mtu=$((veth_mtu - 20)) <<
1847 <<
1848 # UDP <<
1849 esp_payload_rfc4106=$((vti_mtu - 8 <<
1850 ping_payload=$((esp_payload_rfc4106 - <<
1851 <<
1852 mtu "${ns_a}" veth_A-R1 ${veth_mtu} <<
1853 mtu "${ns_r1}" veth_R1-A ${veth_mtu} <<
1854 mtu "${ns_b}" veth_B-R1 ${veth_mtu} <<
1855 mtu "${ns_r1}" veth_R1-B ${veth_mtu} <<
1856 <<
1857 mtu "${ns_a}" vti4_a ${vti_mtu} <<
1858 mtu "${ns_b}" vti4_b ${vti_mtu} <<
1859 <<
1860 # Send DF packet without exceeding li <<
1861 # exception is created <<
1862 run_cmd ${ns_a} ping -q -M want -i 0. <<
1863 pmtu="$(route_get_dst_pmtu_from_excep <<
1864 check_pmtu_value "" "${pmtu}" "sendin <<
1865 <<
1866 # Now decrease link layer MTU by 8 by <<
1867 # with the right PMTU value <<
1868 mtu "${ns_r1}" veth_R1-B $((veth_mtu <<
1869 run_cmd ${ns_a} ping -q -M want -i 0. <<
1870 pmtu="$(route_get_dst_pmtu_from_excep <<
1871 check_pmtu_value "$((esp_payload_rfc4 <<
1872 } <<
1873 <<
1874 test_pmtu_vti6_udp_routed_exception() { <<
1875 setup namespaces routing vti6routed x <<
1876 trace "${ns_a}" veth_A-R1 "${ns_b} <<
1877 "${ns_a}" vti6_a "${ns_b} <<
1878 <<
1879 veth_mtu=1500 <<
1880 vti_mtu=$((veth_mtu - 40)) <<
1881 <<
1882 # UDP <<
1883 esp_payload_rfc4106=$((vti_mtu - 8 <<
1884 ping_payload=$((esp_payload_rfc4106 - <<
1885 <<
1886 mtu "${ns_a}" veth_A-R1 ${veth_mtu} <<
1887 mtu "${ns_r1}" veth_R1-A ${veth_mtu} <<
1888 mtu "${ns_b}" veth_B-R1 ${veth_mtu} <<
1889 mtu "${ns_r1}" veth_R1-B ${veth_mtu} <<
1890 <<
1891 # mtu "${ns_a}" vti6_a ${vti_mtu} <<
1892 # mtu "${ns_b}" vti6_b ${vti_mtu} <<
1893 <<
1894 run_cmd ${ns_a} ${ping6} -q -M want - <<
1895 <<
1896 # Check that exception was not create <<
1897 pmtu="$(route_get_dst_pmtu_from_excep <<
1898 check_pmtu_value "" "${pmtu}" "sendin <<
1899 <<
1900 # Now decrease link layer MTU by 8 by <<
1901 # with the right PMTU value <<
1902 mtu "${ns_r1}" veth_R1-B $((veth_mtu <<
1903 run_cmd ${ns_a} ${ping6} -q -M want - <<
1904 pmtu="$(route_get_dst_pmtu_from_excep <<
1905 check_pmtu_value "$((esp_payload_rfc4 <<
1906 <<
1907 } <<
1908 <<
1909 test_pmtu_vti4_default_mtu() { 971 test_pmtu_vti4_default_mtu() {
1910 setup namespaces veth vti4 || return !! 972 setup namespaces veth vti4 || return 2
1911 973
1912 # Check that MTU of vti device is MTU 974 # Check that MTU of vti device is MTU of veth minus IPv4 header length
1913 veth_mtu="$(link_get_mtu "${ns_a}" ve 975 veth_mtu="$(link_get_mtu "${ns_a}" veth_a)"
1914 vti4_mtu="$(link_get_mtu "${ns_a}" vt 976 vti4_mtu="$(link_get_mtu "${ns_a}" vti4_a)"
1915 if [ $((veth_mtu - vti4_mtu)) -ne 20 977 if [ $((veth_mtu - vti4_mtu)) -ne 20 ]; then
1916 err " vti MTU ${vti4_mtu} is 978 err " vti MTU ${vti4_mtu} is not veth MTU ${veth_mtu} minus IPv4 header length"
1917 return 1 979 return 1
1918 fi 980 fi
1919 } 981 }
1920 982
1921 test_pmtu_vti6_default_mtu() { 983 test_pmtu_vti6_default_mtu() {
1922 setup namespaces veth vti6 || return !! 984 setup namespaces veth vti6 || return 2
1923 985
1924 # Check that MTU of vti device is MTU 986 # Check that MTU of vti device is MTU of veth minus IPv6 header length
1925 veth_mtu="$(link_get_mtu "${ns_a}" ve 987 veth_mtu="$(link_get_mtu "${ns_a}" veth_a)"
1926 vti6_mtu="$(link_get_mtu "${ns_a}" vt 988 vti6_mtu="$(link_get_mtu "${ns_a}" vti6_a)"
1927 if [ $((veth_mtu - vti6_mtu)) -ne 40 989 if [ $((veth_mtu - vti6_mtu)) -ne 40 ]; then
1928 err " vti MTU ${vti6_mtu} is 990 err " vti MTU ${vti6_mtu} is not veth MTU ${veth_mtu} minus IPv6 header length"
1929 return 1 991 return 1
1930 fi 992 fi
1931 } 993 }
1932 994
1933 test_pmtu_vti4_link_add_mtu() { 995 test_pmtu_vti4_link_add_mtu() {
1934 setup namespaces || return $ksft_skip !! 996 setup namespaces || return 2
1935 997
1936 run_cmd ${ns_a} ip link add vti4_a ty 998 run_cmd ${ns_a} ip link add vti4_a type vti local ${veth4_a_addr} remote ${veth4_b_addr} key 10
1937 [ $? -ne 0 ] && err " vti not suppor !! 999 [ $? -ne 0 ] && err " vti not supported" && return 2
1938 run_cmd ${ns_a} ip link del vti4_a 1000 run_cmd ${ns_a} ip link del vti4_a
1939 1001
1940 fail=0 1002 fail=0
1941 1003
1942 min=68 1004 min=68
1943 max=$((65535 - 20)) 1005 max=$((65535 - 20))
1944 # Check invalid values first 1006 # Check invalid values first
1945 for v in $((min - 1)) $((max + 1)); d 1007 for v in $((min - 1)) $((max + 1)); do
1946 run_cmd ${ns_a} ip link add v 1008 run_cmd ${ns_a} ip link add vti4_a mtu ${v} type vti local ${veth4_a_addr} remote ${veth4_b_addr} key 10
1947 # This can fail, or MTU can b 1009 # This can fail, or MTU can be adjusted to a proper value
1948 [ $? -ne 0 ] && continue 1010 [ $? -ne 0 ] && continue
1949 mtu="$(link_get_mtu "${ns_a}" 1011 mtu="$(link_get_mtu "${ns_a}" vti4_a)"
1950 if [ ${mtu} -lt ${min} -o ${m 1012 if [ ${mtu} -lt ${min} -o ${mtu} -gt ${max} ]; then
1951 err " vti tunnel cre 1013 err " vti tunnel created with invalid MTU ${mtu}"
1952 fail=1 1014 fail=1
1953 fi 1015 fi
1954 run_cmd ${ns_a} ip link del v 1016 run_cmd ${ns_a} ip link del vti4_a
1955 done 1017 done
1956 1018
1957 # Now check valid values 1019 # Now check valid values
1958 for v in ${min} 1300 ${max}; do 1020 for v in ${min} 1300 ${max}; do
1959 run_cmd ${ns_a} ip link add v 1021 run_cmd ${ns_a} ip link add vti4_a mtu ${v} type vti local ${veth4_a_addr} remote ${veth4_b_addr} key 10
1960 mtu="$(link_get_mtu "${ns_a}" 1022 mtu="$(link_get_mtu "${ns_a}" vti4_a)"
1961 run_cmd ${ns_a} ip link del v 1023 run_cmd ${ns_a} ip link del vti4_a
1962 if [ "${mtu}" != "${v}" ]; th 1024 if [ "${mtu}" != "${v}" ]; then
1963 err " vti MTU ${mtu} 1025 err " vti MTU ${mtu} doesn't match configured value ${v}"
1964 fail=1 1026 fail=1
1965 fi 1027 fi
1966 done 1028 done
1967 1029
1968 return ${fail} 1030 return ${fail}
1969 } 1031 }
1970 1032
1971 test_pmtu_vti6_link_add_mtu() { 1033 test_pmtu_vti6_link_add_mtu() {
1972 setup namespaces || return $ksft_skip !! 1034 setup namespaces || return 2
1973 1035
1974 run_cmd ${ns_a} ip link add vti6_a ty 1036 run_cmd ${ns_a} ip link add vti6_a type vti6 local ${veth6_a_addr} remote ${veth6_b_addr} key 10
1975 [ $? -ne 0 ] && err " vti6 not suppo !! 1037 [ $? -ne 0 ] && err " vti6 not supported" && return 2
1976 run_cmd ${ns_a} ip link del vti6_a 1038 run_cmd ${ns_a} ip link del vti6_a
1977 1039
1978 fail=0 1040 fail=0
1979 1041
1980 min=68 # vti6 can ca 1042 min=68 # vti6 can carry IPv4 packets too
1981 max=$((65535 - 40)) 1043 max=$((65535 - 40))
1982 # Check invalid values first 1044 # Check invalid values first
1983 for v in $((min - 1)) $((max + 1)); d 1045 for v in $((min - 1)) $((max + 1)); do
1984 run_cmd ${ns_a} ip link add v 1046 run_cmd ${ns_a} ip link add vti6_a mtu ${v} type vti6 local ${veth6_a_addr} remote ${veth6_b_addr} key 10
1985 # This can fail, or MTU can b 1047 # This can fail, or MTU can be adjusted to a proper value
1986 [ $? -ne 0 ] && continue 1048 [ $? -ne 0 ] && continue
1987 mtu="$(link_get_mtu "${ns_a}" 1049 mtu="$(link_get_mtu "${ns_a}" vti6_a)"
1988 if [ ${mtu} -lt ${min} -o ${m 1050 if [ ${mtu} -lt ${min} -o ${mtu} -gt ${max} ]; then
1989 err " vti6 tunnel cr 1051 err " vti6 tunnel created with invalid MTU ${v}"
1990 fail=1 1052 fail=1
1991 fi 1053 fi
1992 run_cmd ${ns_a} ip link del v 1054 run_cmd ${ns_a} ip link del vti6_a
1993 done 1055 done
1994 1056
1995 # Now check valid values 1057 # Now check valid values
1996 for v in 68 1280 1300 $((65535 - 40)) 1058 for v in 68 1280 1300 $((65535 - 40)); do
1997 run_cmd ${ns_a} ip link add v 1059 run_cmd ${ns_a} ip link add vti6_a mtu ${v} type vti6 local ${veth6_a_addr} remote ${veth6_b_addr} key 10
1998 mtu="$(link_get_mtu "${ns_a}" 1060 mtu="$(link_get_mtu "${ns_a}" vti6_a)"
1999 run_cmd ${ns_a} ip link del v 1061 run_cmd ${ns_a} ip link del vti6_a
2000 if [ "${mtu}" != "${v}" ]; th 1062 if [ "${mtu}" != "${v}" ]; then
2001 err " vti6 MTU ${mtu 1063 err " vti6 MTU ${mtu} doesn't match configured value ${v}"
2002 fail=1 1064 fail=1
2003 fi 1065 fi
2004 done 1066 done
2005 1067
2006 return ${fail} 1068 return ${fail}
2007 } 1069 }
2008 1070
2009 test_pmtu_vti6_link_change_mtu() { 1071 test_pmtu_vti6_link_change_mtu() {
2010 setup namespaces || return $ksft_skip !! 1072 setup namespaces || return 2
2011 1073
2012 run_cmd ${ns_a} ip link add dummy0 mt 1074 run_cmd ${ns_a} ip link add dummy0 mtu 1500 type dummy
2013 [ $? -ne 0 ] && err " dummy not supp !! 1075 [ $? -ne 0 ] && err " dummy not supported" && return 2
2014 run_cmd ${ns_a} ip link add dummy1 mt 1076 run_cmd ${ns_a} ip link add dummy1 mtu 3000 type dummy
2015 run_cmd ${ns_a} ip link set dummy0 up 1077 run_cmd ${ns_a} ip link set dummy0 up
2016 run_cmd ${ns_a} ip link set dummy1 up 1078 run_cmd ${ns_a} ip link set dummy1 up
2017 1079
2018 run_cmd ${ns_a} ip addr add ${dummy6_ 1080 run_cmd ${ns_a} ip addr add ${dummy6_0_prefix}1/${dummy6_mask} dev dummy0
2019 run_cmd ${ns_a} ip addr add ${dummy6_ 1081 run_cmd ${ns_a} ip addr add ${dummy6_1_prefix}1/${dummy6_mask} dev dummy1
2020 1082
2021 fail=0 1083 fail=0
2022 1084
2023 # Create vti6 interface bound to devi 1085 # Create vti6 interface bound to device, passing MTU, check it
2024 run_cmd ${ns_a} ip link add vti6_a mt 1086 run_cmd ${ns_a} ip link add vti6_a mtu 1300 type vti6 remote ${dummy6_0_prefix}2 local ${dummy6_0_prefix}1
2025 mtu="$(link_get_mtu "${ns_a}" vti6_a) 1087 mtu="$(link_get_mtu "${ns_a}" vti6_a)"
2026 if [ ${mtu} -ne 1300 ]; then 1088 if [ ${mtu} -ne 1300 ]; then
2027 err " vti6 MTU ${mtu} doesn' 1089 err " vti6 MTU ${mtu} doesn't match configured value 1300"
2028 fail=1 1090 fail=1
2029 fi 1091 fi
2030 1092
2031 # Move to another device with differe 1093 # Move to another device with different MTU, without passing MTU, check
2032 # MTU is adjusted 1094 # MTU is adjusted
2033 run_cmd ${ns_a} ip link set vti6_a ty 1095 run_cmd ${ns_a} ip link set vti6_a type vti6 remote ${dummy6_1_prefix}2 local ${dummy6_1_prefix}1
2034 mtu="$(link_get_mtu "${ns_a}" vti6_a) 1096 mtu="$(link_get_mtu "${ns_a}" vti6_a)"
2035 if [ ${mtu} -ne $((3000 - 40)) ]; the 1097 if [ ${mtu} -ne $((3000 - 40)) ]; then
2036 err " vti MTU ${mtu} is not 1098 err " vti MTU ${mtu} is not dummy MTU 3000 minus IPv6 header length"
2037 fail=1 1099 fail=1
2038 fi 1100 fi
2039 1101
2040 # Move it back, passing MTU, check MT 1102 # Move it back, passing MTU, check MTU is not overridden
2041 run_cmd ${ns_a} ip link set vti6_a mt 1103 run_cmd ${ns_a} ip link set vti6_a mtu 1280 type vti6 remote ${dummy6_0_prefix}2 local ${dummy6_0_prefix}1
2042 mtu="$(link_get_mtu "${ns_a}" vti6_a) 1104 mtu="$(link_get_mtu "${ns_a}" vti6_a)"
2043 if [ ${mtu} -ne 1280 ]; then 1105 if [ ${mtu} -ne 1280 ]; then
2044 err " vti6 MTU ${mtu} doesn' 1106 err " vti6 MTU ${mtu} doesn't match configured value 1280"
2045 fail=1 1107 fail=1
2046 fi 1108 fi
2047 1109
2048 return ${fail} 1110 return ${fail}
2049 } 1111 }
2050 1112
2051 check_command() { 1113 check_command() {
2052 cmd=${1} 1114 cmd=${1}
2053 1115
2054 if ! which ${cmd} > /dev/null 2>&1; t 1116 if ! which ${cmd} > /dev/null 2>&1; then
2055 err " missing required comma 1117 err " missing required command: '${cmd}'"
2056 return 1 1118 return 1
2057 fi 1119 fi
2058 return 0 1120 return 0
2059 } 1121 }
2060 1122
2061 check_running() { <<
2062 pid=${1} <<
2063 cmd=${2} <<
2064 <<
2065 [ "$(cat /proc/${pid}/cmdline 2>/dev/ <<
2066 } <<
2067 <<
2068 test_cleanup_vxlanX_exception() { 1123 test_cleanup_vxlanX_exception() {
2069 outer="${1}" 1124 outer="${1}"
2070 encap="vxlan" 1125 encap="vxlan"
2071 ll_mtu=4000 1126 ll_mtu=4000
2072 1127
2073 check_command taskset || return $ksft !! 1128 check_command taskset || return 2
2074 cpu_list=$(grep -m 2 processor /proc/ 1129 cpu_list=$(grep -m 2 processor /proc/cpuinfo | cut -d ' ' -f 2)
2075 1130
2076 setup namespaces routing ${encap}${ou !! 1131 setup namespaces routing ${encap}${outer} || return 2
2077 trace "${ns_a}" ${encap}_a "${ns_b} 1132 trace "${ns_a}" ${encap}_a "${ns_b}" ${encap}_b \
2078 "${ns_a}" veth_A-R1 "${ns_r1 1133 "${ns_a}" veth_A-R1 "${ns_r1}" veth_R1-A \
2079 "${ns_b}" veth_B-R1 "${ns_r1 1134 "${ns_b}" veth_B-R1 "${ns_r1}" veth_R1-B
2080 1135
2081 # Create route exception by exceeding 1136 # Create route exception by exceeding link layer MTU
2082 mtu "${ns_a}" veth_A-R1 $((${ll_mtu} 1137 mtu "${ns_a}" veth_A-R1 $((${ll_mtu} + 1000))
2083 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} 1138 mtu "${ns_r1}" veth_R1-A $((${ll_mtu} + 1000))
2084 mtu "${ns_b}" veth_B-R1 ${ll_mtu} 1139 mtu "${ns_b}" veth_B-R1 ${ll_mtu}
2085 mtu "${ns_r1}" veth_R1-B ${ll_mtu} 1140 mtu "${ns_r1}" veth_R1-B ${ll_mtu}
2086 1141
2087 mtu "${ns_a}" ${encap}_a $((${ll_mtu} 1142 mtu "${ns_a}" ${encap}_a $((${ll_mtu} + 1000))
2088 mtu "${ns_b}" ${encap}_b $((${ll_mtu} 1143 mtu "${ns_b}" ${encap}_b $((${ll_mtu} + 1000))
2089 1144
2090 # Fill exception cache for multiple C 1145 # Fill exception cache for multiple CPUs (2)
2091 # we can always use inner IPv4 for th 1146 # we can always use inner IPv4 for that
2092 for cpu in ${cpu_list}; do 1147 for cpu in ${cpu_list}; do
2093 run_cmd taskset --cpu-list ${ 1148 run_cmd taskset --cpu-list ${cpu} ${ns_a} ping -q -M want -i 0.1 -w 1 -s $((${ll_mtu} + 500)) ${tunnel4_b_addr}
2094 done 1149 done
2095 1150
2096 ${ns_a} ip link del dev veth_A-R1 & 1151 ${ns_a} ip link del dev veth_A-R1 &
2097 iplink_pid=$! 1152 iplink_pid=$!
2098 for i in $(seq 1 20); do !! 1153 sleep 1
2099 check_running ${iplink_pid} " !! 1154 if [ "$(cat /proc/${iplink_pid}/cmdline 2>/dev/null | tr -d '\0')" = "iplinkdeldevveth_A-R1" ]; then
2100 sleep 0.1 !! 1155 err " can't delete veth device in a timely manner, PMTU dst likely leaked"
2101 done !! 1156 return 1
2102 err " can't delete veth device in a !! 1157 fi
2103 return 1 <<
2104 } 1158 }
2105 1159
2106 test_cleanup_ipv6_exception() { 1160 test_cleanup_ipv6_exception() {
2107 test_cleanup_vxlanX_exception 6 1161 test_cleanup_vxlanX_exception 6
2108 } 1162 }
2109 1163
2110 test_cleanup_ipv4_exception() { 1164 test_cleanup_ipv4_exception() {
2111 test_cleanup_vxlanX_exception 4 1165 test_cleanup_vxlanX_exception 4
2112 } 1166 }
2113 1167
2114 run_test() { 1168 run_test() {
2115 ( 1169 (
2116 tname="$1" 1170 tname="$1"
2117 tdesc="$2" 1171 tdesc="$2"
2118 1172
2119 unset IFS 1173 unset IFS
2120 1174
2121 # Since cleanup() relies on variables <<
2122 # has to run in this context. <<
2123 trap cleanup EXIT <<
2124 <<
2125 if [ "$VERBOSE" = "1" ]; then 1175 if [ "$VERBOSE" = "1" ]; then
2126 printf "\n################### 1176 printf "\n##########################################################################\n\n"
2127 fi 1177 fi
2128 1178
2129 eval test_${tname} 1179 eval test_${tname}
2130 ret=$? 1180 ret=$?
2131 1181
2132 if [ $ret -eq 0 ]; then 1182 if [ $ret -eq 0 ]; then
2133 printf "TEST: %-60s [ OK ]\n 1183 printf "TEST: %-60s [ OK ]\n" "${tdesc}"
2134 elif [ $ret -eq 1 ]; then 1184 elif [ $ret -eq 1 ]; then
2135 printf "TEST: %-60s [FAIL]\n 1185 printf "TEST: %-60s [FAIL]\n" "${tdesc}"
2136 if [ "${PAUSE_ON_FAIL}" = "ye 1186 if [ "${PAUSE_ON_FAIL}" = "yes" ]; then
2137 echo 1187 echo
2138 echo "Pausing. Hit en 1188 echo "Pausing. Hit enter to continue"
2139 read a 1189 read a
2140 fi 1190 fi
2141 err_flush 1191 err_flush
2142 exit 1 1192 exit 1
2143 elif [ $ret -eq $ksft_skip ]; then !! 1193 elif [ $ret -eq 2 ]; then
2144 printf "TEST: %-60s [SKIP]\n 1194 printf "TEST: %-60s [SKIP]\n" "${tdesc}"
2145 err_flush 1195 err_flush
2146 fi 1196 fi
2147 1197
2148 return $ret 1198 return $ret
2149 ) 1199 )
2150 ret=$? 1200 ret=$?
2151 case $ret in !! 1201 [ $ret -ne 0 ] && exitcode=1
2152 0) <<
2153 all_skipped=false <<
2154 [ $exitcode -eq $ksft <<
2155 ;; <<
2156 $ksft_skip) <<
2157 [ $all_skipped = true <<
2158 ;; <<
2159 *) <<
2160 all_skipped=false <<
2161 exitcode=1 <<
2162 ;; <<
2163 esac <<
2164 1202
2165 return $ret 1203 return $ret
2166 } 1204 }
2167 1205
2168 run_test_nh() { 1206 run_test_nh() {
2169 tname="$1" 1207 tname="$1"
2170 tdesc="$2" 1208 tdesc="$2"
2171 1209
2172 USE_NH=yes 1210 USE_NH=yes
2173 run_test "${tname}" "${tdesc} - nexth 1211 run_test "${tname}" "${tdesc} - nexthop objects"
2174 USE_NH=no 1212 USE_NH=no
2175 } 1213 }
2176 1214
2177 test_list_flush_ipv4_exception() { 1215 test_list_flush_ipv4_exception() {
2178 setup namespaces routing || return $k !! 1216 setup namespaces routing || return 2
2179 trace "${ns_a}" veth_A-R1 "${ns_r 1217 trace "${ns_a}" veth_A-R1 "${ns_r1}" veth_R1-A \
2180 "${ns_r1}" veth_R1-B "${ns_b 1218 "${ns_r1}" veth_R1-B "${ns_b}" veth_B-R1 \
2181 "${ns_a}" veth_A-R2 "${ns_r 1219 "${ns_a}" veth_A-R2 "${ns_r2}" veth_R2-A \
2182 "${ns_r2}" veth_R2-B "${ns_b 1220 "${ns_r2}" veth_R2-B "${ns_b}" veth_B-R2
2183 1221
2184 dst_prefix1="${prefix4}.${b_r1}." 1222 dst_prefix1="${prefix4}.${b_r1}."
2185 dst2="${prefix4}.${b_r2}.1" 1223 dst2="${prefix4}.${b_r2}.1"
2186 1224
2187 # Set up initial MTU values 1225 # Set up initial MTU values
2188 mtu "${ns_a}" veth_A-R1 2000 1226 mtu "${ns_a}" veth_A-R1 2000
2189 mtu "${ns_r1}" veth_R1-A 2000 1227 mtu "${ns_r1}" veth_R1-A 2000
2190 mtu "${ns_r1}" veth_R1-B 1500 1228 mtu "${ns_r1}" veth_R1-B 1500
2191 mtu "${ns_b}" veth_B-R1 1500 1229 mtu "${ns_b}" veth_B-R1 1500
2192 1230
2193 mtu "${ns_a}" veth_A-R2 2000 1231 mtu "${ns_a}" veth_A-R2 2000
2194 mtu "${ns_r2}" veth_R2-A 2000 1232 mtu "${ns_r2}" veth_R2-A 2000
2195 mtu "${ns_r2}" veth_R2-B 1500 1233 mtu "${ns_r2}" veth_R2-B 1500
2196 mtu "${ns_b}" veth_B-R2 1500 1234 mtu "${ns_b}" veth_B-R2 1500
2197 1235
2198 fail=0 1236 fail=0
2199 1237
2200 # Add 100 addresses for veth endpoint 1238 # Add 100 addresses for veth endpoint on B reached by default A route
2201 for i in $(seq 100 199); do 1239 for i in $(seq 100 199); do
2202 run_cmd ${ns_b} ip addr add " 1240 run_cmd ${ns_b} ip addr add "${dst_prefix1}${i}" dev veth_B-R1
2203 done 1241 done
2204 1242
2205 # Create 100 cached route exceptions 1243 # Create 100 cached route exceptions for path via R1, one via R2. Note
2206 # that with IPv4 we need to actually 1244 # that with IPv4 we need to actually cause a route lookup that matches
2207 # the exception caused by ICMP, in or 1245 # the exception caused by ICMP, in order to actually have a cached
2208 # route, so we need to ping each dest 1246 # route, so we need to ping each destination twice
2209 for i in $(seq 100 199); do 1247 for i in $(seq 100 199); do
2210 run_cmd ${ns_a} ping -q -M wa 1248 run_cmd ${ns_a} ping -q -M want -i 0.1 -c 2 -s 1800 "${dst_prefix1}${i}"
2211 done 1249 done
2212 run_cmd ${ns_a} ping -q -M want -i 0. 1250 run_cmd ${ns_a} ping -q -M want -i 0.1 -c 2 -s 1800 "${dst2}"
2213 1251
2214 if [ "$(${ns_a} ip -oneline route lis 1252 if [ "$(${ns_a} ip -oneline route list cache | wc -l)" -ne 101 ]; then
2215 err " can't list cached exce 1253 err " can't list cached exceptions"
2216 fail=1 1254 fail=1
2217 fi 1255 fi
2218 1256
2219 run_cmd ${ns_a} ip route flush cache 1257 run_cmd ${ns_a} ip route flush cache
2220 pmtu1="$(route_get_dst_pmtu_from_exce 1258 pmtu1="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst_prefix}1)"
2221 pmtu2="$(route_get_dst_pmtu_from_exce 1259 pmtu2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst_prefix}2)"
2222 if [ -n "${pmtu1}" ] || [ -n "${pmtu2 1260 if [ -n "${pmtu1}" ] || [ -n "${pmtu2}" ] || \
2223 [ -n "$(${ns_a} ip route list cach 1261 [ -n "$(${ns_a} ip route list cache)" ]; then
2224 err " can't flush cached exc 1262 err " can't flush cached exceptions"
2225 fail=1 1263 fail=1
2226 fi 1264 fi
2227 1265
2228 return ${fail} 1266 return ${fail}
2229 } 1267 }
2230 1268
2231 test_list_flush_ipv6_exception() { 1269 test_list_flush_ipv6_exception() {
2232 setup namespaces routing || return $k !! 1270 setup namespaces routing || return 2
2233 trace "${ns_a}" veth_A-R1 "${ns_r 1271 trace "${ns_a}" veth_A-R1 "${ns_r1}" veth_R1-A \
2234 "${ns_r1}" veth_R1-B "${ns_b 1272 "${ns_r1}" veth_R1-B "${ns_b}" veth_B-R1 \
2235 "${ns_a}" veth_A-R2 "${ns_r 1273 "${ns_a}" veth_A-R2 "${ns_r2}" veth_R2-A \
2236 "${ns_r2}" veth_R2-B "${ns_b 1274 "${ns_r2}" veth_R2-B "${ns_b}" veth_B-R2
2237 1275
2238 dst_prefix1="${prefix6}:${b_r1}::" 1276 dst_prefix1="${prefix6}:${b_r1}::"
2239 dst2="${prefix6}:${b_r2}::1" 1277 dst2="${prefix6}:${b_r2}::1"
2240 1278
2241 # Set up initial MTU values 1279 # Set up initial MTU values
2242 mtu "${ns_a}" veth_A-R1 2000 1280 mtu "${ns_a}" veth_A-R1 2000
2243 mtu "${ns_r1}" veth_R1-A 2000 1281 mtu "${ns_r1}" veth_R1-A 2000
2244 mtu "${ns_r1}" veth_R1-B 1500 1282 mtu "${ns_r1}" veth_R1-B 1500
2245 mtu "${ns_b}" veth_B-R1 1500 1283 mtu "${ns_b}" veth_B-R1 1500
2246 1284
2247 mtu "${ns_a}" veth_A-R2 2000 1285 mtu "${ns_a}" veth_A-R2 2000
2248 mtu "${ns_r2}" veth_R2-A 2000 1286 mtu "${ns_r2}" veth_R2-A 2000
2249 mtu "${ns_r2}" veth_R2-B 1500 1287 mtu "${ns_r2}" veth_R2-B 1500
2250 mtu "${ns_b}" veth_B-R2 1500 1288 mtu "${ns_b}" veth_B-R2 1500
2251 1289
2252 fail=0 1290 fail=0
2253 1291
2254 # Add 100 addresses for veth endpoint 1292 # Add 100 addresses for veth endpoint on B reached by default A route
2255 for i in $(seq 100 199); do 1293 for i in $(seq 100 199); do
2256 run_cmd ${ns_b} ip addr add " 1294 run_cmd ${ns_b} ip addr add "${dst_prefix1}${i}" dev veth_B-R1
2257 done 1295 done
2258 1296
2259 # Create 100 cached route exceptions 1297 # Create 100 cached route exceptions for path via R1, one via R2
2260 for i in $(seq 100 199); do 1298 for i in $(seq 100 199); do
2261 run_cmd ${ns_a} ping -q -M wa 1299 run_cmd ${ns_a} ping -q -M want -i 0.1 -w 1 -s 1800 "${dst_prefix1}${i}"
2262 done 1300 done
2263 run_cmd ${ns_a} ping -q -M want -i 0. 1301 run_cmd ${ns_a} ping -q -M want -i 0.1 -w 1 -s 1800 "${dst2}"
2264 if [ "$(${ns_a} ip -oneline -6 route 1302 if [ "$(${ns_a} ip -oneline -6 route list cache | wc -l)" -ne 101 ]; then
2265 err " can't list cached exce 1303 err " can't list cached exceptions"
2266 fail=1 1304 fail=1
2267 fi 1305 fi
2268 1306
2269 run_cmd ${ns_a} ip -6 route flush cac 1307 run_cmd ${ns_a} ip -6 route flush cache
2270 pmtu1="$(route_get_dst_pmtu_from_exce 1308 pmtu1="$(route_get_dst_pmtu_from_exception "${ns_a}" "${dst_prefix1}100")"
2271 pmtu2="$(route_get_dst_pmtu_from_exce 1309 pmtu2="$(route_get_dst_pmtu_from_exception "${ns_a}" ${dst2})"
2272 if [ -n "${pmtu1}" ] || [ -n "${pmtu2 1310 if [ -n "${pmtu1}" ] || [ -n "${pmtu2}" ] || \
2273 [ -n "$(${ns_a} ip -6 route list c 1311 [ -n "$(${ns_a} ip -6 route list cache)" ]; then
2274 err " can't flush cached exc 1312 err " can't flush cached exceptions"
2275 fail=1 1313 fail=1
2276 fi 1314 fi
2277 1315
2278 return ${fail} 1316 return ${fail}
2279 } 1317 }
2280 1318
2281 test_pmtu_ipvX_route_change() { <<
2282 family=${1} <<
2283 <<
2284 setup namespaces routing || return 2 <<
2285 trace "${ns_a}" veth_A-R1 "${ns_r <<
2286 "${ns_r1}" veth_R1-B "${ns_b <<
2287 "${ns_a}" veth_A-R2 "${ns_r <<
2288 "${ns_r2}" veth_R2-B "${ns_b <<
2289 <<
2290 if [ ${family} -eq 4 ]; then <<
2291 ping=ping <<
2292 dst1="${prefix4}.${b_r1}.1" <<
2293 dst2="${prefix4}.${b_r2}.1" <<
2294 gw="${prefix4}.${a_r1}.2" <<
2295 else <<
2296 ping=${ping6} <<
2297 dst1="${prefix6}:${b_r1}::1" <<
2298 dst2="${prefix6}:${b_r2}::1" <<
2299 gw="${prefix6}:${a_r1}::2" <<
2300 fi <<
2301 <<
2302 # Set up initial MTU values <<
2303 mtu "${ns_a}" veth_A-R1 2000 <<
2304 mtu "${ns_r1}" veth_R1-A 2000 <<
2305 mtu "${ns_r1}" veth_R1-B 1400 <<
2306 mtu "${ns_b}" veth_B-R1 1400 <<
2307 <<
2308 mtu "${ns_a}" veth_A-R2 2000 <<
2309 mtu "${ns_r2}" veth_R2-A 2000 <<
2310 mtu "${ns_r2}" veth_R2-B 1500 <<
2311 mtu "${ns_b}" veth_B-R2 1500 <<
2312 <<
2313 # Create route exceptions <<
2314 run_cmd ${ns_a} ${ping} -q -M want -i <<
2315 run_cmd ${ns_a} ${ping} -q -M want -i <<
2316 <<
2317 # Check that exceptions have been cre <<
2318 pmtu_1="$(route_get_dst_pmtu_from_exc <<
2319 check_pmtu_value "1400" "${pmtu_1}" " <<
2320 pmtu_2="$(route_get_dst_pmtu_from_exc <<
2321 check_pmtu_value "1500" "${pmtu_2}" " <<
2322 <<
2323 # Replace the route from A to R1 <<
2324 run_cmd ${ns_a} ip route change defau <<
2325 <<
2326 # Delete the device in A <<
2327 run_cmd ${ns_a} ip link del "veth_A-R <<
2328 } <<
2329 <<
2330 test_pmtu_ipv4_route_change() { <<
2331 test_pmtu_ipvX_route_change 4 <<
2332 } <<
2333 <<
2334 test_pmtu_ipv6_route_change() { <<
2335 test_pmtu_ipvX_route_change 6 <<
2336 } <<
2337 <<
2338 usage() { 1319 usage() {
2339 echo 1320 echo
2340 echo "$0 [OPTIONS] [TEST]..." 1321 echo "$0 [OPTIONS] [TEST]..."
2341 echo "If no TEST argument is given, a 1322 echo "If no TEST argument is given, all tests will be run."
2342 echo 1323 echo
2343 echo "Options" 1324 echo "Options"
2344 echo " --trace: capture traffic to T 1325 echo " --trace: capture traffic to TEST_INTERFACE.pcap"
2345 echo 1326 echo
2346 echo "Available tests${tests}" 1327 echo "Available tests${tests}"
2347 exit 1 1328 exit 1
2348 } 1329 }
2349 1330
2350 ############################################# 1331 ################################################################################
2351 # 1332 #
2352 exitcode=0 1333 exitcode=0
2353 desc=0 1334 desc=0
2354 all_skipped=true <<
2355 1335
2356 while getopts :ptv o 1336 while getopts :ptv o
2357 do 1337 do
2358 case $o in 1338 case $o in
2359 p) PAUSE_ON_FAIL=yes;; 1339 p) PAUSE_ON_FAIL=yes;;
2360 v) VERBOSE=1;; 1340 v) VERBOSE=1;;
2361 t) if which tcpdump > /dev/null 2>&1; 1341 t) if which tcpdump > /dev/null 2>&1; then
2362 TRACING=1 1342 TRACING=1
2363 else 1343 else
2364 echo "=== tcpdump not availab 1344 echo "=== tcpdump not available, tracing disabled"
2365 fi 1345 fi
2366 ;; 1346 ;;
2367 *) usage;; 1347 *) usage;;
2368 esac 1348 esac
2369 done 1349 done
2370 shift $(($OPTIND-1)) 1350 shift $(($OPTIND-1))
2371 1351
2372 IFS=" 1352 IFS="
2373 " 1353 "
2374 1354
2375 for arg do 1355 for arg do
2376 # Check first that all requested test 1356 # Check first that all requested tests are available before running any
2377 command -v > /dev/null "test_${arg}" 1357 command -v > /dev/null "test_${arg}" || { echo "=== Test ${arg} not found"; usage; }
2378 done 1358 done
2379 1359
2380 trap cleanup EXIT 1360 trap cleanup EXIT
2381 1361
2382 # start clean 1362 # start clean
2383 cleanup 1363 cleanup
2384 1364
2385 HAVE_NH=no 1365 HAVE_NH=no
2386 ip nexthop ls >/dev/null 2>&1 1366 ip nexthop ls >/dev/null 2>&1
2387 [ $? -eq 0 ] && HAVE_NH=yes 1367 [ $? -eq 0 ] && HAVE_NH=yes
2388 1368
2389 name="" 1369 name=""
2390 desc="" 1370 desc=""
2391 rerun_nh=0 1371 rerun_nh=0
2392 for t in ${tests}; do 1372 for t in ${tests}; do
2393 [ "${name}" = "" ] && name="${t} 1373 [ "${name}" = "" ] && name="${t}" && continue
2394 [ "${desc}" = "" ] && desc="${t} 1374 [ "${desc}" = "" ] && desc="${t}" && continue
2395 1375
2396 if [ "${HAVE_NH}" = "yes" ]; then 1376 if [ "${HAVE_NH}" = "yes" ]; then
2397 rerun_nh="${t}" 1377 rerun_nh="${t}"
2398 fi 1378 fi
2399 1379
2400 run_this=1 1380 run_this=1
2401 for arg do 1381 for arg do
2402 [ "${arg}" != "${arg#--*}" ] 1382 [ "${arg}" != "${arg#--*}" ] && continue
2403 [ "${arg}" = "${name}" ] && r 1383 [ "${arg}" = "${name}" ] && run_this=1 && break
2404 run_this=0 1384 run_this=0
2405 done 1385 done
2406 if [ $run_this -eq 1 ]; then 1386 if [ $run_this -eq 1 ]; then
2407 run_test "${name}" "${desc}" 1387 run_test "${name}" "${desc}"
2408 # if test was skipped no need 1388 # if test was skipped no need to retry with nexthop objects
2409 [ $? -eq $ksft_skip ] && reru !! 1389 [ $? -eq 2 ] && rerun_nh=0
2410 1390
2411 if [ "${rerun_nh}" = "1" ]; t 1391 if [ "${rerun_nh}" = "1" ]; then
2412 run_test_nh "${name}" 1392 run_test_nh "${name}" "${desc}"
2413 fi 1393 fi
2414 fi 1394 fi
2415 name="" 1395 name=""
2416 desc="" 1396 desc=""
2417 rerun_nh=0 1397 rerun_nh=0
2418 done 1398 done
2419 1399
2420 exit ${exitcode} 1400 exit ${exitcode}
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.