| #!/bin/bash | |
| # SPDX-License-Identifier: GPL-2.0 | |
| ALL_TESTS=" \ | |
| test_clock_jump_backward \ | |
| test_taprio_after_ptp \ | |
| test_max_sdu \ | |
| test_clock_jump_backward_forward \ | |
| " | |
| NUM_NETIFS=4 | |
| source tc_common.sh | |
| source lib.sh | |
| source tsn_lib.sh | |
| require_command python3 | |
| # The test assumes the usual topology from the README, where h1 is connected to | |
| # swp1, h2 to swp2, and swp1 and swp2 are together in a bridge. | |
| # Additional assumption: h1 and h2 use the same PHC, and so do swp1 and swp2. | |
| # By synchronizing h1 to swp1 via PTP, h2 is also implicitly synchronized to | |
| # swp1 (and both to CLOCK_REALTIME). | |
| h1=${NETIFS[p1]} | |
| swp1=${NETIFS[p2]} | |
| swp2=${NETIFS[p3]} | |
| h2=${NETIFS[p4]} | |
| UDS_ADDRESS_H1="/var/run/ptp4l_h1" | |
| UDS_ADDRESS_SWP1="/var/run/ptp4l_swp1" | |
| H1_IPV4="192.0.2.1" | |
| H2_IPV4="192.0.2.2" | |
| H1_IPV6="2001:db8:1::1" | |
| H2_IPV6="2001:db8:1::2" | |
| # Tunables | |
| NUM_PKTS=100 | |
| STREAM_VID=10 | |
| STREAM_PRIO_1=6 | |
| STREAM_PRIO_2=5 | |
| STREAM_PRIO_3=4 | |
| # PTP uses TC 0 | |
| ALL_GATES=$((1 << 0 | 1 << STREAM_PRIO_1 | 1 << STREAM_PRIO_2)) | |
| # Use a conservative cycle of 10 ms to allow the test to still pass when the | |
| # kernel has some extra overhead like lockdep etc | |
| CYCLE_TIME_NS=10000000 | |
| # Create two Gate Control List entries, one OPEN and one CLOSE, of equal | |
| # durations | |
| GATE_DURATION_NS=$((CYCLE_TIME_NS / 2)) | |
| # Give 2/3 of the cycle time to user space and 1/3 to the kernel | |
| FUDGE_FACTOR=$((CYCLE_TIME_NS / 3)) | |
| # Shift the isochron base time by half the gate time, so that packets are | |
| # always received by swp1 close to the middle of the time slot, to minimize | |
| # inaccuracies due to network sync | |
| SHIFT_TIME_NS=$((GATE_DURATION_NS / 2)) | |
| path_delay= | |
| h1_create() | |
| { | |
| simple_if_init $h1 $H1_IPV4/24 $H1_IPV6/64 | |
| } | |
| h1_destroy() | |
| { | |
| simple_if_fini $h1 $H1_IPV4/24 $H1_IPV6/64 | |
| } | |
| h2_create() | |
| { | |
| simple_if_init $h2 $H2_IPV4/24 $H2_IPV6/64 | |
| } | |
| h2_destroy() | |
| { | |
| simple_if_fini $h2 $H2_IPV4/24 $H2_IPV6/64 | |
| } | |
| switch_create() | |
| { | |
| local h2_mac_addr=$(mac_get $h2) | |
| ip link set $swp1 up | |
| ip link set $swp2 up | |
| ip link add br0 type bridge vlan_filtering 1 | |
| ip link set $swp1 master br0 | |
| ip link set $swp2 master br0 | |
| ip link set br0 up | |
| bridge vlan add dev $swp2 vid $STREAM_VID | |
| bridge vlan add dev $swp1 vid $STREAM_VID | |
| bridge fdb add dev $swp2 \ | |
| $h2_mac_addr vlan $STREAM_VID static master | |
| } | |
| switch_destroy() | |
| { | |
| ip link del br0 | |
| } | |
| ptp_setup() | |
| { | |
| # Set up swp1 as a master PHC for h1, synchronized to the local | |
| # CLOCK_REALTIME. | |
| phc2sys_start $UDS_ADDRESS_SWP1 | |
| ptp4l_start $h1 true $UDS_ADDRESS_H1 | |
| ptp4l_start $swp1 false $UDS_ADDRESS_SWP1 | |
| } | |
| ptp_cleanup() | |
| { | |
| ptp4l_stop $swp1 | |
| ptp4l_stop $h1 | |
| phc2sys_stop | |
| } | |
| txtime_setup() | |
| { | |
| local if_name=$1 | |
| tc qdisc add dev $if_name clsact | |
| # Classify PTP on TC 7 and isochron on TC 6 | |
| tc filter add dev $if_name egress protocol 0x88f7 \ | |
| flower action skbedit priority 7 | |
| tc filter add dev $if_name egress protocol 802.1Q \ | |
| flower vlan_ethtype 0xdead action skbedit priority 6 | |
| tc qdisc add dev $if_name handle 100: parent root mqprio num_tc 8 \ | |
| queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 \ | |
| map 0 1 2 3 4 5 6 7 \ | |
| hw 1 | |
| # Set up TC 5, 6, 7 for SO_TXTIME. tc-mqprio queues count from 1. | |
| tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_1 + 1)) etf \ | |
| clockid CLOCK_TAI offload delta $FUDGE_FACTOR | |
| tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_2 + 1)) etf \ | |
| clockid CLOCK_TAI offload delta $FUDGE_FACTOR | |
| tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_3 + 1)) etf \ | |
| clockid CLOCK_TAI offload delta $FUDGE_FACTOR | |
| } | |
| txtime_cleanup() | |
| { | |
| local if_name=$1 | |
| tc qdisc del dev $if_name clsact | |
| tc qdisc del dev $if_name root | |
| } | |
| taprio_replace() | |
| { | |
| local if_name="$1"; shift | |
| local extra_args="$1"; shift | |
| # STREAM_PRIO_1 always has an open gate. | |
| # STREAM_PRIO_2 has a gate open for GATE_DURATION_NS (half the cycle time) | |
| # STREAM_PRIO_3 always has a closed gate. | |
| tc qdisc replace dev $if_name root stab overhead 24 taprio num_tc 8 \ | |
| queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 \ | |
| map 0 1 2 3 4 5 6 7 \ | |
| sched-entry S $(printf "%x" $ALL_GATES) $GATE_DURATION_NS \ | |
| sched-entry S $(printf "%x" $((ALL_GATES & ~(1 << STREAM_PRIO_2)))) $GATE_DURATION_NS \ | |
| base-time 0 flags 0x2 $extra_args | |
| taprio_wait_for_admin $if_name | |
| } | |
| taprio_cleanup() | |
| { | |
| local if_name=$1 | |
| tc qdisc del dev $if_name root | |
| } | |
| probe_path_delay() | |
| { | |
| local isochron_dat="$(mktemp)" | |
| local received | |
| log_info "Probing path delay" | |
| isochron_do "$h1" "$h2" "$UDS_ADDRESS_H1" "" 0 \ | |
| "$CYCLE_TIME_NS" "" "" "$NUM_PKTS" \ | |
| "$STREAM_VID" "$STREAM_PRIO_1" "" "$isochron_dat" | |
| received=$(isochron_report_num_received "$isochron_dat") | |
| if [ "$received" != "$NUM_PKTS" ]; then | |
| echo "Cannot establish basic data path between $h1 and $h2" | |
| exit $ksft_fail | |
| fi | |
| printf "pdelay = {}\n" > isochron_data.py | |
| isochron report --input-file "$isochron_dat" \ | |
| --printf-format "pdelay[%u] = %d - %d\n" \ | |
| --printf-args "qRT" \ | |
| >> isochron_data.py | |
| cat <<-'EOF' > isochron_postprocess.py | |
| #!/usr/bin/env python3 | |
| from isochron_data import pdelay | |
| import numpy as np | |
| w = np.array(list(pdelay.values())) | |
| print("{}".format(np.max(w))) | |
| EOF | |
| path_delay=$(python3 ./isochron_postprocess.py) | |
| log_info "Path delay from $h1 to $h2 estimated at $path_delay ns" | |
| if [ "$path_delay" -gt "$GATE_DURATION_NS" ]; then | |
| echo "Path delay larger than gate duration, aborting" | |
| exit $ksft_fail | |
| fi | |
| rm -f ./isochron_data.py 2> /dev/null | |
| rm -f ./isochron_postprocess.py 2> /dev/null | |
| rm -f "$isochron_dat" 2> /dev/null | |
| } | |
| setup_prepare() | |
| { | |
| vrf_prepare | |
| h1_create | |
| h2_create | |
| switch_create | |
| txtime_setup $h1 | |
| # Temporarily set up PTP just to probe the end-to-end path delay. | |
| ptp_setup | |
| probe_path_delay | |
| ptp_cleanup | |
| } | |
| cleanup() | |
| { | |
| pre_cleanup | |
| isochron_recv_stop | |
| txtime_cleanup $h1 | |
| switch_destroy | |
| h2_destroy | |
| h1_destroy | |
| vrf_cleanup | |
| } | |
| run_test() | |
| { | |
| local base_time=$1; shift | |
| local stream_prio=$1; shift | |
| local expected_delay=$1; shift | |
| local should_fail=$1; shift | |
| local test_name=$1; shift | |
| local isochron_dat="$(mktemp)" | |
| local received | |
| local median_delay | |
| RET=0 | |
| # Set the shift time equal to the cycle time, which effectively | |
| # cancels the default advance time. Packets won't be sent early in | |
| # software, which ensures that they won't prematurely enter through | |
| # the open gate in __test_out_of_band(). Also, the gate is open for | |
| # long enough that this won't cause a problem in __test_in_band(). | |
| isochron_do "$h1" "$h2" "$UDS_ADDRESS_H1" "" "$base_time" \ | |
| "$CYCLE_TIME_NS" "$SHIFT_TIME_NS" "$GATE_DURATION_NS" \ | |
| "$NUM_PKTS" "$STREAM_VID" "$stream_prio" "" "$isochron_dat" | |
| received=$(isochron_report_num_received "$isochron_dat") | |
| [ "$received" = "$NUM_PKTS" ] | |
| check_err_fail $should_fail $? "Reception of $NUM_PKTS packets" | |
| if [ $should_fail = 0 ] && [ "$received" = "$NUM_PKTS" ]; then | |
| printf "pdelay = {}\n" > isochron_data.py | |
| isochron report --input-file "$isochron_dat" \ | |
| --printf-format "pdelay[%u] = %d - %d\n" \ | |
| --printf-args "qRT" \ | |
| >> isochron_data.py | |
| cat <<-'EOF' > isochron_postprocess.py | |
| #!/usr/bin/env python3 | |
| from isochron_data import pdelay | |
| import numpy as np | |
| w = np.array(list(pdelay.values())) | |
| print("{}".format(int(np.median(w)))) | |
| EOF | |
| median_delay=$(python3 ./isochron_postprocess.py) | |
| # If the condition below is true, packets were delayed by a closed gate | |
| [ "$median_delay" -gt $((path_delay + expected_delay)) ] | |
| check_fail $? "Median delay $median_delay is greater than expected delay $expected_delay plus path delay $path_delay" | |
| # If the condition below is true, packets were sent expecting them to | |
| # hit a closed gate in the switch, but were not delayed | |
| [ "$expected_delay" -gt 0 ] && [ "$median_delay" -lt "$expected_delay" ] | |
| check_fail $? "Median delay $median_delay is less than expected delay $expected_delay" | |
| fi | |
| log_test "$test_name" | |
| rm -f ./isochron_data.py 2> /dev/null | |
| rm -f ./isochron_postprocess.py 2> /dev/null | |
| rm -f "$isochron_dat" 2> /dev/null | |
| } | |
| __test_always_open() | |
| { | |
| run_test 0.000000000 $STREAM_PRIO_1 0 0 "Gate always open" | |
| } | |
| __test_always_closed() | |
| { | |
| run_test 0.000000000 $STREAM_PRIO_3 0 1 "Gate always closed" | |
| } | |
| __test_in_band() | |
| { | |
| # Send packets in-band with the OPEN gate entry | |
| run_test 0.000000000 $STREAM_PRIO_2 0 0 "In band with gate" | |
| } | |
| __test_out_of_band() | |
| { | |
| # Send packets in-band with the CLOSE gate entry | |
| run_test 0.005000000 $STREAM_PRIO_2 \ | |
| $((GATE_DURATION_NS - SHIFT_TIME_NS)) 0 \ | |
| "Out of band with gate" | |
| } | |
| run_subtests() | |
| { | |
| __test_always_open | |
| __test_always_closed | |
| __test_in_band | |
| __test_out_of_band | |
| } | |
| test_taprio_after_ptp() | |
| { | |
| log_info "Setting up taprio after PTP" | |
| ptp_setup | |
| taprio_replace $swp2 | |
| run_subtests | |
| taprio_cleanup $swp2 | |
| ptp_cleanup | |
| } | |
| __test_under_max_sdu() | |
| { | |
| # Limit max-sdu for STREAM_PRIO_1 | |
| taprio_replace "$swp2" "max-sdu 0 0 0 0 0 0 100 0" | |
| run_test 0.000000000 $STREAM_PRIO_1 0 0 "Under maximum SDU" | |
| } | |
| __test_over_max_sdu() | |
| { | |
| # Limit max-sdu for STREAM_PRIO_1 | |
| taprio_replace "$swp2" "max-sdu 0 0 0 0 0 0 20 0" | |
| run_test 0.000000000 $STREAM_PRIO_1 0 1 "Over maximum SDU" | |
| } | |
| test_max_sdu() | |
| { | |
| ptp_setup | |
| __test_under_max_sdu | |
| __test_over_max_sdu | |
| taprio_cleanup $swp2 | |
| ptp_cleanup | |
| } | |
| # Perform a clock jump in the past without synchronization running, so that the | |
| # time base remains where it was set by phc_ctl. | |
| test_clock_jump_backward() | |
| { | |
| # This is a more complex schedule specifically crafted in a way that | |
| # has been problematic on NXP LS1028A. Not much to test with it other | |
| # than the fact that it passes traffic. | |
| tc qdisc replace dev $swp2 root stab overhead 24 taprio num_tc 8 \ | |
| queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 map 0 1 2 3 4 5 6 7 \ | |
| base-time 0 sched-entry S 20 300000 sched-entry S 10 200000 \ | |
| sched-entry S 20 300000 sched-entry S 48 200000 \ | |
| sched-entry S 20 300000 sched-entry S 83 200000 \ | |
| sched-entry S 40 300000 sched-entry S 00 200000 flags 2 | |
| log_info "Forcing a backward clock jump" | |
| phc_ctl $swp1 set 0 | |
| ping_test $h1 192.0.2.2 | |
| taprio_cleanup $swp2 | |
| } | |
| # Test that taprio tolerates clock jumps. | |
| # Since ptp4l and phc2sys are running, it is expected for the time to | |
| # eventually recover (through yet another clock jump). Isochron waits | |
| # until that is the case. | |
| test_clock_jump_backward_forward() | |
| { | |
| log_info "Forcing a backward and a forward clock jump" | |
| taprio_replace $swp2 | |
| phc_ctl $swp1 set 0 | |
| ptp_setup | |
| ping_test $h1 192.0.2.2 | |
| run_subtests | |
| ptp_cleanup | |
| taprio_cleanup $swp2 | |
| } | |
| tc_offload_check | |
| if [[ $? -ne 0 ]]; then | |
| log_test_skip "Could not test offloaded functionality" | |
| exit $EXIT_STATUS | |
| fi | |
| trap cleanup EXIT | |
| setup_prepare | |
| setup_wait | |
| tests_run | |
| exit $EXIT_STATUS |