test/vhost: Add helper functions for extracting IRQ data

#  SPDX-License-Identifier: BSD-3-Clause

#  Copyright (C) 2022 Intel Corporation.

#  All rights reserved.

source "$rootdir/test/scheduler/common.sh"

declare -a irqs_counters=()

declare -a irqs_devices=()

declare -a irqs_types=()

declare -a cpus=()

_get_cpus() {

	local state=${1:-online}

	_get_override_cpus || "_get_${state}_cpus"

}

_get_override_cpus() {

	((${#cpus_override[@]} > 0)) || return 1

	fold_list_onto_array cpus "${cpus_override[@]}"

}

_get_online_cpus() {

	fold_list_onto_array cpus $(get_online_cpus)

}

_get_offline_cpus() {

	fold_list_onto_array cpus $(get_offline_cpus)

}

get_all_irqs() {

	local irqs=() s_irqs=()

	irqs=(/proc/irq/+([0-9]))

	irqs=("${irqs[@]##*/}")

	# Sort it

	fold_list_onto_array s_irqs "${irqs[@]}"

	printf '%u\n' "${s_irqs[@]}"

}

check_this_irq() {

	local irq=${1:-0}

	((${#irqs_to_lookup[@]} > 0)) || return 0

	[[ -n ${irqs_to_lookup[irq]} ]]

}

update_irqs_sysfs() {

	local sysroot=${1:-}

	local input=$sysroot/sys/kernel/irq

	[[ -e $input ]] || return 1

	# per_cpu_count holds a list of all cpus, regardless of their state

	_get_cpus online

	_get_cpus offline

	local irq_path

	for irq_path in "$input/"*; do

		irq=${irq_path##*/}

		check_this_irq "$irq" || continue

		IFS="," read -ra cpu_counters < "$irq_path/per_cpu_count"

		for cpu in "${cpus[@]}"; do

			eval "_irq${irq}_cpu${cpu}+=(${cpu_counters[cpu]})"

			eval "_irq${irq}_counter[cpu]=_irq${irq}_cpu${cpu}[@]"

		done

		irqs_counters[irq]="_irq${irq}_counter[@]"

		irqs_devices[irq]=$(< "$irq_path/actions")

		irqs_types[irq]="$(< "$irq_path/chip_name") $(< "$irq_path/hwirq")-$(< "$irq_path/name")"

	done

}

update_irqs_procfs() {

	local input=${1:-/proc/interrupts}

	[[ -e $input ]] || return 1

	# /proc/interrupts shows only online CPUs. Use get_cpus() to get readings for

	# proper CPUs rather than parsing the actual header of the file.

	_get_cpus online

	local counter_idx

	while read -ra irqs; do

		irq=${irqs[0]%:*}

		[[ $irq == +([0-9]) ]] || continue

		check_this_irq "$irq" || continue

		cpu_counters=("${irqs[@]:1:${#cpus[@]}}") counter_idx=0

		for cpu in "${cpus[@]}"; do

			eval "_irq${irq}_cpu${cpu}+=(${cpu_counters[counter_idx++]})"

			eval "_irq${irq}_counter[cpu]=_irq${irq}_cpu${cpu}[@]"

		done

		irqs_counters[irq]="_irq${irq}_counter[@]"

		irqs_devices[irq]=${irqs[*]:${#cpus[@]}+1:2}

		irqs_types[irq]=${irqs[*]:${#cpus[@]}+3}

	done < "$input"

}

update_irqs() {

	local irqs irq

	local cpu cpu_counters=()

	local irqs_to_lookup=()

	fold_list_onto_array irqs_to_lookup "$@"

	update_irqs_sysfs || update_irqs_procfs

}

get_irqs() {

	local irqs=("$@") irq cpu

	local _counters counters counter delta total

	# If cpus[@] are not init, update was not run so nothing to check

	((${#cpus[@]} > 0)) || return 1

	if ((${#irqs[@]} == 0)); then

		irqs=($(get_all_irqs))

	fi

	for irq in "${irqs[@]}"; do

		for cpu in "${cpus[@]}"; do

			[[ -v "_irq${irq}_cpu${cpu}[@]" ]] || continue

			local -n counters="_irq${irq}_cpu${cpu}"

			# keep a separate copy to not touch the main _irq*[]

			_counters=("${counters[@]}") total=0

			if ((${#counters[@]} > 1)); then

				# Enhance output with calculating deltas between each reading

				for ((counter = 0; counter < ${#counters[@]} - 1; counter++)); do

					delta=$((counters[counter + 1] - counters[counter]))

					_counters[counter + 1]="${counters[counter + 1]} (+$delta)"

					: $((total += delta))

				done

			fi

			_counters+=("==$total")

			# Ignore idle irqs unless request from the env tells otherwise

			if [[ -n $SHOW_ALL_IRQS ]] || ((total > 0)); then

				echo "irq$irq->$(get_irq_type "$irq")->$(get_irq_device "$irq")@cpu$cpu:"

				printf '  %s\n' "${_counters[@]}"

			fi

		done

	done

}

get_irq_type() {

	[[ -n ${irqs_types[$1]} ]] || return 1

	echo "${irqs_types[$1]}"

}

get_irq_device() {

	[[ -n ${irqs_devices[$1]} ]] || return 1

	echo "${irqs_devices[$1]}"

}

reset_irqs() {

	irqs_counters=() irqs_devices=() irqs_types=() cpus=()

	unset -v "${!_irq@}"

}

read_irq_cpu_mask() {

	local irq=$1 mask=$2

	[[ -n $irq && -e /proc/irq/$irq || -n $mask ]] || return 1

	# smp_affinity holds a string of comma-separated 32-bit values. Iterate

	# over each dWORD and extract cpus bit by bit. Iterate from the end of

	# the array as that's where the first dWORD is located.

	local smp_affinity

	local bit dword dword_l=32 dword_idx

	local cpus=()

	if [[ -n $mask ]]; then

		IFS="," read -ra smp_affinity <<< "$mask"

	else

		IFS="," read -ra smp_affinity < "/proc/irq/$irq/smp_affinity"

	fi

	smp_affinity=("${smp_affinity[@]/#/0x}")

	for ((dword = ${#smp_affinity[@]} - 1, dword_idx = 0; dword >= 0; dword--, dword_idx++)); do

		bit=-1

		while ((++bit < dword_l)); do

			if ((smp_affinity[dword] & 1 << bit)); then

				cpus[bit + dword_l * dword_idx]=$bit

			fi

		done

	done

	printf '%u\n' "${!cpus[@]}"

}

read_irq_cpu_list() {

	local irq=$1 effective=${2:-0}

	[[ -n $irq && -e /proc/irq/$irq ]] || return 1

	if ((effective)); then

		parse_cpu_list "/proc/irq/$irq/effective_affinity_list"

	else

		parse_cpu_list "/proc/irq/$irq/smp_affinity_list"

	fi

}

build_irq_cpu_mask() {

	local cpu dword_l=32 dword_idx dword idxs

	local _mask=() mask=""

	for cpu; do

		dword_idx=$((cpu / dword_l))

		((_mask[dword_idx] |= 1 << (cpu - dword_l * dword_idx)))

	done

	# Store sorted list of dword indexes that we got

	idxs=("${!_mask[@]}")

	# Fill out all dWORDs starting from the highest (last) dword index

	for ((dword = idxs[-1]; dword >= 0; dword--)); do

		_mask[dword]=$(printf '%08x' "${_mask[dword]}")

		mask=${mask:+$mask,}${_mask[dword]}

	done

	echo "$mask"

}

squash_irq_cpu_mask() {

	local mask

	mask=$(build_irq_cpu_mask "$@")

	# E.g.: 1,32,64,65,77,88,127 -> 0x80000000010020030000000100000002

	# Valid under DPDK

	echo "0x${mask//,/}"

}

unsquash_irq_cpu_mask() {

	# E.g.: 0x80000000010020030000000100000002 -> 80000000,01002003,00000001,00000002

	# 8 is a max number of chars in a dWORD represented in hex.

	local smask=$1 _smask="" smask_l _smask_l

	smask=${smask/0x/} smask_l=$((${#smask} / 8)) _smask_l=$smask_l

	((smask_l == 0)) && echo "$smask" && return 0

	# Put comma at a right index

	while ((_smask_l)); do

		_smask+=,${smask:${#smask}-_smask_l--*8:8}

	done

	# Add remaining chars if any

	_smask=${smask::${#smask}-8*smask_l}${_smask}

	# If there were no chars left, drop the ',' from the beginning of the string

	echo "${_smask#,}"

}