xref: /openbmc/linux/samples/pktgen/functions.sh (revision a27ac539)
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
8set -o errexit
9
10## -- General shell logging cmds --
11function err() {
12    local exitcode=$1
13    shift
14    echo "ERROR: $@" >&2
15    exit $exitcode
16}
17
18function warn() {
19    echo "WARN : $@" >&2
20}
21
22function info() {
23    if [[ -n "$VERBOSE" ]]; then
24	echo "INFO : $@" >&2
25    fi
26}
27
28## -- Pktgen proc config commands -- ##
29export 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
39function pg_ctrl() {
40    local proc_file="pgctrl"
41    proc_cmd ${proc_file} "$@"
42}
43
44function pg_thread() {
45    local thread=$1
46    local proc_file="kpktgend_${thread}"
47    shift
48    proc_cmd ${proc_file} "$@"
49}
50
51function 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.
60function 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
93function 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
111function 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
121function 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
135function 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
146function 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.
162function 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)
178function 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
182function 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.
209function 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
249function validate_addr6() { validate_addr $@ ; }
250
251# Given a single IP(v4/v6) or CIDR, return minimum and maximum IP addr.
252function 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
306function parse_addr6() { parse_addr $@ ; }
307
308# Given a single or range of port(s), return minimum and maximum port number.
309function 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.
325function 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}
341