etwen/Blanton_TTL_Script
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 18 Wiki Activity

feat(ber,power): Add the BER sweep and TR518 load; keep ce0 actually sending

Browse Source 
Three new tools and one fix to an old one.

blanton_ber.sh - PRBS BER across every cabled port, init/start/report/
stop/clear, -u 0|1|all. A lane passes only below 1e-6 (equal to the
threshold fails). report ends with a per-unit summary carrying the worst
lane, so an all-PASS run still shows how much margin there was. init
checks every lane locked, because an unlocked lane still reports a BER
and it is a meaningless one. Script C runs it after the traffic report,
following SWB_UNIT0/SWB_UNIT1 like the traffic block does.

blanton_tr518.sh - the built-in packet test, used to load the rails
before measuring power. start settles 120s so the reading afterwards is
loaded rather than mid-ramp. stop sends port cd lb=none and nothing else,
exactly what the bench procedure does - l2 learning and test mode are
left as start set them, and stop says so instead of quietly leaving the
box in a state nobody asked about.

TH6_SWB{0,1}_power_readback.sh - 19 rails, V x I and total. These read
the two sensor tables ONCE. The previous version read them per rail: 38
invocations of a slow CLI at 38 different instants, so the "total" was a
sum of readings seconds apart - and under load the currents move (TH6_CORE
186 A -> 636 A). A rail missing from the table now warns on stderr instead
of silently contributing 0 W.

blanton_traffic_linespeed.sh - ce0 (VLAN 138) joins the test. It has no
loopback partner and a switch never sends a frame back out its ingress
port, so a tx burst was one round trip and then silence. init now sets an
ingress mirror of ce0 back to itself; the mirrored copy is not
egress-filtered, so packets keep lapping until stop turns the mirror off.
stop is what ends it - removing the VLAN membership does not, because the
copy never consulted the VLAN. TL_CE_MODE also drops to 'self': ps ce
shows one ce port per unit and a unit-0-only burst returned on unit 0.
Read as cross-unit, both links dying would still report PASS (0 == 0).

Fixes a parser bug worth remembering: bcmcmd returns CRLF, and the BER is
the last token on its line, so the CR stayed glued to the number. Every
lane read as NA, and printing the CR sent the cursor to column 1 so the
RESULT column overwrote the start of the row. One stray \r, two symptoms.

Not yet verified on hardware, all called out in the release notes: the
ce0 mirror (destport == srcport may be refused), the 120s settle (tr 518
may be time-limited), and 'test mode nr=no' on stop.

