1#!/bin/bash
2# SPDX-License-Identifier: GPL-2.0
3
4# This test sends one stream of traffic from H1 through a TBF shaper, to a RED
5# within TBF shaper on $swp3. The two shapers have the same configuration, and
6# thus the resulting stream should fill all available bandwidth on the latter
7# shaper. A second stream is sent from H2 also via $swp3, and used to inject
8# additional traffic. Since all available bandwidth is taken, this traffic has
9# to go to backlog.
10#
11# +--------------------------+                     +--------------------------+
12# | H1                       |                     | H2                       |
13# |     + $h1                |                     |     + $h2                |
14# |     | 192.0.2.1/28       |                     |     | 192.0.2.2/28       |
15# |     | TBF 10Mbps         |                     |     |                    |
16# +-----|--------------------+                     +-----|--------------------+
17#       |                                                |
18# +-----|------------------------------------------------|--------------------+
19# | SW  |                                                |                    |
20# |  +--|------------------------------------------------|----------------+   |
21# |  |  + $swp1                                          + $swp2          |   |
22# |  |                               BR                                   |   |
23# |  |                                                                    |   |
24# |  |                                + $swp3                             |   |
25# |  |                                | TBF 10Mbps / RED                  |   |
26# |  +--------------------------------|-----------------------------------+   |
27# |                                   |                                       |
28# +-----------------------------------|---------------------------------------+
29#                                     |
30#                               +-----|--------------------+
31#			        | H3  |                    |
32#			        |     + $h1                |
33#			        |       192.0.2.3/28       |
34#			        |                          |
35#			        +--------------------------+
36
37ALL_TESTS="
38	ping_ipv4
39	ecn_test
40	ecn_nodrop_test
41	red_test
42	red_qevent_test
43	ecn_qevent_test
44"
45
46NUM_NETIFS=6
47CHECK_TC="yes"
48source lib.sh
49
50BACKLOG=30000
51PKTSZ=1400
52
53h1_create()
54{
55	simple_if_init $h1 192.0.2.1/28
56	mtu_set $h1 10000
57	tc qdisc replace dev $h1 root handle 1: tbf \
58	   rate 10Mbit burst 10K limit 1M
59}
60
61h1_destroy()
62{
63	tc qdisc del dev $h1 root
64	mtu_restore $h1
65	simple_if_fini $h1 192.0.2.1/28
66}
67
68h2_create()
69{
70	simple_if_init $h2 192.0.2.2/28
71	mtu_set $h2 10000
72}
73
74h2_destroy()
75{
76	mtu_restore $h2
77	simple_if_fini $h2 192.0.2.2/28
78}
79
80h3_create()
81{
82	simple_if_init $h3 192.0.2.3/28
83	mtu_set $h3 10000
84}
85
86h3_destroy()
87{
88	mtu_restore $h3
89	simple_if_fini $h3 192.0.2.3/28
90}
91
92switch_create()
93{
94	ip link add dev br up type bridge
95	ip link set dev $swp1 up master br
96	ip link set dev $swp2 up master br
97	ip link set dev $swp3 up master br
98
99	mtu_set $swp1 10000
100	mtu_set $swp2 10000
101	mtu_set $swp3 10000
102
103	tc qdisc replace dev $swp3 root handle 1: tbf \
104	   rate 10Mbit burst 10K limit 1M
105	ip link add name _drop_test up type dummy
106}
107
108switch_destroy()
109{
110	ip link del dev _drop_test
111	tc qdisc del dev $swp3 root
112
113	mtu_restore $h3
114	mtu_restore $h2
115	mtu_restore $h1
116
117	ip link set dev $swp3 down nomaster
118	ip link set dev $swp2 down nomaster
119	ip link set dev $swp1 down nomaster
120	ip link del dev br
121}
122
123setup_prepare()
124{
125	h1=${NETIFS[p1]}
126	swp1=${NETIFS[p2]}
127
128	h2=${NETIFS[p3]}
129	swp2=${NETIFS[p4]}
130
131	swp3=${NETIFS[p5]}
132	h3=${NETIFS[p6]}
133
134	h3_mac=$(mac_get $h3)
135
136	vrf_prepare
137
138	h1_create
139	h2_create
140	h3_create
141	switch_create
142}
143
144cleanup()
145{
146	pre_cleanup
147
148	switch_destroy
149	h3_destroy
150	h2_destroy
151	h1_destroy
152
153	vrf_cleanup
154}
155
156ping_ipv4()
157{
158	ping_test $h1 192.0.2.3 " from host 1"
159	ping_test $h2 192.0.2.3 " from host 2"
160}
161
162get_qdisc_backlog()
163{
164	qdisc_stats_get $swp3 11: .backlog
165}
166
167get_nmarked()
168{
169	qdisc_stats_get $swp3 11: .marked
170}
171
172get_qdisc_npackets()
173{
174	qdisc_stats_get $swp3 11: .packets
175}
176
177get_nmirrored()
178{
179	link_stats_get _drop_test tx packets
180}
181
182send_packets()
183{
184	local proto=$1; shift
185	local pkts=$1; shift
186
187	$MZ $h2 -p $PKTSZ -a own -b $h3_mac -A 192.0.2.2 -B 192.0.2.3 -t $proto -q -c $pkts "$@"
188}
189
190# This sends traffic in an attempt to build a backlog of $size. Returns 0 on
191# success. After 10 failed attempts it bails out and returns 1. It dumps the
192# backlog size to stdout.
193build_backlog()
194{
195	local size=$1; shift
196	local proto=$1; shift
197
198	local i=0
199
200	while :; do
201		local cur=$(get_qdisc_backlog)
202		local diff=$((size - cur))
203		local pkts=$(((diff + PKTSZ - 1) / PKTSZ))
204
205		if ((cur >= size)); then
206			echo $cur
207			return 0
208		elif ((i++ > 10)); then
209			echo $cur
210			return 1
211		fi
212
213		send_packets $proto $pkts "$@"
214		sleep 1
215	done
216}
217
218check_marking()
219{
220	local cond=$1; shift
221
222	local npackets_0=$(get_qdisc_npackets)
223	local nmarked_0=$(get_nmarked)
224	sleep 5
225	local npackets_1=$(get_qdisc_npackets)
226	local nmarked_1=$(get_nmarked)
227
228	local nmarked_d=$((nmarked_1 - nmarked_0))
229	local npackets_d=$((npackets_1 - npackets_0))
230	local pct=$((100 * nmarked_d / npackets_d))
231
232	echo $pct
233	((pct $cond))
234}
235
236check_mirroring()
237{
238	local cond=$1; shift
239
240	local npackets_0=$(get_qdisc_npackets)
241	local nmirrored_0=$(get_nmirrored)
242	sleep 5
243	local npackets_1=$(get_qdisc_npackets)
244	local nmirrored_1=$(get_nmirrored)
245
246	local nmirrored_d=$((nmirrored_1 - nmirrored_0))
247	local npackets_d=$((npackets_1 - npackets_0))
248	local pct=$((100 * nmirrored_d / npackets_d))
249
250	echo $pct
251	((pct $cond))
252}
253
254ecn_test_common()
255{
256	local name=$1; shift
257	local limit=$1; shift
258	local backlog
259	local pct
260
261	# Build the below-the-limit backlog using UDP. We could use TCP just
262	# fine, but this way we get a proof that UDP is accepted when queue
263	# length is below the limit. The main stream is using TCP, and if the
264	# limit is misconfigured, we would see this traffic being ECN marked.
265	RET=0
266	backlog=$(build_backlog $((2 * limit / 3)) udp)
267	check_err $? "Could not build the requested backlog"
268	pct=$(check_marking "== 0")
269	check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0."
270	log_test "$name backlog < limit"
271
272	# Now push TCP, because non-TCP traffic would be early-dropped after the
273	# backlog crosses the limit, and we want to make sure that the backlog
274	# is above the limit.
275	RET=0
276	backlog=$(build_backlog $((3 * limit / 2)) tcp tos=0x01)
277	check_err $? "Could not build the requested backlog"
278	pct=$(check_marking ">= 95")
279	check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected >= 95."
280	log_test "$name backlog > limit"
281}
282
283do_ecn_test()
284{
285	local limit=$1; shift
286	local name=ECN
287
288	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
289		-a own -b $h3_mac -t tcp -q tos=0x01 &
290	sleep 1
291
292	ecn_test_common "$name" $limit
293
294	# Up there we saw that UDP gets accepted when backlog is below the
295	# limit. Now that it is above, it should all get dropped, and backlog
296	# building should fail.
297	RET=0
298	build_backlog $((2 * limit)) udp >/dev/null
299	check_fail $? "UDP traffic went into backlog instead of being early-dropped"
300	log_test "$name backlog > limit: UDP early-dropped"
301
302	stop_traffic
303	sleep 1
304}
305
306do_ecn_nodrop_test()
307{
308	local limit=$1; shift
309	local name="ECN nodrop"
310
311	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
312		-a own -b $h3_mac -t tcp -q tos=0x01 &
313	sleep 1
314
315	ecn_test_common "$name" $limit
316
317	# Up there we saw that UDP gets accepted when backlog is below the
318	# limit. Now that it is above, in nodrop mode, make sure it goes to
319	# backlog as well.
320	RET=0
321	build_backlog $((2 * limit)) udp >/dev/null
322	check_err $? "UDP traffic was early-dropped instead of getting into backlog"
323	log_test "$name backlog > limit: UDP not dropped"
324
325	stop_traffic
326	sleep 1
327}
328
329do_red_test()
330{
331	local limit=$1; shift
332	local backlog
333	local pct
334
335	# Use ECN-capable TCP to verify there's no marking even though the queue
336	# is above limit.
337	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
338		-a own -b $h3_mac -t tcp -q tos=0x01 &
339
340	# Pushing below the queue limit should work.
341	RET=0
342	backlog=$(build_backlog $((2 * limit / 3)) tcp tos=0x01)
343	check_err $? "Could not build the requested backlog"
344	pct=$(check_marking "== 0")
345	check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0."
346	log_test "RED backlog < limit"
347
348	# Pushing above should not.
349	RET=0
350	backlog=$(build_backlog $((3 * limit / 2)) tcp tos=0x01)
351	check_fail $? "Traffic went into backlog instead of being early-dropped"
352	pct=$(check_marking "== 0")
353	check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0."
354	log_test "RED backlog > limit"
355
356	stop_traffic
357	sleep 1
358}
359
360do_red_qevent_test()
361{
362	local limit=$1; shift
363	local backlog
364	local base
365	local now
366	local pct
367
368	RET=0
369
370	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
371		-a own -b $h3_mac -t udp -q &
372	sleep 1
373
374	tc filter add block 10 pref 1234 handle 102 matchall skip_hw \
375	   action mirred egress mirror dev _drop_test
376
377	# Push to the queue until it's at the limit. The configured limit is
378	# rounded by the qdisc, so this is the best we can do to get to the real
379	# limit.
380	build_backlog $((3 * limit / 2)) udp >/dev/null
381
382	base=$(get_nmirrored)
383	send_packets udp 100
384	sleep 1
385	now=$(get_nmirrored)
386	((now >= base + 100))
387	check_err $? "Dropped packets not observed: 100 expected, $((now - base)) seen"
388
389	tc filter del block 10 pref 1234 handle 102 matchall
390
391	base=$(get_nmirrored)
392	send_packets udp 100
393	sleep 1
394	now=$(get_nmirrored)
395	((now == base))
396	check_err $? "Dropped packets still observed: 0 expected, $((now - base)) seen"
397
398	log_test "RED early_dropped packets mirrored"
399
400	stop_traffic
401	sleep 1
402}
403
404do_ecn_qevent_test()
405{
406	local limit=$1; shift
407	local name=ECN
408
409	RET=0
410
411	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
412		-a own -b $h3_mac -t tcp -q tos=0x01 &
413	sleep 1
414
415	tc filter add block 10 pref 1234 handle 102 matchall skip_hw \
416	   action mirred egress mirror dev _drop_test
417
418	backlog=$(build_backlog $((2 * limit / 3)) tcp tos=0x01)
419	check_err $? "Could not build the requested backlog"
420	pct=$(check_mirroring "== 0")
421	check_err $? "backlog $backlog / $limit Got $pct% mirrored packets, expected == 0."
422
423	backlog=$(build_backlog $((3 * limit / 2)) tcp tos=0x01)
424	check_err $? "Could not build the requested backlog"
425	pct=$(check_mirroring ">= 95")
426	check_err $? "backlog $backlog / $limit Got $pct% mirrored packets, expected >= 95."
427
428	tc filter del block 10 pref 1234 handle 102 matchall
429
430	log_test "ECN marked packets mirrored"
431
432	stop_traffic
433	sleep 1
434}
435
436install_qdisc()
437{
438	local -a args=("$@")
439
440	tc qdisc replace dev $swp3 parent 1:1 handle 11: red \
441	   limit 1M avpkt $PKTSZ probability 1 \
442	   min $BACKLOG max $((BACKLOG + 1)) burst 38 "${args[@]}"
443	sleep 1
444}
445
446uninstall_qdisc()
447{
448	tc qdisc del dev $swp3 parent 1:1
449}
450
451ecn_test()
452{
453	install_qdisc ecn
454	do_ecn_test $BACKLOG
455	uninstall_qdisc
456}
457
458ecn_nodrop_test()
459{
460	install_qdisc ecn nodrop
461	do_ecn_nodrop_test $BACKLOG
462	uninstall_qdisc
463}
464
465red_test()
466{
467	install_qdisc
468	do_red_test $BACKLOG
469	uninstall_qdisc
470}
471
472red_qevent_test()
473{
474	install_qdisc qevent early_drop block 10
475	do_red_qevent_test $BACKLOG
476	uninstall_qdisc
477}
478
479ecn_qevent_test()
480{
481	install_qdisc ecn qevent mark block 10
482	do_ecn_qevent_test $BACKLOG
483	uninstall_qdisc
484}
485
486trap cleanup EXIT
487
488setup_prepare
489setup_wait
490
491tests_run
492
493exit $EXIT_STATUS
494