samples/pktgen/functions.sh

   1 #
   2 # Common functions used by pktgen scripts
   3 #  - Depending on bash 3 (or higher) syntax
   4 #
   5 # Author: Jesper Dangaaard Brouer
   6 # License: GPL
   7
   8 set -o errexit
   9
  10 ## -- General shell logging cmds --
  11 function err() {
  12     local exitcode=$1
  13     shift
  14     echo "ERROR: $@" >&2
  15     exit $exitcode
  16 }
  17
  18 function warn() {
  19     echo "WARN : $@" >&2
  20 }
  21
  22 function info() {
  23     if [[ -n "$VERBOSE" ]]; then
  24         echo "INFO : $@" >&2
  25     fi
  26 }
  27
  28 ## -- Pktgen proc config commands -- ##
  29 export PROC_DIR=/proc/net/pktgen
  30 #
  31 # Three different shell functions for configuring the different
  32 # components of pktgen:
  33 #   pg_ctrl(), pg_thread() and pg_set().
  34 #
  35 # These functions correspond to pktgens different components.
  36 # * pg_ctrl()   control "pgctrl" (/proc/net/pktgen/pgctrl)
  37 # * pg_thread() control the kernel threads and binding to devices
  38 # * pg_set()    control setup of individual devices
  39 function pg_ctrl() {
  40     local proc_file="pgctrl"
  41     proc_cmd ${proc_file} "$@"
  42 }
  43
  44 function pg_thread() {
  45     local thread=$1
  46     local proc_file="kpktgend_${thread}"
  47     shift
  48     proc_cmd ${proc_file} "$@"
  49 }
  50
  51 function pg_set() {
  52     local dev=$1
  53     local proc_file="$dev"
  54     shift
  55     proc_cmd ${proc_file} "$@"
  56 }
  57
  58 # More generic replacement for pgset(), that does not depend on global
  59 # variable for proc file.
  60 function proc_cmd() {
  61     local result
  62     local proc_file=$1
  63     local status=0
  64     # after shift, the remaining args are contained in $@
  65     shift
  66     local proc_ctrl=${PROC_DIR}/$proc_file
  67     if [[ ! -e "$proc_ctrl" ]]; then
  68         err 3 "proc file:$proc_ctrl does not exists (dev added to thread?)"
  69     else
  70         if [[ ! -w "$proc_ctrl" ]]; then
  71             err 4 "proc file:$proc_ctrl not writable, not root?!"
  72         fi
  73     fi
  74
  75     if [[ "$DEBUG" == "yes" ]]; then
  76         echo "cmd: $@ > $proc_ctrl"
  77     fi
  78     # Quoting of "$@" is important for space expansion
  79     echo "$@" > "$proc_ctrl" || status=$?
  80
  81     if [[ "$proc_file" != "pgctrl" ]]; then
  82         result=$(grep "Result: OK:" $proc_ctrl) || true
  83         if [[ "$result" == "" ]]; then
  84             grep "Result:" $proc_ctrl >&2
  85         fi
  86     fi
  87     if (( $status != 0 )); then
  88         err 5 "Write error($status) occurred cmd: \"$@ > $proc_ctrl\""
  89     fi
  90 }
  91
  92 # Old obsolete "pgset" function, with slightly improved err handling
  93 function pgset() {
  94     local result
  95
  96     if [[ "$DEBUG" == "yes" ]]; then
  97         echo "cmd: $1 > $PGDEV"
  98     fi
  99     echo $1 > $PGDEV
 100     local status=$?
 101
 102     result=`cat $PGDEV | fgrep "Result: OK:"`
 103     if [[ "$result" == "" ]]; then
 104          cat $PGDEV | fgrep Result:
 105     fi
 106     if (( $status != 0 )); then
 107         err 5 "Write error($status) occurred cmd: \"$1 > $PGDEV\""
 108     fi
 109 }
 110
 111 function trap_exit()
 112 {
 113     # Cleanup pktgen setup on exit if thats not "append mode"
 114     if [[ -z "$APPEND" ]] && [[ $EUID -eq 0 ]]; then
 115         trap 'pg_ctrl "reset"' EXIT
 116     fi
 117 }
 118
 119 ## -- General shell tricks --
 120
 121 function root_check_run_with_sudo() {
 122     # Trick so, program can be run as normal user, will just use "sudo"
 123     #  call as root_check_run_as_sudo "$@"
 124     if [ "$EUID" -ne 0 ]; then
 125         if [ -x $0 ]; then # Directly executable use sudo
 126             info "Not root, running with sudo"
 127             sudo -E "$0" "$@"
 128             exit $?
 129         fi
 130         err 4 "cannot perform sudo run of $0"
 131     fi
 132 }
 133
 134 # Exact input device's NUMA node info
 135 function get_iface_node()
 136 {
 137     local node=$(</sys/class/net/$1/device/numa_node)
 138     if [[ $node == -1 ]]; then
 139         echo 0
 140     else
 141         echo $node
 142     fi
 143 }
 144
 145 # Given an Dev/iface, get its queues' irq numbers
 146 function get_iface_irqs()
 147 {
 148         local IFACE=$1
 149         local queues="${IFACE}-.*TxRx"
 150
 151         irqs=$(grep "$queues" /proc/interrupts | cut -f1 -d:)
 152         [ -z "$irqs" ] && irqs=$(grep $IFACE /proc/interrupts | cut -f1 -d:)
 153         [ -z "$irqs" ] && irqs=$(for i in `ls -Ux /sys/class/net/$IFACE/device/msi_irqs` ;\
 154             do grep "$i:.*TxRx" /proc/interrupts | grep -v fdir | cut -f 1 -d : ;\
 155             done)
 156         [ -z "$irqs" ] && err 3 "Could not find interrupts for $IFACE"
 157
 158         echo $irqs
 159 }
 160
 161 # Given a NUMA node, return cpu ids belonging to it.
 162 function get_node_cpus()
 163 {
 164         local node=$1
 165         local node_cpu_list
 166         local node_cpu_range_list=`cut -f1- -d, --output-delimiter=" " \
 167                           /sys/devices/system/node/node$node/cpulist`
 168
 169         for cpu_range in $node_cpu_range_list
 170         do
 171             node_cpu_list="$node_cpu_list "`seq -s " " ${cpu_range//-/ }`
 172         done
 173
 174         echo $node_cpu_list
 175 }
 176
 177 # Check $1 is in between $2, $3 ($2 <= $1 <= $3)
 178 function in_between() { [[ ($1 -ge $2) && ($1 -le $3) ]] ; }
 179
 180 # Extend shrunken IPv6 address.
 181 # fe80::42:bcff:fe84:e10a => fe80:0:0:0:42:bcff:fe84:e10a
 182 function extend_addr6()
 183 {
 184     local addr=$1
 185     local sep=: sep2=::
 186     local sep_cnt=$(tr -cd $sep <<< $1 | wc -c)
 187     local shrink
 188
 189     # separator count should be (2 <= $sep_cnt <= 7)
 190     if ! (in_between $sep_cnt 2 7); then
 191         err 5 "Invalid IP6 address: $1"
 192     fi
 193
 194     # if shrink '::' occurs multiple, it's malformed.
 195     shrink=( $(grep -E -o "$sep{2,}" <<< $addr) )
 196     if [[ ${#shrink[@]} -ne 0 ]]; then
 197         if [[ ${#shrink[@]} -gt 1 || ( ${shrink[0]} != $sep2 ) ]]; then
 198             err 5 "Invalid IP6 address: $1"
 199         fi
 200     fi
 201
 202     # add 0 at begin & end, and extend addr by adding :0
 203     [[ ${addr:0:1} == $sep ]] && addr=0${addr}
 204     [[ ${addr: -1} == $sep ]] && addr=${addr}0
 205     echo "${addr/$sep2/$(printf ':0%.s' $(seq $[8-sep_cnt])):}"
 206 }
 207
 208 # Given a single IP(v4/v6) address, whether it is valid.
 209 function validate_addr()
 210 {
 211     # check function is called with (funcname)6
 212     [[ ${FUNCNAME[1]: -1} == 6 ]] && local IP6=6
 213     local bitlen=$[ IP6 ? 128 : 32 ]
 214     local len=$[ IP6 ? 8 : 4 ]
 215     local max=$[ 2**(len*2)-1 ]
 216     local net prefix
 217     local addr sep
 218
 219     IFS='/' read net prefix <<< $1
 220     [[ $IP6 ]] && net=$(extend_addr6 $net)
 221
 222     # if prefix exists, check (0 <= $prefix <= $bitlen)
 223     if [[ -n $prefix ]]; then
 224         if ! (in_between $prefix 0 $bitlen); then
 225             err 5 "Invalid prefix: /$prefix"
 226         fi
 227     fi
 228
 229     # set separator for each IP(v4/v6)
 230     [[ $IP6 ]] && sep=: || sep=.
 231     IFS=$sep read -a addr <<< $net
 232
 233     # array length
 234     if [[ ${#addr[@]} != $len ]]; then
 235         err 5 "Invalid IP$IP6 address: $1"
 236     fi
 237
 238     # check each digit (0 <= $digit <= $max)
 239     for digit in "${addr[@]}"; do
 240         [[ $IP6 ]] && digit=$[ 16#$digit ]
 241         if ! (in_between $digit 0 $max); then
 242             err 5 "Invalid IP$IP6 address: $1"
 243         fi
 244     done
 245
 246     return 0
 247 }
 248
 249 function validate_addr6() { validate_addr $@ ; }
 250
 251 # Given a single IP(v4/v6) or CIDR, return minimum and maximum IP addr.
 252 function parse_addr()
 253 {
 254     # check function is called with (funcname)6
 255     [[ ${FUNCNAME[1]: -1} == 6 ]] && local IP6=6
 256     local net prefix
 257     local min_ip max_ip
 258
 259     IFS='/' read net prefix <<< $1
 260     [[ $IP6 ]] && net=$(extend_addr6 $net)
 261
 262     if [[ -z $prefix ]]; then
 263         min_ip=$net
 264         max_ip=$net
 265     else
 266         # defining array for converting Decimal 2 Binary
 267         # 00000000 00000001 00000010 00000011 00000100 ...
 268         local d2b='{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}'
 269         [[ $IP6 ]] && d2b+=$d2b
 270         eval local D2B=($d2b)
 271
 272         local bitlen=$[ IP6 ? 128 : 32 ]
 273         local remain=$[ bitlen-prefix ]
 274         local octet=$[ IP6 ? 16 : 8 ]
 275         local min_mask max_mask
 276         local min max
 277         local ip_bit
 278         local ip sep
 279
 280         # set separator for each IP(v4/v6)
 281         [[ $IP6 ]] && sep=: || sep=.
 282         IFS=$sep read -ra ip <<< $net
 283
 284         min_mask="$(printf '1%.s' $(seq $prefix))$(printf '0%.s' $(seq $remain))"
 285         max_mask="$(printf '0%.s' $(seq $prefix))$(printf '1%.s' $(seq $remain))"
 286
 287         # calculate min/max ip with &,| operator
 288         for i in "${!ip[@]}"; do
 289             digit=$[ IP6 ? 16#${ip[$i]} : ${ip[$i]} ]
 290             ip_bit=${D2B[$digit]}
 291
 292             idx=$[ octet*i ]
 293             min[$i]=$[ 2#$ip_bit & 2#${min_mask:$idx:$octet} ]
 294             max[$i]=$[ 2#$ip_bit | 2#${max_mask:$idx:$octet} ]
 295             [[ $IP6 ]] && { min[$i]=$(printf '%X' ${min[$i]});
 296                             max[$i]=$(printf '%X' ${max[$i]}); }
 297         done
 298
 299         min_ip=$(IFS=$sep; echo "${min[*]}")
 300         max_ip=$(IFS=$sep; echo "${max[*]}")
 301     fi
 302
 303     echo $min_ip $max_ip
 304 }
 305
 306 function parse_addr6() { parse_addr $@ ; }
 307
 308 # Given a single or range of port(s), return minimum and maximum port number.
 309 function parse_ports()
 310 {
 311     local port_str=$1
 312     local port_list
 313     local min_port
 314     local max_port
 315
 316     IFS="-" read -ra port_list <<< $port_str
 317
 318     min_port=${port_list[0]}
 319     max_port=${port_list[1]:-$min_port}
 320
 321     echo $min_port $max_port
 322 }
 323
 324 # Given a minimum and maximum port, verify port number.
 325 function validate_ports()
 326 {
 327     local min_port=$1
 328     local max_port=$2
 329
 330     # 1 <= port <= 65535
 331     if (in_between $min_port 1 65535); then
 332         if (in_between $max_port 1 65535); then
 333             if [[ $min_port -le $max_port ]]; then
 334                 return 0
 335             fi
 336         fi
 337     fi
 338
 339     err 5 "Invalid port(s): $min_port-$max_port"
 340 }