mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-14 22:44:27 +08:00
a27ac53909
Each sample script sources functions.sh before parameters.sh which makes $APPEND undefined when trapping EXIT no matter in append mode or not. Due to this when sample scripts finished they always do "pgctrl reset" which resets pktgen config. So move trap to each script after sourcing parameters.sh and trap EXIT explicitly. Signed-off-by: J.J. Martzki <mars14850@gmail.com> Signed-off-by: David S. Miller <davem@davemloft.net>
341 lines
8.7 KiB
Bash
341 lines
8.7 KiB
Bash
#
|
|
# Common functions used by pktgen scripts
|
|
# - Depending on bash 3 (or higher) syntax
|
|
#
|
|
# Author: Jesper Dangaaard Brouer
|
|
# License: GPL
|
|
|
|
set -o errexit
|
|
|
|
## -- General shell logging cmds --
|
|
function err() {
|
|
local exitcode=$1
|
|
shift
|
|
echo "ERROR: $@" >&2
|
|
exit $exitcode
|
|
}
|
|
|
|
function warn() {
|
|
echo "WARN : $@" >&2
|
|
}
|
|
|
|
function info() {
|
|
if [[ -n "$VERBOSE" ]]; then
|
|
echo "INFO : $@" >&2
|
|
fi
|
|
}
|
|
|
|
## -- Pktgen proc config commands -- ##
|
|
export PROC_DIR=/proc/net/pktgen
|
|
#
|
|
# Three different shell functions for configuring the different
|
|
# components of pktgen:
|
|
# pg_ctrl(), pg_thread() and pg_set().
|
|
#
|
|
# These functions correspond to pktgens different components.
|
|
# * pg_ctrl() control "pgctrl" (/proc/net/pktgen/pgctrl)
|
|
# * pg_thread() control the kernel threads and binding to devices
|
|
# * pg_set() control setup of individual devices
|
|
function pg_ctrl() {
|
|
local proc_file="pgctrl"
|
|
proc_cmd ${proc_file} "$@"
|
|
}
|
|
|
|
function pg_thread() {
|
|
local thread=$1
|
|
local proc_file="kpktgend_${thread}"
|
|
shift
|
|
proc_cmd ${proc_file} "$@"
|
|
}
|
|
|
|
function pg_set() {
|
|
local dev=$1
|
|
local proc_file="$dev"
|
|
shift
|
|
proc_cmd ${proc_file} "$@"
|
|
}
|
|
|
|
# More generic replacement for pgset(), that does not depend on global
|
|
# variable for proc file.
|
|
function proc_cmd() {
|
|
local result
|
|
local proc_file=$1
|
|
local status=0
|
|
# after shift, the remaining args are contained in $@
|
|
shift
|
|
local proc_ctrl=${PROC_DIR}/$proc_file
|
|
if [[ ! -e "$proc_ctrl" ]]; then
|
|
err 3 "proc file:$proc_ctrl does not exists (dev added to thread?)"
|
|
else
|
|
if [[ ! -w "$proc_ctrl" ]]; then
|
|
err 4 "proc file:$proc_ctrl not writable, not root?!"
|
|
fi
|
|
fi
|
|
|
|
if [[ "$DEBUG" == "yes" ]]; then
|
|
echo "cmd: $@ > $proc_ctrl"
|
|
fi
|
|
# Quoting of "$@" is important for space expansion
|
|
echo "$@" > "$proc_ctrl" || status=$?
|
|
|
|
if [[ "$proc_file" != "pgctrl" ]]; then
|
|
result=$(grep "Result: OK:" $proc_ctrl) || true
|
|
if [[ "$result" == "" ]]; then
|
|
grep "Result:" $proc_ctrl >&2
|
|
fi
|
|
fi
|
|
if (( $status != 0 )); then
|
|
err 5 "Write error($status) occurred cmd: \"$@ > $proc_ctrl\""
|
|
fi
|
|
}
|
|
|
|
# Old obsolete "pgset" function, with slightly improved err handling
|
|
function pgset() {
|
|
local result
|
|
|
|
if [[ "$DEBUG" == "yes" ]]; then
|
|
echo "cmd: $1 > $PGDEV"
|
|
fi
|
|
echo $1 > $PGDEV
|
|
local status=$?
|
|
|
|
result=`cat $PGDEV | fgrep "Result: OK:"`
|
|
if [[ "$result" == "" ]]; then
|
|
cat $PGDEV | fgrep Result:
|
|
fi
|
|
if (( $status != 0 )); then
|
|
err 5 "Write error($status) occurred cmd: \"$1 > $PGDEV\""
|
|
fi
|
|
}
|
|
|
|
function trap_exit()
|
|
{
|
|
# Cleanup pktgen setup on exit if thats not "append mode"
|
|
if [[ -z "$APPEND" ]] && [[ $EUID -eq 0 ]]; then
|
|
trap 'pg_ctrl "reset"' EXIT
|
|
fi
|
|
}
|
|
|
|
## -- General shell tricks --
|
|
|
|
function root_check_run_with_sudo() {
|
|
# Trick so, program can be run as normal user, will just use "sudo"
|
|
# call as root_check_run_as_sudo "$@"
|
|
if [ "$EUID" -ne 0 ]; then
|
|
if [ -x $0 ]; then # Directly executable use sudo
|
|
info "Not root, running with sudo"
|
|
sudo -E "$0" "$@"
|
|
exit $?
|
|
fi
|
|
err 4 "cannot perform sudo run of $0"
|
|
fi
|
|
}
|
|
|
|
# Exact input device's NUMA node info
|
|
function get_iface_node()
|
|
{
|
|
local node=$(</sys/class/net/$1/device/numa_node)
|
|
if [[ $node == -1 ]]; then
|
|
echo 0
|
|
else
|
|
echo $node
|
|
fi
|
|
}
|
|
|
|
# Given an Dev/iface, get its queues' irq numbers
|
|
function get_iface_irqs()
|
|
{
|
|
local IFACE=$1
|
|
local queues="${IFACE}-.*TxRx"
|
|
|
|
irqs=$(grep "$queues" /proc/interrupts | cut -f1 -d:)
|
|
[ -z "$irqs" ] && irqs=$(grep $IFACE /proc/interrupts | cut -f1 -d:)
|
|
[ -z "$irqs" ] && irqs=$(for i in `ls -Ux /sys/class/net/$IFACE/device/msi_irqs` ;\
|
|
do grep "$i:.*TxRx" /proc/interrupts | grep -v fdir | cut -f 1 -d : ;\
|
|
done)
|
|
[ -z "$irqs" ] && err 3 "Could not find interrupts for $IFACE"
|
|
|
|
echo $irqs
|
|
}
|
|
|
|
# Given a NUMA node, return cpu ids belonging to it.
|
|
function get_node_cpus()
|
|
{
|
|
local node=$1
|
|
local node_cpu_list
|
|
local node_cpu_range_list=`cut -f1- -d, --output-delimiter=" " \
|
|
/sys/devices/system/node/node$node/cpulist`
|
|
|
|
for cpu_range in $node_cpu_range_list
|
|
do
|
|
node_cpu_list="$node_cpu_list "`seq -s " " ${cpu_range//-/ }`
|
|
done
|
|
|
|
echo $node_cpu_list
|
|
}
|
|
|
|
# Check $1 is in between $2, $3 ($2 <= $1 <= $3)
|
|
function in_between() { [[ ($1 -ge $2) && ($1 -le $3) ]] ; }
|
|
|
|
# Extend shrunken IPv6 address.
|
|
# fe80::42:bcff:fe84:e10a => fe80:0:0:0:42:bcff:fe84:e10a
|
|
function extend_addr6()
|
|
{
|
|
local addr=$1
|
|
local sep=: sep2=::
|
|
local sep_cnt=$(tr -cd $sep <<< $1 | wc -c)
|
|
local shrink
|
|
|
|
# separator count should be (2 <= $sep_cnt <= 7)
|
|
if ! (in_between $sep_cnt 2 7); then
|
|
err 5 "Invalid IP6 address: $1"
|
|
fi
|
|
|
|
# if shrink '::' occurs multiple, it's malformed.
|
|
shrink=( $(grep -E -o "$sep{2,}" <<< $addr) )
|
|
if [[ ${#shrink[@]} -ne 0 ]]; then
|
|
if [[ ${#shrink[@]} -gt 1 || ( ${shrink[0]} != $sep2 ) ]]; then
|
|
err 5 "Invalid IP6 address: $1"
|
|
fi
|
|
fi
|
|
|
|
# add 0 at begin & end, and extend addr by adding :0
|
|
[[ ${addr:0:1} == $sep ]] && addr=0${addr}
|
|
[[ ${addr: -1} == $sep ]] && addr=${addr}0
|
|
echo "${addr/$sep2/$(printf ':0%.s' $(seq $[8-sep_cnt])):}"
|
|
}
|
|
|
|
# Given a single IP(v4/v6) address, whether it is valid.
|
|
function validate_addr()
|
|
{
|
|
# check function is called with (funcname)6
|
|
[[ ${FUNCNAME[1]: -1} == 6 ]] && local IP6=6
|
|
local bitlen=$[ IP6 ? 128 : 32 ]
|
|
local len=$[ IP6 ? 8 : 4 ]
|
|
local max=$[ 2**(len*2)-1 ]
|
|
local net prefix
|
|
local addr sep
|
|
|
|
IFS='/' read net prefix <<< $1
|
|
[[ $IP6 ]] && net=$(extend_addr6 $net)
|
|
|
|
# if prefix exists, check (0 <= $prefix <= $bitlen)
|
|
if [[ -n $prefix ]]; then
|
|
if ! (in_between $prefix 0 $bitlen); then
|
|
err 5 "Invalid prefix: /$prefix"
|
|
fi
|
|
fi
|
|
|
|
# set separator for each IP(v4/v6)
|
|
[[ $IP6 ]] && sep=: || sep=.
|
|
IFS=$sep read -a addr <<< $net
|
|
|
|
# array length
|
|
if [[ ${#addr[@]} != $len ]]; then
|
|
err 5 "Invalid IP$IP6 address: $1"
|
|
fi
|
|
|
|
# check each digit (0 <= $digit <= $max)
|
|
for digit in "${addr[@]}"; do
|
|
[[ $IP6 ]] && digit=$[ 16#$digit ]
|
|
if ! (in_between $digit 0 $max); then
|
|
err 5 "Invalid IP$IP6 address: $1"
|
|
fi
|
|
done
|
|
|
|
return 0
|
|
}
|
|
|
|
function validate_addr6() { validate_addr $@ ; }
|
|
|
|
# Given a single IP(v4/v6) or CIDR, return minimum and maximum IP addr.
|
|
function parse_addr()
|
|
{
|
|
# check function is called with (funcname)6
|
|
[[ ${FUNCNAME[1]: -1} == 6 ]] && local IP6=6
|
|
local net prefix
|
|
local min_ip max_ip
|
|
|
|
IFS='/' read net prefix <<< $1
|
|
[[ $IP6 ]] && net=$(extend_addr6 $net)
|
|
|
|
if [[ -z $prefix ]]; then
|
|
min_ip=$net
|
|
max_ip=$net
|
|
else
|
|
# defining array for converting Decimal 2 Binary
|
|
# 00000000 00000001 00000010 00000011 00000100 ...
|
|
local d2b='{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}'
|
|
[[ $IP6 ]] && d2b+=$d2b
|
|
eval local D2B=($d2b)
|
|
|
|
local bitlen=$[ IP6 ? 128 : 32 ]
|
|
local remain=$[ bitlen-prefix ]
|
|
local octet=$[ IP6 ? 16 : 8 ]
|
|
local min_mask max_mask
|
|
local min max
|
|
local ip_bit
|
|
local ip sep
|
|
|
|
# set separator for each IP(v4/v6)
|
|
[[ $IP6 ]] && sep=: || sep=.
|
|
IFS=$sep read -ra ip <<< $net
|
|
|
|
min_mask="$(printf '1%.s' $(seq $prefix))$(printf '0%.s' $(seq $remain))"
|
|
max_mask="$(printf '0%.s' $(seq $prefix))$(printf '1%.s' $(seq $remain))"
|
|
|
|
# calculate min/max ip with &,| operator
|
|
for i in "${!ip[@]}"; do
|
|
digit=$[ IP6 ? 16#${ip[$i]} : ${ip[$i]} ]
|
|
ip_bit=${D2B[$digit]}
|
|
|
|
idx=$[ octet*i ]
|
|
min[$i]=$[ 2#$ip_bit & 2#${min_mask:$idx:$octet} ]
|
|
max[$i]=$[ 2#$ip_bit | 2#${max_mask:$idx:$octet} ]
|
|
[[ $IP6 ]] && { min[$i]=$(printf '%X' ${min[$i]});
|
|
max[$i]=$(printf '%X' ${max[$i]}); }
|
|
done
|
|
|
|
min_ip=$(IFS=$sep; echo "${min[*]}")
|
|
max_ip=$(IFS=$sep; echo "${max[*]}")
|
|
fi
|
|
|
|
echo $min_ip $max_ip
|
|
}
|
|
|
|
function parse_addr6() { parse_addr $@ ; }
|
|
|
|
# Given a single or range of port(s), return minimum and maximum port number.
|
|
function parse_ports()
|
|
{
|
|
local port_str=$1
|
|
local port_list
|
|
local min_port
|
|
local max_port
|
|
|
|
IFS="-" read -ra port_list <<< $port_str
|
|
|
|
min_port=${port_list[0]}
|
|
max_port=${port_list[1]:-$min_port}
|
|
|
|
echo $min_port $max_port
|
|
}
|
|
|
|
# Given a minimum and maximum port, verify port number.
|
|
function validate_ports()
|
|
{
|
|
local min_port=$1
|
|
local max_port=$2
|
|
|
|
# 1 <= port <= 65535
|
|
if (in_between $min_port 1 65535); then
|
|
if (in_between $max_port 1 65535); then
|
|
if [[ $min_port -le $max_port ]]; then
|
|
return 0
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
err 5 "Invalid port(s): $min_port-$max_port"
|
|
}
|