Script A -> V1.1.0.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014RetWKFZFG1ZHcitQAyhwM
This commit is contained in:
etwen
2026-08-28 16:33:40 +08:00
co-authored by Claude Opus 5
parent 43314444e9
commit 59861cf953
13 changed files with 2450 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Script_ABC_Blanton/1_Blanton_Script_A.ttl
+38 -1
View File
@@ -1,6 +1,6 @@
; =============================================================================
; Script A for Blanton
; Version : V1.0.11
; Version : V1.1.0
; Date : 2026-08-28
; Author : ETWen
; =============================================================================
@@ -95,6 +95,43 @@
; LTC2980_Margin_Script/Ref/*.md 0x15 trace note corrected to send-byte
; LTC2980_Margin_Script/script/margin_save_all.sh Point at margin_save all; keep it for subsets
; config.ttl FAN_SPEED 30 -> 100 (full speed by default)
; V1.1.0 2026-08-28 Blanton_Script/blanton_ber.sh Add whole-switch SerDes BER test (PRBS via phydiag)
; init / start / report / stop / clear, -u 0|1|all
; report: one row per lane, PASS when BER < 1e-6, then
; a summary across units carrying the worst lane
; init also checks every lane locked - an unlocked lane
; still reports a BER, and it is a meaningless one
; !! PRBS takes the SerDes out of normal operation:
; links show DOWN, no traffic passes while it runs
; Blanton_Script/blanton_tr518.sh Add TR518 packet test - loads the switch so the rails
; can be measured under traffic
; start [-u 0|1] then settles 120s (TR_SETTLE_SEC), so
; the power read afterwards is loaded, not ramping
; stop = port cd lb=none, exactly what TR518.txt does;
; l2 learn / test mode are NOT put back - stop says so
; Blanton_Script/TH6_SWB{0,1}_power_readback.sh Read the sensor tables ONCE, not once per rail
; 38 'show platform' calls -> 2. The old loop sampled
; each rail at a different instant, so the total was a
; sum of readings seconds apart. Output format unchanged
; A rail missing from the table now warns on stderr
; instead of silently counting as 0 W
; Blanton_Script/blanton_traffic_linespeed.sh Add the 100G uplink (ce0, VLAN 138) to the test
; ce0 has no loopback partner and a switch will not send
; a frame back out its ingress port, so a tx burst was
; one round trip. An INGRESS MIRROR of ce0 back to ce0
; keeps it circulating until stop turns the mirror off
; !! stop MUST run - the loop does not end on its own
; report: ce0 is the last row; a summary at the bottom
; carries every unit's PASS / FAIL / NA totals
; ScriptC Run the BER sweep, after the traffic report so the
; two do not fight over the same ports
; Follows SWB_UNIT0/SWB_UNIT1 like the traffic block:
; -u 0 / -u 1 / skip, so a single-unit DUT is not asked
; for counters from a board it does not have
; tools/BER_Test.txt Bench command references for the two new scripts
; tools/100G_Traffic.txt
; tools/TR518.txt Corrected on the bench: port cd (not *:port all),
; testphase=1, and an explicit stop
; =============================================================================
include "config.ttl"
src/Script_ABC_Blanton/3_Blanton_Script_C.ttl
+48
View File
@@ -120,6 +120,54 @@ else
endif
; ========== BER ==========
; PRBS takes the SerDes out of normal operation, so this runs AFTER the
; traffic report. sleep 30 matches blanton_ber.sh BER_INTERVAL - reporting
; earlier reads an interval that has not finished accumulating.
if SWB_UNIT0 = 1 && SWB_UNIT1 = 1 then
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh init"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh start"
wait prompt_sonic_root
sendln "sleep 30"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh report"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh stop"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh clear"
elseif SWB_UNIT0 = 1 && SWB_UNIT1 = 0 then
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh init -u 0"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh start -u 0"
wait prompt_sonic_root
sendln "sleep 30"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh report -u 0"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh stop -u 0"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh clear -u 0"
elseif SWB_UNIT0 = 0 && SWB_UNIT1 = 1 then
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh init -u 1"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh start -u 1"
wait prompt_sonic_root
sendln "sleep 30"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh report -u 1"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh stop -u 1"
wait prompt_sonic_root
sendln "./Blanton_Script/blanton_ber.sh clear -u 1"
else
endif
; ========== NVME Err Info ==========
wait prompt_sonic_root
sendln "/usr/sbin/nvme smart-log -H /dev/nvme0"
src/Script_ABC_Blanton/Blanton_Script/TH6_SWB0_power_readback.sh
+95
View File
@@ -0,0 +1,95 @@
#!/bin/bash
# =============================================================================
# TH6_SWB0_power_readback.sh -- SWB0 rail power from the platform sensors
# =============================================================================
# Version History:
# V1.1.0 2026-08-28 'show platform voltage' and 'show platform current' are
# now read ONCE each instead of once per rail. The old
# loop ran them 19 times apiece (38 invocations of a slow
# Python CLI) and every sample came from a different
# instant, so the rails were never actually measured
# together. Output format is unchanged.
# Rails missing from the tables are reported on stderr
# instead of silently contributing 0.000 V / 0.00 W.
# V1.0.0 2026-08-28 First version.
# =============================================================================
#
# Reads the two platform sensor tables:
# 'show platform voltage' -> <RAIL> in mV
# 'show platform current' -> <RAIL>_CURRENT in mA
# and reports V x I per rail plus the total.
#
# For a loaded reading, start traffic first: blanton_tr518.sh start
# =============================================================================
# --- Rails to report, in output order (edit this list) ---
rails=(
"SWB0_0V9_ANLG0"
"SWB0_0V9_ANLG1"
"SWB0_0V75_ANLG0"
"SWB0_0V75_ANLG1"
"SWB0_PHYTILE_P0"
"SWB0_PHYTILE_P1"
"SWB0_PHYTILE_P2"
"SWB0_PHYTILE_P3"
"SWB0_PHYTILE_P4"
"SWB0_PHYTILE_P5"
"SWB0_PHYTILE_P6"
"SWB0_PHYTILE_P7"
"SWB0_PVDD1V5_CNDR0"
"SWB0_PVDD1V5_CNDR1"
"SWB0_PVDDA_PHYT0"
"SWB0_PVDDA_PHYT1"
"SWB0_PVDDA_PHYT2"
"SWB0_PVDDA_PHYT3"
"SWB0_TH6_CORE"
)
# --- One snapshot of each table ---------------------------------------------
# Both are taken up front, back to back, so every rail below comes from the same
# moment. Under tr 518 the currents move a lot; re-reading per rail meant the
# total was a sum of readings taken seconds apart.
V_TABLE="$(show platform voltage 2>/dev/null)"
C_TABLE="$(show platform current 2>/dev/null)"
if [ -z "$V_TABLE" ] || [ -z "$C_TABLE" ]; then
echo "ERROR: 'show platform voltage/current' returned nothing" >&2
exit 1
fi
# --- Join and report ---------------------------------------------------------
# Sensor name is field 1 and the value field 2 in both tables; header and rule
# lines drop out because their field 2 is not numeric.
{
printf '%s\n' "$V_TABLE"
echo "@@@SPLIT@@@"
printf '%s\n' "$C_TABLE"
} | awk -v rails="${rails[*]}" '
BEGIN { n = split(rails, R, " "); sec = 1 }
/^@@@SPLIT@@@$/ { sec = 2; next }
{
if (NF < 2) next
name = $1; val = $2
if (val !~ /^[0-9]+(\.[0-9]+)?$/) next # header / ---- / blank
if (sec == 2) CUR[name] = val + 0
else VOLT[name] = val + 0
}
END {
total = 0
for (i = 1; i <= n; i++) {
rail = R[i]; cname = rail "_CURRENT"
haveV = (rail in VOLT); haveC = (cname in CUR)
if (!haveV || !haveC)
printf "WARN: %s missing from the sensor table (%s%s%s) -- counted as 0 W\n", \
rail, (haveV ? "" : "no voltage"), \
((!haveV && !haveC) ? ", " : ""), \
(haveC ? "" : "no current") > "/dev/stderr"
v = haveV ? VOLT[rail] : 0
c = haveC ? CUR[cname] : 0
p = sprintf("%.2f", (v/1000)*(c/1000))
printf "%s: Voltage=%.3f V, Current=%.3f A, Power=%.2f W\n", rail, v/1000, c/1000, p
total = sprintf("%.2f", total + p)
}
print "----------------------------------------"
printf "TOTAL POWER: %.2f W\n", total
}'
src/Script_ABC_Blanton/Blanton_Script/TH6_SWB1_power_readback.sh
+95
View File
@@ -0,0 +1,95 @@
#!/bin/bash
# =============================================================================
# TH6_SWB1_power_readback.sh -- SWB1 rail power from the platform sensors
# =============================================================================
# Version History:
# V1.1.0 2026-08-28 'show platform voltage' and 'show platform current' are
# now read ONCE each instead of once per rail. The old
# loop ran them 19 times apiece (38 invocations of a slow
# Python CLI) and every sample came from a different
# instant, so the rails were never actually measured
# together. Output format is unchanged.
# Rails missing from the tables are reported on stderr
# instead of silently contributing 0.000 V / 0.00 W.
# V1.0.0 2026-08-28 First version.
# =============================================================================
#
# Reads the two platform sensor tables:
# 'show platform voltage' -> <RAIL> in mV
# 'show platform current' -> <RAIL>_CURRENT in mA
# and reports V x I per rail plus the total.
#
# For a loaded reading, start traffic first: blanton_tr518.sh start
# =============================================================================
# --- Rails to report, in output order (edit this list) ---
rails=(
"SWB1_0V9_ANLG0"
"SWB1_0V9_ANLG1"
"SWB1_0V75_ANLG0"
"SWB1_0V75_ANLG1"
"SWB1_PHYTILE_P0"
"SWB1_PHYTILE_P1"
"SWB1_PHYTILE_P2"
"SWB1_PHYTILE_P3"
"SWB1_PHYTILE_P4"
"SWB1_PHYTILE_P5"
"SWB1_PHYTILE_P6"
"SWB1_PHYTILE_P7"
"SWB1_PVDD1V5_CNDR0"
"SWB1_PVDD1V5_CNDR1"
"SWB1_PVDDA_PHYT0"
"SWB1_PVDDA_PHYT1"
"SWB1_PVDDA_PHYT2"
"SWB1_PVDDA_PHYT3"
"SWB1_TH6_CORE"
)
# --- One snapshot of each table ---------------------------------------------
# Both are taken up front, back to back, so every rail below comes from the same
# moment. Under tr 518 the currents move a lot; re-reading per rail meant the
# total was a sum of readings taken seconds apart.
V_TABLE="$(show platform voltage 2>/dev/null)"
C_TABLE="$(show platform current 2>/dev/null)"
if [ -z "$V_TABLE" ] || [ -z "$C_TABLE" ]; then
echo "ERROR: 'show platform voltage/current' returned nothing" >&2
exit 1
fi
# --- Join and report ---------------------------------------------------------
# Sensor name is field 1 and the value field 2 in both tables; header and rule
# lines drop out because their field 2 is not numeric.
{
printf '%s\n' "$V_TABLE"
echo "@@@SPLIT@@@"
printf '%s\n' "$C_TABLE"
} | awk -v rails="${rails[*]}" '
BEGIN { n = split(rails, R, " "); sec = 1 }
/^@@@SPLIT@@@$/ { sec = 2; next }
{
if (NF < 2) next
name = $1; val = $2
if (val !~ /^[0-9]+(\.[0-9]+)?$/) next # header / ---- / blank
if (sec == 2) CUR[name] = val + 0
else VOLT[name] = val + 0
}
END {
total = 0
for (i = 1; i <= n; i++) {
rail = R[i]; cname = rail "_CURRENT"
haveV = (rail in VOLT); haveC = (cname in CUR)
if (!haveV || !haveC)
printf "WARN: %s missing from the sensor table (%s%s%s) -- counted as 0 W\n", \
rail, (haveV ? "" : "no voltage"), \
((!haveV && !haveC) ? ", " : ""), \
(haveC ? "" : "no current") > "/dev/stderr"
v = haveV ? VOLT[rail] : 0
c = haveC ? CUR[cname] : 0
p = sprintf("%.2f", (v/1000)*(c/1000))
printf "%s: Voltage=%.3f V, Current=%.3f A, Power=%.2f W\n", rail, v/1000, c/1000, p
total = sprintf("%.2f", total + p)
}
print "----------------------------------------"
printf "TOTAL POWER: %.2f W\n", total
}'
src/Script_ABC_Blanton/Blanton_Script/blanton_ber.sh
+495
View File
@@ -0,0 +1,495 @@
#!/usr/bin/env bash
# =============================================================================
# blanton_ber.sh -- SerDes BER test over every cabled port (PRBS via phydiag)
# =============================================================================
# Version History:
# V1.0.1 2026-08-28 Fix: every lane reported NA and the Port column showed
# "NA". bcmcmd returns CRLF, and the BER is the last token
# on its line, so the CR stayed glued to the number: it
# failed the numeric test (-> NA) and printing it sent the
# cursor back to column 1, so the RESULT column overwrote
# the start of the row. The parser now strips CR first.
# (The traffic report never hit this -- there the counter
# is followed by a delta, so the CR was trimmed with it.)
# V1.0.0 2026-08-28 First version. Bash port of tools/BER_Test.txt.
# init/clear/start/stop/report, -u 0|1|all (default both).
# report parses 'prbsstat Ber' into a per-lane table with a
# PASS/FAIL against BER_MAX (default 1e-6) and a summary
# across units at the very bottom.
# =============================================================================
#
# This is the WHOLE-SWITCH BER sweep: every cabled port, both lanes, PRBS-31
# through the SerDes. Not to be confused with port_prbs_monitor.sh, which drives
# the two 100G uplinks only and polls them continuously.
#
# Order of operations (matches tools/BER_Test.txt):
# init phydiag <ports> prbs set p=3 arm PRBS on every lane
# phydiag <ports> prbs get confirm every lane locked
# start phydiag <ports> prbsstat STArt Interval=<n>
# ...wait at least one Interval...
# report phydiag <ports> prbsstat Ber read + judge
# stop phydiag <ports> prbsstat STOp
# clear phydiag <ports> prbs clear disarm, release the lanes
#
# ⚠️ 'clear' disarms PRBS -- run 'init' again before another measurement.
# ⚠️ PRBS takes the SerDes out of normal operation: the links report DOWN and no
# traffic passes while it is armed. Do not run this alongside
# blanton_traffic_linespeed or blanton_tr518.
#
# Usage (run directly):
# ./blanton_ber.sh init # both units
# ./blanton_ber.sh start -u 0 # unit 0 only
# ./blanton_ber.sh report
# ./blanton_ber.sh stop
# ./blanton_ber.sh clear
#
# Usage (sourced, like the other blanton_*.sh tools):
# source blanton_ber.sh
# blanton_ber report -u 1
#
# Options:
# -u|--unit <0|1|all|0,1> bcmcmd unit(s). Default: $BER_UNITS ("0 1")
# -c|--criteria <ber> report: PASS threshold (default $BER_MAX)
# -i|--interval <sec> start: prbsstat Interval (default $BER_INTERVAL)
# -p|--ports <list> override the port list
# -F|--fail-only report: list only the lanes that FAIL
# --tsv report: tab-separated (paste into Excel)
# --raw report: also print the raw 'prbsstat Ber' output
# --color|--no-color report: force / disable colours
# -f|--file <log> report: parse a saved console log, do not touch DUT
# -d|--debug print every bcmcmd before running it
# -n|--dry-run print commands only, do not touch the DUT
# -h|--help help
#
# Environment overrides:
# BCMCMD_CMD=bcmcmd BER_UNITS="0 1" BER_MAX=1e-6 BER_INTERVAL=30
# BER_PORTS="1-24,..." BER_POLY=p=3 BER_LOG_DIR=/tmp DEBUG_MODE=1
# =============================================================================
# === Config ==================================================================
BCMCMD_CMD="${BCMCMD_CMD:-bcmcmd}"
BER_UNITS="${BER_UNITS:-0 1}" # one DUT = two switch boards (0 and 1)
# The cabled ports, in bcm logical-port numbering. Same list as
# blanton_traffic_linespeed.sh's TL_PS_PORTS -- kept as one string so it can be
# pasted straight from/into a manual phydiag command.
BER_PORTS="${BER_PORTS:-1-24,40-96,112-168,184-240,256-259,270-308,310-327,342-380,382-399,414-452,454-471,486-524,526-543,558-565}"
BER_POLY="${BER_POLY:-p=3}" # passed to 'prbs set'
BER_INTERVAL="${BER_INTERVAL:-30}" # passed to 'prbsstat STArt Interval='
# PASS threshold. A lane PASSES when its BER is strictly BELOW this.
# 1e-6 is the acceptance figure for this project; the measured lanes sit around
# 1e-13..1e-8, so anything near the threshold is already a real finding.
BER_MAX="${BER_MAX:-1e-6}"
BER_LOG_DIR="${BER_LOG_DIR:-/tmp}" # where the raw 'prbsstat Ber' capture goes
BER_FAIL_ONLY=${BER_FAIL_ONLY:-0}
BER_TSV=${BER_TSV:-0}
BER_RAW=${BER_RAW:-0}
BER_REPORT_FILE="" # -f <log>: parse this instead of the DUT
BER_COLOR="${BER_COLOR:-auto}" # auto|always|never
DEBUG_MODE=${DEBUG_MODE:-0}
BER_DRY_RUN=${BER_DRY_RUN:-0}
# === Logging =================================================================
_ber_info() { echo -e "[\033[34mINFO\033[0m] $*"; }
_ber_ok() { echo -e "[\033[32m OK \033[0m] $*"; }
_ber_warn() { echo -e "[\033[33mWARN\033[0m] $*" >&2; }
_ber_err() { echo -e "[\033[31mERR \033[0m] $*" >&2; }
_ber_dbg() { [ "$DEBUG_MODE" = "1" ] && echo -e "\033[90m[DEBG] $*\033[0m" >&2; return 0; }
# === bcmcmd wrapper ==========================================================
# stdin closed for the same reason as blanton_traffic_linespeed.sh: bcmcmd
# otherwise inherits the caller's stdin and eats what a surrounding loop reads.
#
# bcmcmd exits 0 even when the BCM shell refused the command, so the output is
# pattern-matched as well. And it exits NON-zero on long-running commands whose
# response poll times out while the command is in fact fine -- that one is
# tolerated (the blanton_tr518.sh lesson).
BER_ERR_PAT="${BER_ERR_PAT:-ERROR|Failed to execute|Invalid|Syntax error|Unavailable|Unknown command}"
BER_BENIGN_PAT="${BER_BENIGN_PAT:-polling socket timeout}"
# _ber_bcm <unit> <phydiag args...> -- wraps in dsh -c 'phydiag <ports> ...'
# echoes the DUT output on stdout, returns 0 ok / 1 failed
_ber_bcm() {
local unit="$1"; shift
local inner="phydiag ${BER_PORTS} $*"
local cmd="dsh -c '${inner}'"
_ber_dbg "$BCMCMD_CMD -n $unit -c \"${cmd}\""
if [ "$BER_DRY_RUN" = "1" ]; then
echo "[DRY ] $BCMCMD_CMD -n $unit -c \" ${cmd} \"" >&2
return 0
fi
local out rc
out=$("$BCMCMD_CMD" -n "$unit" -c "$cmd" </dev/null 2>&1); rc=$?
printf '%s\n' "$out"
if echo "$out" | grep -qiE "$BER_ERR_PAT"; then
_ber_err "unit $unit: the BCM shell rejected 'phydiag ... $*'"
return 1
fi
if [ "$rc" -ne 0 ] && ! echo "$out" | grep -qiE "$BER_BENIGN_PAT"; then
_ber_err "unit $unit: bcmcmd exited $rc on 'phydiag ... $*'"
return 1
fi
return 0
}
_ber_units_check() {
local u ok=""
for u in $BER_UNITS; do
case "$u" in
0|1) ok="$ok $u" ;;
*) _ber_err "invalid unit '$u' (use 0, 1 or all)"; return 1 ;;
esac
done
[ -n "$ok" ] || { _ber_err "no unit selected"; return 1; }
BER_UNITS="${ok# }"
return 0
}
_ber_use_color() {
case "$BER_COLOR" in
always|1|yes) return 0 ;;
never|0|no) return 1 ;;
*) [ -t 1 ] && [ "$BER_TSV" != "1" ] ;;
esac
}
# === init ====================================================================
# prbs set + prbs get. The 'get' is not decoration: a lane that did not lock
# still reports a BER later, and it is a meaningless one.
blanton_ber_init() {
_ber_units_check || return 1
local unit out total ok rc=0
for unit in $BER_UNITS; do
_ber_info "unit $unit: prbs set ${BER_POLY} on ${BER_PORTS}"
_ber_bcm "$unit" "prbs set ${BER_POLY}" >/dev/null || { rc=1; continue; }
out=$(_ber_bcm "$unit" "prbs get") || { rc=1; continue; }
[ "$BER_DRY_RUN" = "1" ] && continue
# lines look like: " 185 : PRBS OK!has been unlocked since last call"
total=$(printf '%s\n' "$out" | grep -cE '^[ \t]*[0-9]+[ \t]*:')
ok=$(printf '%s\n' "$out" | grep -cE '^[ \t]*[0-9]+[ \t]*:.*PRBS OK')
if [ "$total" -eq 0 ]; then
_ber_err "unit $unit: 'prbs get' reported no lanes at all"
rc=1
elif [ "$ok" -eq "$total" ]; then
_ber_ok "unit $unit: $ok/$total ports locked"
else
_ber_warn "unit $unit: only $ok/$total ports locked -- the rest will report a meaningless BER:"
printf '%s\n' "$out" | grep -E '^[ \t]*[0-9]+[ \t]*:' | grep -v 'PRBS OK' >&2
rc=2
fi
done
return $rc
}
# === clear ===================================================================
blanton_ber_clear() {
_ber_units_check || return 1
local unit rc=0
for unit in $BER_UNITS; do
_ber_info "unit $unit: prbs clear"
_ber_bcm "$unit" "prbs clear" >/dev/null || rc=1
done
[ "$rc" -eq 0 ] && _ber_ok "PRBS disarmed on unit(s): $BER_UNITS -- run 'init' before measuring again"
return $rc
}
# === start ===================================================================
blanton_ber_start() {
_ber_units_check || return 1
local unit rc=0
for unit in $BER_UNITS; do
_ber_info "unit $unit: prbsstat STArt Interval=${BER_INTERVAL}"
_ber_bcm "$unit" "prbsstat STArt Interval=${BER_INTERVAL}" >/dev/null || rc=1
done
if [ "$rc" -eq 0 ]; then
_ber_ok "BER accumulation running on unit(s): $BER_UNITS"
_ber_info "wait at least ${BER_INTERVAL}s before 'report' -- a shorter run has not accumulated a full interval"
fi
return $rc
}
# === stop ====================================================================
blanton_ber_stop() {
_ber_units_check || return 1
local unit rc=0
for unit in $BER_UNITS; do
_ber_info "unit $unit: prbsstat STOp"
_ber_bcm "$unit" "prbsstat STOp" >/dev/null || rc=1
done
if [ "$rc" -eq 0 ]; then
_ber_ok "BER accumulation stopped on unit(s): $BER_UNITS"
_ber_info "PRBS is still armed -- 'clear' releases the lanes and restores normal operation"
fi
return $rc
}
# === report ==================================================================
# Parses 'prbsstat Ber' output:
# port BER
# ====
# 1[0] : 3.53e-11
# 1[1] : 4.00e-11
# into <port> <lane> <ber> <verdict>, PASS when ber < BER_MAX.
# _ber_render <logfile> [side_file] -> 0 all PASS, 2 any FAIL/NA, 1 parse error
_ber_render() {
local log="$1" side="${2:-/dev/null}" color=0
_ber_use_color && color=1
awk -v MAXBER="$BER_MAX" \
-v FAILONLY="$BER_FAIL_ONLY" \
-v TSV="$BER_TSV" \
-v COLOR="$color" \
-v SIDE="$side" '
function vc(v) {
if (!COLOR) return v
if (v == "PASS") return "\033[32m" v "\033[0m"
if (v == "FAIL") return "\033[31m" v "\033[0m"
return "\033[33m" v "\033[0m"
}
BEGIN {
LIM = MAXBER + 0
NC = 4
HDR[1] = "Port"; AL[1] = 1
HDR[2] = "Lane"; AL[2] = 1
HDR[3] = "BER"; AL[3] = 1
HDR[4] = "RESULT"; AL[4] = 1
worst = -1; worstlane = "-"
}
# bcmcmd hands back CRLF. On the cd/traffic report the counter is followed by
# a delta, so the CR got trimmed with the rest of the line; here the BER is
# the LAST token, so the CR sticks to the number -- it failed the numeric
# test (every lane NA) and, worse, printing it moved the cursor back to
# column 1 so the RESULT column overwrote the start of the row.
{ gsub(/\r/, "") }
{
# " 203[1] : 5.05e-09" (leading spaces vary, "====" separators ignored)
if ($0 !~ /^[ \t]*[0-9]+\[[0-9]+\][ \t]*:/) next
line = $0
sub(/^[ \t]+/, "", line)
p = index(line, "[")
q = index(line, "]")
c = index(line, ":")
port = substr(line, 1, p - 1)
lane = substr(line, p + 1, q - p - 1)
ber = substr(line, c + 1)
gsub(/^[ \t\r]+|[ \t\r]+$/, "", ber)
sub(/[ \t\r].*$/, "", ber)
seen++
n++
PORT[n] = port; LANE[n] = lane; BERS[n] = ber
# a lane that reported something non-numeric has no usable measurement
if (ber ~ /^[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?$/) {
v = ber + 0
if (v < LIM) { V[n] = "PASS"; npass++ }
else { V[n] = "FAIL"; nfail++ }
if (v > worst) { worst = v; worstlane = port "[" lane "]"; worststr = ber }
} else {
V[n] = "NA"; nna++
}
}
END {
if (seen == 0) {
print "error: no \"<port>[<lane>] : <ber>\" line found in the log" > "/dev/stderr"
exit 1
}
# column widths over the rows that will actually be printed
for (c2 = 1; c2 <= NC; c2++) w[c2] = length(HDR[c2])
for (i = 1; i <= n; i++) {
if (FAILONLY && V[i] == "PASS") continue
if (length(PORT[i]) > w[1]) w[1] = length(PORT[i])
if (length(LANE[i]) > w[2]) w[2] = length(LANE[i])
if (length(BERS[i]) > w[3]) w[3] = length(BERS[i])
if (length(V[i]) > w[4]) w[4] = length(V[i])
}
for (c2 = 1; c2 <= NC; c2++) w[c2] += 2
if (TSV) {
print HDR[1] "\t" HDR[2] "\t" HDR[3] "\t" HDR[4]
for (i = 1; i <= n; i++) {
if (FAILONLY && V[i] == "PASS") continue
print PORT[i] "\t" LANE[i] "\t" BERS[i] "\t" V[i]
}
} else {
printf "%*s%*s%*s%*s\n", w[1], HDR[1], w[2], HDR[2], w[3], HDR[3], w[4], HDR[4]
for (i = 1; i <= n; i++) {
if (FAILONLY && V[i] == "PASS") continue
printf "%*s%*s%*s", w[1], PORT[i], w[2], LANE[i], w[3], BERS[i]
# pad on the plain text, then colour, so the columns stay aligned
printf "%*s%s\n", w[4] - length(V[i]), "", vc(V[i])
}
if (FAILONLY && nfail == 0 && nna == 0)
print " (no failing lane)"
}
print ""
printf "# lanes measured : %d\n", n
printf "# %s %d %s %d %s %d (criteria BER < %s)\n", \
vc("PASS"), npass + 0, vc("FAIL"), nfail + 0, vc("NA"), nna + 0, MAXBER
if (worst >= 0)
printf "# worst lane : %s %s\n", worstlane, worststr
if (SIDE != "" && SIDE != "/dev/null")
printf "SUM %d %d %d %d %s %s\n", n, npass + 0, nfail + 0, nna + 0, \
(worst >= 0 ? worststr : "-"), worstlane > SIDE
exit (nfail || nna) ? 2 : 0
}' "$log"
}
# _ber_summary <stamp> -- one table for every unit, printed last
_ber_summary() {
local stamp="$1" unit side g r y n worst=0
g=$'\033[32m'; r=$'\033[31m'; y=$'\033[33m'; n=$'\033[0m'
_ber_use_color || { g=""; r=""; y=""; n=""; }
echo ""
echo "===== summary : all units ====="
printf '%-8s %8s %8s %8s %8s %-12s %-10s %s\n' \
"Unit" "LANES" "PASS" "FAIL" "NA" "WORST BER" "WORST LANE" "RESULT"
local tag lanes pass fail na wber wlane v any=0
for unit in $BER_UNITS; do
side="$BER_LOG_DIR/berside_unit${unit}_${stamp}"
[ -r "$side" ] || continue
read -r tag lanes pass fail na wber wlane < "$side" 2>/dev/null
[ "$tag" = "SUM" ] || continue
any=1
if [ "${fail:-0}" -gt 0 ] || [ "${na:-0}" -gt 0 ]; then
v="${r}FAIL${n}"; worst=2
else
v="${g}PASS${n}"
fi
printf '%-8s %8s %8s %8s %8s %-12s %-10s %b\n' \
"unit $unit" "$lanes" "$pass" "$fail" "$na" "$wber" "$wlane" "$v"
done
[ "$any" = "1" ] || echo " (no unit produced a result)"
echo ""
printf 'criteria: BER < %s\n' "$BER_MAX"
echo ""
return "$worst"
}
blanton_ber_report() {
local unit log side rc worst=0 stamp
# -f <log>: offline, no DUT access, no unit loop -> no cross-unit summary
if [ -n "$BER_REPORT_FILE" ]; then
[ -r "$BER_REPORT_FILE" ] || { _ber_err "cannot read log '$BER_REPORT_FILE'"; return 1; }
_ber_info "report from log: $BER_REPORT_FILE (criteria BER < $BER_MAX)" >&2
_ber_render "$BER_REPORT_FILE"; return $?
fi
_ber_units_check || return 1
if [ "$BER_DRY_RUN" = "1" ]; then
for unit in $BER_UNITS; do _ber_bcm "$unit" "prbsstat Ber" >/dev/null; done
return 0
fi
stamp=$(date +%Y%m%d_%H%M%S 2>/dev/null || echo now)
for unit in $BER_UNITS; do
log="$BER_LOG_DIR/prbsber_unit${unit}_${stamp}.log"
side="$BER_LOG_DIR/berside_unit${unit}_${stamp}"
: > "$side"
if ! _ber_bcm "$unit" "prbsstat Ber" > "$log" 2>&1; then
_ber_err "unit $unit: 'prbsstat Ber' failed (see $log)"; worst=1; continue
fi
[ "$BER_RAW" = "1" ] && { echo "----- unit $unit : raw prbsstat Ber -----"; cat "$log"; }
echo "===== unit $unit : PRBS BER report (raw: $log) ====="
_ber_render "$log" "$side"; rc=$?
[ "$rc" -gt "$worst" ] && worst=$rc
case "$rc" in
0) _ber_ok "unit $unit: every lane below $BER_MAX" ;;
2) _ber_warn "unit $unit: at least one lane FAIL/NA" ;;
*) _ber_err "unit $unit: report parse error" ;;
esac
done
_ber_summary "$stamp"; rc=$?
[ "$rc" -gt "$worst" ] && worst=$rc
rm -f "$BER_LOG_DIR"/berside_unit*_"${stamp}"
return "$worst"
}
# === Help ====================================================================
blanton_ber_help() {
echo -e "\033[1mblanton_ber.sh - SerDes BER test over every cabled port (PRBS via phydiag)\033[0m"
echo ""
echo -e " Units : \033[36m$BER_UNITS\033[0m poly: \033[36m$BER_POLY\033[0m interval: \033[36m${BER_INTERVAL}s\033[0m"
echo -e " Criteria : BER < \033[36m$BER_MAX\033[0m"
echo -e " Ports : \033[36m$BER_PORTS\033[0m"
echo ""
echo -e "\033[1mSubcommands\033[0m"
echo -e " \033[33minit\033[0m prbs set $BER_POLY + prbs get (checks every lane locked)"
echo -e " \033[33mstart\033[0m prbsstat STArt Interval=$BER_INTERVAL"
echo -e " \033[33mreport\033[0m prbsstat Ber -> per-lane table + PASS/FAIL + summary"
echo -e " \033[33mstop\033[0m prbsstat STOp"
echo -e " \033[33mclear\033[0m prbs clear (disarms PRBS -- 'init' again before measuring)"
echo -e " \033[33mhelp\033[0m"
echo ""
echo -e "\033[1mOptions\033[0m"
echo -e " \033[33m-u|--unit\033[0m <0|1|all> bcmcmd unit(s); 'all' = 0 1 (default: $BER_UNITS)"
echo -e " \033[33m-c|--criteria\033[0m <ber> PASS threshold (default $BER_MAX)"
echo -e " \033[33m-i|--interval\033[0m <sec> prbsstat Interval (default $BER_INTERVAL)"
echo -e " \033[33m-p|--ports\033[0m <list> override the port list"
echo -e " \033[33m-F|--fail-only\033[0m report: list only failing lanes"
echo -e " \033[33m--tsv\033[0m report: tab-separated"
echo -e " \033[33m--raw\033[0m report: also print the raw output"
echo -e " \033[33m-f|--file\033[0m <log> report: parse a saved log, do not touch the DUT"
echo -e " \033[33m-d|--debug\033[0m print every bcmcmd"
echo -e " \033[33m-n|--dry-run\033[0m print commands only"
echo ""
echo -e "\033[1mTypical run\033[0m"
echo -e " ./blanton_ber.sh init && ./blanton_ber.sh start"
echo -e " sleep $BER_INTERVAL"
echo -e " ./blanton_ber.sh report"
echo -e " ./blanton_ber.sh stop && ./blanton_ber.sh clear"
echo ""
echo -e "\033[33m PRBS takes the SerDes out of normal operation: links show DOWN and no\033[0m"
echo -e "\033[33m traffic passes. Do not run alongside blanton_traffic_linespeed / blanton_tr518.\033[0m"
}
# === Argument parsing ========================================================
blanton_ber() {
local sub="${1:-help}"; shift 2>/dev/null
while [ $# -gt 0 ]; do
case "$1" in
-u|--unit)
case "$2" in
all|ALL) BER_UNITS="0 1" ;;
*) BER_UNITS="$(echo "$2" | tr ',' ' ')" ;;
esac
shift 2 ;;
-c|--criteria) BER_MAX="$2"; shift 2 ;;
-i|--interval) BER_INTERVAL="$2"; shift 2 ;;
-p|--ports) BER_PORTS="$2"; shift 2 ;;
-f|--file) BER_REPORT_FILE="$2"; shift 2 ;;
-F|--fail-only) BER_FAIL_ONLY=1; shift ;;
--tsv) BER_TSV=1; shift ;;
--raw) BER_RAW=1; shift ;;
--color) BER_COLOR=always; shift ;;
--no-color) BER_COLOR=never; shift ;;
-d|--debug) DEBUG_MODE=1; shift ;;
-n|--dry-run) BER_DRY_RUN=1; shift ;;
-h|--help) blanton_ber_help; return 0 ;;
*) _ber_err "unknown option '$1'"; return 1 ;;
esac
done
case "$sub" in
init) blanton_ber_init ;;
clear) blanton_ber_clear ;;
start) blanton_ber_start ;;
stop) blanton_ber_stop ;;
report) blanton_ber_report ;;
help|-h|--help) blanton_ber_help ;;
*) _ber_err "unknown subcommand '$sub'"; blanton_ber_help; return 1 ;;
esac
}
# Run when executed, define-only when sourced (same as the other blanton_*.sh).
if [ "${BASH_SOURCE[0]}" = "$0" ]; then
blanton_ber "$@"
fi
src/Script_ABC_Blanton/Blanton_Script/blanton_tr518.sh
+326
View File
@@ -0,0 +1,326 @@
#!/usr/bin/env bash
# =============================================================================
# blanton_tr518.sh -- TH6 built-in packet test (tr 518) via bcmcmd
# =============================================================================
# Version History:
# V1.0.1 2026-08-28 Fix: start reported ERR on a run that was actually fine.
# bcmcmd exits NON-zero on 'tr 518' because the test
# outlives its response poll ("polling socket timeout:
# Success") -- the command had been accepted and was
# running. The tr 518 step is now judged on a POSITIVE
# marker in the output ("TR 518 TEST PARAMETERS", which
# the shell prints only after it starts the test) instead
# of on bcmcmd's exit status, and "polling socket timeout"
# is tolerated generally. Failures now also say WHICH
# check tripped (shell rejected it / bcmcmd exited N).
# V1.0.0 2026-08-28 First version. Bash port of tools/TR518.txt, command for
# command. start = port cd lb=mac, l2 learn off,
# test mode nr=yes, tr 518 ... testphase=1, then a settle
# wait so a power reading taken afterwards is a loaded and
# stable one rather than a ramping one.
# stop = port cd lb=none (exactly what TR518.txt does).
# -u 0 | -u 1 | -u all (default both).
# =============================================================================
#
# What this is for: tr 518 loads the switch so the power rails can be measured
# under traffic. The usual sequence is
#
# blanton_tr518.sh start # loads both units, waits to settle
# TH6_SWB0_power_readback.sh # now the numbers mean something
# TH6_SWB1_power_readback.sh
# blanton_tr518.sh stop
#
# ⚠️ tr 518 and blanton_traffic_linespeed CANNOT run at the same time. Both take
# over the cd ports and L2 learning; running one while the other is set up
# gives numbers from neither test. Stop one before the other starts.
#
# ⚠️ stop only undoes the loopback -- see TR_RESTORE_* below.
#
# Usage (run directly):
# ./blanton_tr518.sh start # both units
# ./blanton_tr518.sh start -u 0 # unit 0 only
# ./blanton_tr518.sh start -u 1 # unit 1 only
# ./blanton_tr518.sh stop [-u 0|1]
# ./blanton_tr518.sh help
#
# Usage (sourced, like the other blanton_*.sh tools):
# source blanton_tr518.sh
# blanton_tr518 start -u 0
#
# Options:
# -u|--unit <0|1|all|0,1> bcmcmd unit(s). Default: $TR_UNITS ("0 1")
# -w|--wait <sec> start: settle wait after tr 518 (default $TR_SETTLE_SEC)
# --no-wait start: skip the settle wait entirely
# -d|--debug print every bcmcmd and its output
# -n|--dry-run print commands only, do not touch the DUT
# -h|--help help
#
# Environment overrides:
# BCMCMD_CMD=bcmcmd TR_UNITS="0 1" TR_SETTLE_SEC=120 TR_UNIT_GAP_SEC=1
# TR_TEST_ARGS="..." TR_LB_PORTS=cd TR_RESTORE_LEARN=0 TR_RESTORE_TESTMODE=0
# DEBUG_MODE=1
# =============================================================================
# === Config ==================================================================
BCMCMD_CMD="${BCMCMD_CMD:-bcmcmd}"
TR_UNITS="${TR_UNITS:-0 1}" # one DUT = two switch boards (0 and 1)
# Settle wait after tr 518 is issued. The point is NOT the test itself -- it is
# to stop someone reading power while traffic is still ramping and reporting a
# number that is neither idle nor loaded. Lower it only if you know the rails
# have already settled.
TR_SETTLE_SEC="${TR_SETTLE_SEC:-120}"
# Gap between unit 0 and unit 1 (each unit is set up as a complete block, the
# way TR518.txt does it -- the cd ports are in MAC loopback, so a unit does not
# depend on the other one being ready).
TR_UNIT_GAP_SEC="${TR_UNIT_GAP_SEC:-1}"
# Ports put into MAC loopback. 'cd' = the cd port group, per TR518.txt.
TR_LB_PORTS="${TR_LB_PORTS:-cd}"
# The tr 518 argument string, verbatim from tools/TR518.txt. One editable line
# so it can be pasted straight from / into a manual bcmcmd.
# Printed by the BCM shell only after tr 518 has accepted its arguments and
# started. Used as the success marker, because bcmcmd's own exit status is not
# trustworthy for a command that runs longer than its response poll.
TR_TEST_OK_PAT="${TR_TEST_OK_PAT:-TR 518 TEST PARAMETERS}"
TR_TEST_ARGS="${TR_TEST_ARGS:-Scenario=6 Profile=2 Count=260 PktSize=324 PortList=1-259,270-565 rm=ext CheckLinkTime=20 CheckDataTime=200 testphase=1}"
# TR518.txt stops with 'port cd lb=none' and nothing else, so that is the
# default here too. But note what start changed and stop does NOT put back:
# l2 learn off -> the unit keeps learning disabled
# test mode nr=yes -> the unit stays in test mode
# Both persist until something else changes them or the box reboots. Set these
# to 1 if you want stop to be a true inverse; they are off by default because
# they are not in the bench-verified list.
TR_RESTORE_LEARN="${TR_RESTORE_LEARN:-0}"
TR_RESTORE_TESTMODE="${TR_RESTORE_TESTMODE:-0}"
DEBUG_MODE=${DEBUG_MODE:-0}
TR_DRY_RUN=${TR_DRY_RUN:-0}
TR_NO_WAIT=${TR_NO_WAIT:-0}
# === Logging =================================================================
_tr_info() { echo -e "[\033[34mINFO\033[0m] $*"; }
_tr_ok() { echo -e "[\033[32m OK \033[0m] $*"; }
_tr_warn() { echo -e "[\033[33mWARN\033[0m] $*" >&2; }
_tr_err() { echo -e "[\033[31mERR \033[0m] $*" >&2; }
_tr_dbg() { [ "$DEBUG_MODE" = "1" ] && echo -e "\033[90m[DEBG] $*\033[0m" >&2; return 0; }
# === bcmcmd wrapper ==========================================================
# stdin is closed for the same reason as in blanton_traffic_linespeed.sh:
# bcmcmd otherwise inherits the caller's stdin and eats whatever a surrounding
# loop was reading.
#
# bcmcmd exits 0 even when the BCM shell refused the command, so the output is
# pattern-matched as well (the V0.3.1 lesson from blanton_traffic_linespeed.sh).
TR_ERR_PAT="${TR_ERR_PAT:-ERROR|Failed to execute|Invalid|Syntax error|Unavailable|Unknown command}"
# ...and the reverse also happens: bcmcmd exits NON-zero on a command that was
# accepted and is running. 'tr 518' outlives bcmcmd's response poll, so bcmcmd
# gives up with "polling socket timeout: Success" and a non-zero status while
# the test carries on inside the BCM shell. Treating that as a failure is what
# made V1.0.0 report ERR on a run that was actually fine.
TR_BENIGN_PAT="${TR_BENIGN_PAT:-polling socket timeout}"
# _tr_bcm <unit> <cmd> -> 0 ok, 1 failed
# _tr_bcm_ok <unit> <ok_marker> <cmd> -> as above, but if the output contains
# <ok_marker> the command is a success
# regardless of exit status.
#
# The marker is a POSITIVE proof of success ("the shell printed the thing it
# only prints when it accepted this command"), which is far more reliable than
# trying to enumerate every way bcmcmd can look unhappy.
_tr_bcm() { _tr_bcm_ok "$1" "" "${@:2}"; }
_tr_bcm_ok() {
local unit="$1" okpat="$2"; shift 2
local cmd="$*" out rc why=""
_tr_dbg "$BCMCMD_CMD -n $unit -c '$cmd'"
if [ "$TR_DRY_RUN" = "1" ]; then
echo "[DRY ] $BCMCMD_CMD -n $unit -c '$cmd'"
return 0
fi
out=$("$BCMCMD_CMD" -n "$unit" -c "$cmd" </dev/null 2>&1); rc=$?
[ "$DEBUG_MODE" = "1" ] && [ -n "$out" ] && echo "$out"
# 1. positive proof wins over everything else
if [ -n "$okpat" ] && echo "$out" | grep -qF "$okpat"; then
[ "$rc" -ne 0 ] && _tr_dbg "unit $unit: bcmcmd rc=$rc but '$okpat' seen -> accepted"
return 0
fi
# 2. the BCM shell said no
if echo "$out" | grep -qiE "$TR_ERR_PAT"; then
why="the BCM shell rejected it"
# 3. bcmcmd itself was unhappy -- unless it is the known transport artifact
elif [ "$rc" -ne 0 ]; then
if echo "$out" | grep -qiE "$TR_BENIGN_PAT"; then
_tr_dbg "unit $unit: bcmcmd rc=$rc (${TR_BENIGN_PAT}) -> tolerated"
return 0
fi
why="bcmcmd exited $rc"
else
return 0
fi
_tr_err "unit $unit: $why -- '$cmd'"
[ "$DEBUG_MODE" = "1" ] || { [ -n "$out" ] && echo "$out" >&2; }
return 1
}
_tr_units_check() {
local u ok=""
for u in $TR_UNITS; do
case "$u" in
0|1) ok="$ok $u" ;;
*) _tr_err "invalid unit '$u' (use 0, 1 or all)"; return 1 ;;
esac
done
[ -n "$ok" ] || { _tr_err "no unit selected"; return 1; }
TR_UNITS="${ok# }"
return 0
}
_tr_is_uint() { case "$1" in ''|*[!0-9]*) return 1 ;; *) return 0 ;; esac; }
_tr_gap() {
[ "$TR_DRY_RUN" = "1" ] && return 0
[ "$TR_UNIT_GAP_SEC" = "0" ] && return 0
sleep "$TR_UNIT_GAP_SEC"
}
# === start ===================================================================
# One complete block per unit, exactly the order in tools/TR518.txt.
blanton_tr518_start() {
_tr_units_check || return 1
_tr_is_uint "$TR_SETTLE_SEC" || { _tr_err "settle wait '$TR_SETTLE_SEC' is not an integer (-w <sec>)"; return 1; }
local unit fail=0 first=1
_tr_info "TR518 start on unit(s): $TR_UNITS"
for unit in $TR_UNITS; do
[ "$first" = "0" ] && _tr_gap
first=0
_tr_info "unit $unit: port $TR_LB_PORTS lb=mac -> l2 learn off -> test mode nr=yes -> tr 518"
_tr_bcm "$unit" "port $TR_LB_PORTS lb=mac" || fail=$((fail+1))
_tr_bcm "$unit" "l2 learn off" || fail=$((fail+1))
_tr_bcm "$unit" 'dsh -c "test mode nr=yes"' || fail=$((fail+1))
# "TR 518 TEST PARAMETERS" is printed only once the shell has parsed the
# arguments and started the test -- that is the proof we check for.
_tr_bcm_ok "$unit" "$TR_TEST_OK_PAT" "dsh -c \"tr 518 $TR_TEST_ARGS\"" || fail=$((fail+1))
done
if [ "$fail" -ne 0 ]; then
_tr_err "$fail command(s) failed -- traffic may not be running, not waiting"
_tr_warn "the unit(s) may still be in loopback: blanton_tr518.sh stop"
return 1
fi
if [ "$TR_NO_WAIT" = "1" ] || [ "$TR_SETTLE_SEC" = "0" ]; then
_tr_ok "TR518 running on unit(s): $TR_UNITS (settle wait skipped)"
_tr_warn "rails may still be ramping -- a power reading taken now is not a settled one"
return 0
fi
_tr_info "settling ${TR_SETTLE_SEC}s before the rails are worth reading ..."
[ "$TR_DRY_RUN" = "1" ] || sleep "$TR_SETTLE_SEC"
_tr_ok "TR518 running and settled on unit(s): $TR_UNITS"
_tr_info "read power now: TH6_SWB0_power_readback.sh / TH6_SWB1_power_readback.sh"
_tr_info "when finished: blanton_tr518.sh stop"
return 0
}
# === stop ====================================================================
# TR518.txt stops with 'port cd lb=none' only. l2 learning and test mode are
# left as start set them unless TR_RESTORE_* is turned on.
blanton_tr518_stop() {
_tr_units_check || return 1
local unit fail=0 first=1
_tr_info "TR518 stop on unit(s): $TR_UNITS"
for unit in $TR_UNITS; do
[ "$first" = "0" ] && _tr_gap
first=0
_tr_bcm "$unit" "port $TR_LB_PORTS lb=none" || fail=$((fail+1))
[ "$TR_RESTORE_LEARN" = "1" ] && { _tr_bcm "$unit" "l2 learn on" || fail=$((fail+1)); }
[ "$TR_RESTORE_TESTMODE" = "1" ] && { _tr_bcm "$unit" 'dsh -c "test mode nr=no"' || fail=$((fail+1)); }
done
if [ "$fail" -eq 0 ]; then
_tr_ok "unit(s) $TR_UNITS: port $TR_LB_PORTS lb=none"
[ "$TR_RESTORE_LEARN" = "1" ] || \
_tr_info "l2 learning is still off (TR_RESTORE_LEARN=1 to put it back)"
[ "$TR_RESTORE_TESTMODE" = "1" ] || \
_tr_info "test mode is still nr=yes (TR_RESTORE_TESTMODE=1 to put it back)"
else
_tr_warn "$fail command(s) failed -- check the unit is not still in loopback:"
_tr_warn " bcmcmd -n <u> -c 'port $TR_LB_PORTS' | head"
return 1
fi
return 0
}
# === Help ====================================================================
blanton_tr518_help() {
echo -e "\033[1mblanton_tr518.sh - TH6 built-in packet test (tr 518) for power loading\033[0m"
echo ""
echo -e " Units : \033[36m$TR_UNITS\033[0m"
echo -e " Settle wait : \033[36m${TR_SETTLE_SEC}s\033[0m after tr 518 (so power is read loaded, not ramping)"
echo -e " Loopback : \033[36mport $TR_LB_PORTS lb=mac\033[0m"
echo -e " tr 518 args : \033[36m$TR_TEST_ARGS\033[0m"
echo ""
echo -e "\033[1mSubcommands\033[0m"
echo -e " \033[33mstart\033[0m per unit: port $TR_LB_PORTS lb=mac -> l2 learn off -> test mode nr=yes -> tr 518 -> wait"
echo -e " \033[33mstop\033[0m per unit: port $TR_LB_PORTS lb=none"
echo -e " \033[33mhelp\033[0m"
echo ""
echo -e "\033[1mOptions\033[0m"
echo -e " \033[33m-u|--unit\033[0m <0|1|all> bcmcmd unit(s); 'all' = 0 1 (default: $TR_UNITS)"
echo -e " \033[33m-w|--wait\033[0m <sec> start: settle wait (default $TR_SETTLE_SEC)"
echo -e " \033[33m--no-wait\033[0m start: skip the settle wait"
echo -e " \033[33m-d|--debug\033[0m print every bcmcmd and its output"
echo -e " \033[33m-n|--dry-run\033[0m print commands only, do not touch the DUT"
echo ""
echo -e "\033[1mExamples\033[0m"
echo -e " ./blanton_tr518.sh start # both units, then wait ${TR_SETTLE_SEC}s"
echo -e " ./blanton_tr518.sh start -u 0 # unit 0 only"
echo -e " ./blanton_tr518.sh stop -u 1 # release unit 1"
echo -e " ./blanton_tr518.sh start -n # show the bcmcmds, touch nothing"
echo ""
echo -e "\033[33m stop only sends 'port $TR_LB_PORTS lb=none'. l2 learning stays off and test mode\033[0m"
echo -e "\033[33m stays nr=yes -- TR_RESTORE_LEARN=1 / TR_RESTORE_TESTMODE=1 to put them back.\033[0m"
echo -e "\033[33m tr 518 and blanton_traffic_linespeed cannot run together.\033[0m"
}
# === Argument parsing ========================================================
blanton_tr518() {
local sub="${1:-help}"; shift 2>/dev/null
while [ $# -gt 0 ]; do
case "$1" in
-u|--unit)
case "$2" in
all|ALL) TR_UNITS="0 1" ;;
*) TR_UNITS="$(echo "$2" | tr ',' ' ')" ;;
esac
shift 2 ;;
-w|--wait) TR_SETTLE_SEC="$2"; shift 2 ;;
--no-wait) TR_NO_WAIT=1; shift ;;
-d|--debug) DEBUG_MODE=1; shift ;;
-n|--dry-run) TR_DRY_RUN=1; shift ;;
-h|--help) blanton_tr518_help; return 0 ;;
*) _tr_err "unknown option '$1'"; return 1 ;;
esac
done
case "$sub" in
start) blanton_tr518_start ;;
stop) blanton_tr518_stop ;;
help|-h|--help) blanton_tr518_help ;;
*) _tr_err "unknown subcommand '$sub'"; blanton_tr518_help; return 1 ;;
esac
}
# Run when executed, define-only when sourced (same as the other blanton_*.sh).
if [ "${BASH_SOURCE[0]}" = "$0" ]; then
blanton_tr518 "$@"
fi
src/Script_ABC_Blanton/Blanton_Script/blanton_traffic_linespeed.sh
+287 -8
View File
@@ -74,6 +74,44 @@
# Same fix applied to the "# FAIL ..." delta line (%+d ->
# %+.0f), which would otherwise saturate when a dead port
# makes the delta the size of the whole counter.
# V0.5.0 2026-08-28 Add: the 100G uplink (ce0, VLAN 138) joins init / start /
# stop / report, from tools/100G_Traffic.txt.
# ce0 is NOT a loopback pair: there is one per unit and the
# two are cabled to each other, so its verdict is a
# CROSS-UNIT check and cannot be decided from one unit's
# counters. It therefore appears as the LAST row of each
# unit table with the verdict DEFER, and is judged in a new
# summary printed once at the very bottom, after every
# unit -- which also carries the per-unit PASS/FAIL/NA
# totals ("all Results" in one place).
# TL_CE_MODE=cross (default) | self picks the topology;
# it is a plain editable flag, NOT auto-detected, because
# a non-zero RX cannot tell the two cablings apart.
# With only one unit selected the summary reports
# UNDECIDED (exit 3) instead of guessing.
# TL_CE_ENABLE=0 restores the old cd-pairs-only behaviour.
# V0.6.0 2026-08-28 Add: ce0 traffic is now SUSTAINED, not a single burst.
# A cd pair keeps its packets circulating because they
# flood to the partner port; ce0 has no partner and a
# switch will not send a frame back out its ingress port,
# so 'tx 100' was exactly one round trip (TX 100/RX 100)
# and then silence. init now sets an INGRESS MIRROR of ce0
# back to ce0 -- the mirrored copy is not egress-filtered,
# so each packet keeps lapping until stop turns it off.
# init : mirror init; mirror port ce0 Mode=Ingress
# DestPort=ce0; vlan create/add
# stop : mirror port ce0 Mode=Off (FIRST -- this is what
# breaks the loop), then vlan remove
# Bench-verified command set. TL_CE_MIRROR=0 goes back to
# the one-shot burst.
# Change: TL_CE_MODE now defaults to 'self'. 'ps ce' shows
# one ce port per unit and a unit-0-only burst returned on
# unit 0, so the cross-unit reading was wrong.
# V0.5.1 2026-08-28 Add: TL_CE_COUNTER selects which counter judges the ce
# port -- packets (MIB_TPOK/MIB_RPOK, default, same as the
# cd rows) or bytes (MIB_TBYT/MIB_RBYT). The report prints
# which one it used under the table, so a byte figure is
# never mistaken for a packet count next to the cd rows.
# =============================================================================
#
# The VLAN/port table below is copied verbatim from
@@ -145,6 +183,56 @@ TL_DEFAULT_VLAN_PBM="${TL_DEFAULT_VLAN_PBM:-cd}"
# pasted straight from/into a manual "bcmcmd -n 0 -c 'ps <list>'".
TL_PS_PORTS="${TL_PS_PORTS:-1-24,40-96,112-168,184-240,256-259,270-308,310-327,342-380,382-399,414-452,454-471,486-524,526-543,558-565}"
# --- 100G uplink (ce0) ------------------------------------------------------
# The cd pairs above are loopback pairs WITHIN one switch unit (cdN <-> cdN+32).
# ce0 is not a pair: 'ps ce' shows exactly one ce port per unit, and it is looped
# back on itself. Bench-confirmed 2026-08-28 -- a tx burst on unit 0 alone came
# back on unit 0 (TPOK +100 AND RPOK +100), which only happens on a self loop.
#
# TL_CE_MODE=self ce0 loops back on itself (default, matches bench)
# verdict: TX == RX within the unit, decided in its own table
# TL_CE_MODE=cross unit0.ce0 <-> unit1.ce0 cabled together
# verdict: unit0.TX == unit1.RX and unit0.RX == unit1.TX,
# decided in the summary; needs BOTH units
#
# If the bench cabling changes, edit TL_CE_MODE -- it is not auto-detected,
# because "RX happens to be non-zero" cannot tell the two topologies apart.
# Note the two modes agree whenever both units send the same amount, so a wrong
# setting looks fine until something actually breaks: with a self loop read as
# cross, BOTH links dying still leaves unit0.TX == unit1.RX (0 == 0) -> PASS.
TL_CE_ENABLE=${TL_CE_ENABLE:-1} # 0 = skip ce0 entirely (cd pairs only)
TL_CE_VLAN="${TL_CE_VLAN:-138}" # one past the cd range (30..137)
TL_CE_PORT="${TL_CE_PORT:-ce0}" # bcm port name, same on both units
TL_CE_MODE="${TL_CE_MODE:-self}" # cross | self -- see above
# --- Why ce0 needs an ingress mirror -----------------------------------------
# A cd pair sustains itself: the packet floods to the OTHER member, goes out the
# cable, comes back on the partner, floods to the other member again -- forever.
# ce0 has no partner. A switch never forwards a frame back out the port it
# arrived on (source-port knockout), so with ce0 as the only VLAN member the
# returning packet is dropped and one 'tx' burst is exactly one round trip:
# TX 100, RX 100, done. That measures the link, it does not load it.
#
# An INGRESS MIRROR of ce0 back to ce0 is the way round it: the mirrored copy is
# not subject to the egress filter, so it does leave the port it came in on.
# Each circulating packet makes exactly one copy per lap -- 1:1, not amplifying,
# so the load is set by how many packets 'start' injects, and it runs until
# 'stop' turns the mirror off.
#
# ⚠️ The loop does NOT stop on its own. Unlike the cd pairs, removing the VLAN
# membership is not enough -- 'stop' must set Mode=Off, or the port keeps
# running flat out with nothing in 'show interfaces status' to hint at it.
# ⚠️ 'mirror init' resets the mirror module. Anything else using mirroring on
# this box (ERSPAN, monitoring) is cleared. Set TL_CE_MIRROR=0 to skip it.
TL_CE_MIRROR=${TL_CE_MIRROR:-1} # 0 = no mirror (one-shot burst, as before)
# Which counter the ce port is judged on. Packets by default, the same counter
# as the cd pairs, so every row of the table is in the same unit.
# packets -> MIB_TPOK / MIB_RPOK (default, same as the cd rows)
# bytes -> MIB_TBYT / MIB_RBYT
# Either way the report prints which one it used under the table.
TL_CE_COUNTER="${TL_CE_COUNTER:-packets}"
# --- report (pair cross-check) defaults -------------------------------------
TL_TOLERANCE="${TL_TOLERANCE:-0}" # allowed |delta| in packets before FAIL
TL_LOG_DIR="${TL_LOG_DIR:-/tmp}" # where the raw 'show c' capture is kept
@@ -378,6 +466,21 @@ traffic_linespeed_init() {
_tl_bcm_q "$unit" "vlan add $vid pbm=$pa,$pb" || fail=$((fail+1))
n=$((n+1))
done 3<<< "$TL_PAIRS"
# 100G uplink: one port, its own VLAN, added last so it is easy to skip.
# The mirror goes up BEFORE the VLAN so the loop is armed the moment the
# first packet is injected.
if [ "$TL_CE_ENABLE" = "1" ]; then
if [ "$TL_CE_MIRROR" = "1" ]; then
_tl_bcm_q "$unit" "mirror init" || fail=$((fail+1))
_tl_bcm_q "$unit" "mirror port $TL_CE_PORT Mode=Ingress DestPort=$TL_CE_PORT" \
|| fail=$((fail+1))
fi
_tl_bcm_run "$unit" "$TL_BENIGN_CREATE" "vlan create $TL_CE_VLAN"; rc=$?
[ "$rc" = "1" ] && fail=$((fail+1))
[ "$rc" = "2" ] && exist=$((exist+1))
_tl_bcm_q "$unit" "vlan add $TL_CE_VLAN pbm=$TL_CE_PORT" || fail=$((fail+1))
n=$((n+1))
fi
if [ "$fail" -eq 0 ]; then
_tl_ok "unit $unit: $n VLANs configured$([ "$exist" -gt 0 ] && echo " ($exist already existed)"), port pairs added"
else
@@ -421,8 +524,14 @@ traffic_linespeed_start() {
_tl_bcm_q "$unit" "tx $TL_TX_COUNT length=$TL_TX_LENGTH VLantag=$vid" || fail=$((fail+1))
n=$((n+1))
done 3<<< "$TL_PAIRS"
if [ "$TL_CE_ENABLE" = "1" ]; then
_tl_bcm_q "$unit" "tx $TL_TX_COUNT length=$TL_TX_LENGTH VLantag=$TL_CE_VLAN" || fail=$((fail+1))
n=$((n+1))
fi
if [ "$fail" -eq 0 ]; then
_tl_ok "unit $unit: $n bursts sent ($((n * TL_TX_COUNT)) packets, ${TL_TX_LENGTH}B each)"
[ "$TL_CE_ENABLE" = "1" ] && [ "$TL_CE_MIRROR" = "1" ] && \
_tl_info "unit $unit: ${TL_CE_PORT} is now circulating and will keep running until 'stop'"
else
_tl_warn "unit $unit: $n bursts attempted, $fail failed"
fi
@@ -446,6 +555,25 @@ traffic_linespeed_stop() {
fi
n=$((n+1))
done 3<<< "$TL_PAIRS"
if [ "$TL_CE_ENABLE" = "1" ]; then
# Mirror OFF first: that is what actually breaks the loop. Removing
# the VLAN membership does not -- the mirrored copy never consulted
# the VLAN in the first place.
if [ "$TL_CE_MIRROR" = "1" ]; then
_tl_bcm_q "$unit" "mirror port $TL_CE_PORT Mode=Off" || {
fail=$((fail+1))
_tl_err "unit $unit: ${TL_CE_PORT} mirror still ON -- the loop is STILL RUNNING"
_tl_err " stop it by hand: ${BCMCMD_CMD} -n $unit -c 'mirror port $TL_CE_PORT Mode=Off'"
}
fi
_tl_bcm_run "$unit" "$TL_BENIGN_REMOVE" "vlan remove $TL_CE_VLAN pbm=$TL_CE_PORT"
[ "$?" = "1" ] && fail=$((fail+1))
if [ "$TL_DESTROY" = "1" ]; then
_tl_bcm_run "$unit" "$TL_BENIGN_REMOVE" "vlan destroy $TL_CE_VLAN"
[ "$?" = "1" ] && fail=$((fail+1))
fi
n=$((n+1))
fi
if [ "$fail" -eq 0 ]; then
_tl_ok "unit $unit: $n VLANs cleaned$([ "$TL_DESTROY" = "1" ] && echo " and destroyed")"
else
@@ -480,8 +608,11 @@ traffic_linespeed_ps() {
# (a cd port absent from 'show c' means the counter is zero or the
# console scrolled -- cross-check with 'ps' before blaming the port).
# _tl_pair_report <logfile> -> 0 all PASS, 2 any FAIL/NA, 1 parse error
# _tl_pair_report <logfile> [side_file]
# side_file (optional) receives machine-readable lines for the cross-unit
# summary: SUM <npass> <nfail> <nna> CE <tx> <rx> (CE omitted if absent)
_tl_pair_report() {
local log="$1" color=0
local log="$1" side="${2:-/dev/null}" color=0
# PASS green / FAIL red / NA yellow. auto = only when stdout is a terminal,
# so redirecting to a file or piping into grep/diff stays plain text.
case "$TL_COLOR" in
@@ -497,7 +628,11 @@ _tl_pair_report() {
-v WITHPORT="$TL_REPORT_WITHPORT" \
-v QUIET="$TL_REPORT_QUIET" \
-v TSV="$TL_REPORT_TSV" \
-v COLOR="$color" '
-v COLOR="$color" \
-v CEPORT="$([ "$TL_CE_ENABLE" = "1" ] && echo "$TL_CE_PORT")" \
-v CEMODE="$TL_CE_MODE" \
-v CECOUNTER="$TL_CE_COUNTER" \
-v SIDE="$side" '
function grp(v, s,out,l,i) {
s = sprintf("%.0f", v)
if (!GROUPED) return s
@@ -513,8 +648,9 @@ _tl_pair_report() {
# colour the verdict token: PASS green, FAIL red, NA yellow
function vc(v) {
if (!COLOR) return v
if (v == "PASS") return "\033[32m" v "\033[0m"
if (v == "FAIL") return "\033[31m" v "\033[0m"
if (v == "PASS") return "\033[32m" v "\033[0m"
if (v == "FAIL") return "\033[31m" v "\033[0m"
if (v == "DEFER") return "\033[36m" v "\033[0m" # cyan: judged in the summary
return "\033[33m" v "\033[0m"
}
function redl(s) { return COLOR ? "\033[31m" s "\033[0m" : s }
@@ -535,11 +671,12 @@ _tl_pair_report() {
if (idx == 0) next
s = substr($0, idx)
kind = substr(s, 5, 4)
if (kind != "TPOK" && kind != "RPOK") next
# POK = packets (the cd pairs), BYT = bytes (used for the ce port)
if (kind != "TPOK" && kind != "RPOK" && kind != "TBYT" && kind != "RBYT") next
p1 = index(s, "."); p2 = index(s, "("); p3 = index(s, ")"); p4 = index(s, ":")
if (p1 == 0 || p2 == 0 || p3 == 0 || p4 == 0 || p2 < p1 || p4 < p3) next
cd = substr(s, p1 + 1, p2 - p1 - 1)
if (cd !~ /^cd[0-9]+$/) next
if (cd !~ /^(cd|ce)[0-9]+$/) next
lp = substr(s, p2 + 1, p3 - p2 - 1)
val = substr(s, p4 + 1)
sub(/^[ \t]+/, "", val)
@@ -547,7 +684,10 @@ _tl_pair_report() {
sub(/[ \t].*$/, "", val)
gsub(/,/, "", val)
LP[cd] = lp
if (kind == "TPOK") { TX[cd] = val + 0; HTX[cd] = 1 } else { RX[cd] = val + 0; HRX[cd] = 1 }
if (kind == "TPOK") { TX[cd] = val + 0; HTX[cd] = 1 }
else if (kind == "RPOK") { RX[cd] = val + 0; HRX[cd] = 1 }
else if (kind == "TBYT") { TXB[cd] = val + 0; HTXB[cd] = 1 }
else { RXB[cd] = val + 0; HRXB[cd] = 1 }
seen++
}
END {
@@ -580,6 +720,41 @@ _tl_pair_report() {
nrow++; CELL[nrow,1] = pname(b); CELL[nrow,2] = tb; CELL[nrow,3] = rb; CELL[nrow,4] = v
}
# --- 100G uplink, appended LAST so it sits at the bottom of the table ---
# It is a single port, not a pair, so it gets one row. In cross mode the
# verdict needs the OTHER unit counters and is decided in the summary;
# DEFER says "not judged here", which is not the same as NA ("no data").
cev = ""; ceunit = ""
if (CEPORT != "") {
if (CECOUNTER == "packets") {
ceunit = "packets"
haveT = (CEPORT in HTX); haveR = (CEPORT in HRX)
cetv = TX[CEPORT]; cerv = RX[CEPORT]
} else {
ceunit = "bytes"
haveT = (CEPORT in HTXB); haveR = (CEPORT in HRXB)
cetv = TXB[CEPORT]; cerv = RXB[CEPORT]
}
cet = haveT ? grp(cetv) : MISSING
cer = haveR ? grp(cerv) : MISSING
if (!(haveT && haveR)) {
cev = "NA"; nna++
} else if (CEMODE == "self") {
if (absd(cetv - cerv) <= TOL + 0) { cev = "PASS"; npass++ }
else {
cev = "FAIL"; nfail++
FL[++nf] = sprintf("# FAIL %s: TX-RX=%+.0f %s (self loopback)", \
CEPORT, cetv - cerv, ceunit)
}
} else {
cev = "DEFER"
}
nrep++
nrow++; CELL[nrow,1] = pname(CEPORT); CELL[nrow,2] = cet; CELL[nrow,3] = cer; CELL[nrow,4] = cev
if (SIDE != "" && SIDE != "/dev/null" && haveT && haveR)
printf "CE %.0f %.0f\n", cetv, cerv > SIDE
}
if (TSV) {
line = HDR[1]
for (c = 2; c <= NC; c++) line = line "\t" HDR[c]
@@ -616,13 +791,103 @@ _tl_pair_report() {
printf "# pairs reported : %d\n", nrep
printf "# %s %d %s %d %s %d (tolerance %d)\n", \
vc("PASS"), npass, vc("FAIL"), nfail, vc("NA"), nna, TOL + 0
if (CEPORT != "" && ceunit != "")
printf "# %s TX/RX are %s (MIB_%s/MIB_%s); the cd rows are packets\n", \
CEPORT, ceunit, \
(ceunit == "bytes" ? "TBYT" : "TPOK"), \
(ceunit == "bytes" ? "RBYT" : "RPOK")
if (cev == "DEFER")
printf "# %s is judged across units -- see the summary at the end\n", CEPORT
# every NA pair is a visible row -> no long "no counters" list needed
for (i = 1; i <= nf; i++) print redl(FL[i])
}
if (SIDE != "" && SIDE != "/dev/null")
printf "SUM %d %d %d\n", npass, nfail, nna > SIDE
exit (nfail || nna) ? 2 : 0
}' "$log"
}
# _tl_ce_summary -- the cross-unit ce0 verdict + the per-unit totals.
# Printed once, at the very bottom, after every unit's table.
# Args: <stamp> (side files are $TL_LOG_DIR/tlside_unit<N>_<stamp>)
# Returns 0 all PASS, 2 any FAIL/NA, 3 could not be decided.
_tl_ce_summary() {
local stamp="$1" unit side c g y n r
c=$'\033[36m'; g=$'\033[32m'; y=$'\033[33m'; r=$'\033[31m'; n=$'\033[0m'
case "$TL_COLOR" in
never|0|no) c=""; g=""; y=""; r=""; n="" ;;
always|1|yes) ;;
*) [ -t 1 ] || { c=""; g=""; y=""; r=""; n=""; } ;;
esac
local u tx rx pass fail na have=""
local -A CETX CERX UPASS UFAIL UNA
for unit in $TL_UNITS; do
side="$TL_LOG_DIR/tlside_unit${unit}_${stamp}"
[ -r "$side" ] || continue
while read -r tag a b cc; do
case "$tag" in
CE) CETX[$unit]="$a"; CERX[$unit]="$b" ;;
SUM) UPASS[$unit]="$a"; UFAIL[$unit]="$b"; UNA[$unit]="$cc" ;;
esac
done < "$side"
have="$have $unit"
done
echo ""
echo "===== summary : all units ====="
printf '%-8s %8s %8s %8s %s\n' "Unit" "PASS" "FAIL" "NA" "RESULT"
local worst=0 v
for unit in $have; do
pass="${UPASS[$unit]:-0}"; fail="${UFAIL[$unit]:-0}"; na="${UNA[$unit]:-0}"
if [ "$fail" -gt 0 ] || [ "$na" -gt 0 ]; then v="${r}FAIL${n}"; worst=2
else v="${g}PASS${n}"; fi
printf '%-8s %8s %8s %8s %b\n' "unit $unit" "$pass" "$fail" "$na" "$v"
done
[ "$TL_CE_ENABLE" = "1" ] || { echo ""; return "$worst"; }
echo ""
echo "----- ${TL_CE_PORT} (100G uplink, VLAN ${TL_CE_VLAN}, mode=${TL_CE_MODE}, counter=${TL_CE_COUNTER}) -----"
if [ "$TL_CE_MODE" != "cross" ]; then
echo "# mode=self: the verdict is in each unit's table above"
echo ""
return "$worst"
fi
# cross mode needs both units' counters
if [ -z "${CETX[0]}" ] || [ -z "${CETX[1]}" ]; then
printf '%b\n' "${y}UNDECIDED${n} ${TL_CE_PORT} is a cross-unit check and needs unit 0 AND unit 1;"
echo " this run had TL_UNITS=\"$TL_UNITS\" (counters seen for:${have:-none})."
echo " Re-run with -u all, or set TL_CE_MODE=self if the cabling is a self loopback."
echo ""
[ "$worst" -lt 3 ] && worst=3
return "$worst"
fi
local cu="bytes"; [ "$TL_CE_COUNTER" = "packets" ] && cu="packets"
printf '%-22s %18s %18s\n' "Direction" "TX ($cu)" "RX ($cu)"
printf '%-22s %18s %18s\n' "unit0.${TL_CE_PORT}" "${CETX[0]}" "${CERX[0]}"
printf '%-22s %18s %18s\n' "unit1.${TL_CE_PORT}" "${CETX[1]}" "${CERX[1]}"
local d1 d2 v1 v2
d1=$(awk -v a="${CETX[0]}" -v b="${CERX[1]}" 'BEGIN{printf "%.0f", a-b}')
d2=$(awk -v a="${CETX[1]}" -v b="${CERX[0]}" 'BEGIN{printf "%.0f", a-b}')
v1=$(awk -v d="$d1" -v t="$TL_TOLERANCE" 'BEGIN{print (d<0?-d:d)<=t ? "PASS" : "FAIL"}')
v2=$(awk -v d="$d2" -v t="$TL_TOLERANCE" 'BEGIN{print (d<0?-d:d)<=t ? "PASS" : "FAIL"}')
echo ""
printf 'unit0.TX -> unit1.RX delta %+d %b\n' "$d1" "$([ "$v1" = PASS ] && echo "${g}PASS${n}" || echo "${r}FAIL${n}")"
printf 'unit1.TX -> unit0.RX delta %+d %b\n' "$d2" "$([ "$v2" = PASS ] && echo "${g}PASS${n}" || echo "${r}FAIL${n}")"
if [ "$v1" = PASS ] && [ "$v2" = PASS ]; then
printf '%-22s %b\n' "${TL_CE_PORT} RESULT" "${g}PASS${n}"
else
printf '%-22s %b\n' "${TL_CE_PORT} RESULT" "${r}FAIL${n}"
worst=2
fi
echo ""
return "$worst"
}
# traffic_linespeed_report -- 'show c' per unit, keep the raw log, render the table
traffic_linespeed_report() {
local unit log rc worst=0 stamp
@@ -641,14 +906,17 @@ traffic_linespeed_report() {
fi
stamp=$(date +%Y%m%d_%H%M%S 2>/dev/null || echo now)
local side
for unit in $TL_UNITS; do
log="$TL_LOG_DIR/showc_unit${unit}_${stamp}.log"
side="$TL_LOG_DIR/tlside_unit${unit}_${stamp}"
: > "$side"
if ! _tl_bcm "$unit" "show c" > "$log" 2>&1; then
_tl_err "unit $unit: show c failed (see $log)"; return 1
fi
[ "$TL_REPORT_RAW" = "1" ] && { echo "----- unit $unit : raw show c -----"; cat "$log"; }
echo "===== unit $unit : loopback pair counter report (raw: $log) ====="
_tl_pair_report "$log"; rc=$?
_tl_pair_report "$log" "$side"; rc=$?
[ "$rc" -gt "$worst" ] && worst=$rc
case "$rc" in
0) _tl_ok "unit $unit: all pairs PASS" ;;
@@ -656,6 +924,12 @@ traffic_linespeed_report() {
*) _tl_err "unit $unit: report parse error" ;;
esac
done
# Summary last, after every unit's table -- this is where the cross-unit
# ce0 verdict can finally be decided.
_tl_ce_summary "$stamp"; rc=$?
[ "$rc" -gt "$worst" ] && worst=$rc
rm -f "$TL_LOG_DIR"/tlside_unit*_"${stamp}"
return "$worst"
}
@@ -677,6 +951,8 @@ blanton_traffic_linespeed_help() {
echo ""
echo -e " Units: \033[36m$TL_UNITS\033[0m tx: \033[36m$TL_TX_COUNT pkt x ${TL_TX_LENGTH}B\033[0m"
echo -e " VLANs: 30..137 ($(_tl_pair_count) loopback pairs, cdN <-> cdN+32)"
[ "$TL_CE_ENABLE" = "1" ] && \
echo -e " 100G : VLAN \033[36m$TL_CE_VLAN\033[0m port \033[36m$TL_CE_PORT\033[0m mode=\033[36m$TL_CE_MODE\033[0m (cross = unit0.$TL_CE_PORT <-> unit1.$TL_CE_PORT cabled)"
echo ""
echo -e "\033[1mSubcommands\033[0m"
echo -e " \033[33minit\033[0m step 1 vlan remove 1 pbm=cd, vlan create/add each pair"
@@ -684,8 +960,11 @@ blanton_traffic_linespeed_help() {
echo -e " \033[33mshow\033[0m step 3/6 show c (run before and after traffic)"
echo -e " \033[33mstart\033[0m step 4 tx <count> length=<len> VLantag=<vid> per VLAN"
echo -e " \033[33mstop\033[0m step 5 vlan remove <vid> pbm=<pair> [--destroy also destroys]"
[ "$TL_CE_ENABLE" = "1" ] && [ "$TL_CE_MIRROR" = "1" ] && \
echo -e " \033[33m^ also turns the $TL_CE_PORT mirror off -- without it the 100G loop keeps running\033[0m"
echo -e " \033[33mps\033[0m ps <portlist> port status (link/speed) of the cabled ports"
echo -e " \033[33mreport\033[0m show c -> per-port TX/RX per pair + PASS/FAIL/NA cross-check"
echo -e " ${TL_CE_PORT} is the last row (DEFER), judged in the summary at the bottom"
echo -e " \033[33mrun\033[0m ps -> init -> clear -> start -> report"
echo -e " \033[33mhelp\033[0m"
echo ""