1#!/usr/bin/env bash 2# 3# This allows for launching of multiple QEMU instances, with independent 4# communication possible to each instance. 5# 6# Each instance can choose, at launch, to use either the QMP or the 7# HMP (monitor) interface. 8# 9# All instances are cleaned up via _cleanup_qemu, including killing the 10# running qemu instance. 11# 12# Copyright (C) 2014 Red Hat, Inc. 13# 14# This program is free software; you can redistribute it and/or modify 15# it under the terms of the GNU General Public License as published by 16# the Free Software Foundation; either version 2 of the License, or 17# (at your option) any later version. 18# 19# This program is distributed in the hope that it will be useful, 20# but WITHOUT ANY WARRANTY; without even the implied warranty of 21# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22# GNU General Public License for more details. 23# 24# You should have received a copy of the GNU General Public License 25# along with this program. If not, see <http://www.gnu.org/licenses/>. 26# 27 28QEMU_COMM_TIMEOUT=10 29 30QEMU_FIFO_IN="${QEMU_TEST_DIR}/qmp-in-$$" 31QEMU_FIFO_OUT="${QEMU_TEST_DIR}/qmp-out-$$" 32 33QEMU_HANDLE=0 34export _QEMU_HANDLE=0 35 36# If bash version is >= 4.1, these will be overwritten and dynamic 37# file descriptor values assigned. 38_out_fd=3 39_in_fd=4 40 41# Wait for expected QMP response from QEMU. Will time out 42# after 10 seconds, which counts as failure. 43# 44# Override QEMU_COMM_TIMEOUT for a timeout different than the 45# default 10 seconds 46# 47# $1: The handle to use 48# $2+ All remaining arguments comprise the string to search for 49# in the response. 50# 51# If $silent is set to anything but an empty string, then 52# response is not echoed out. 53# If $mismatch_only is set, only non-matching responses will 54# be echoed. 55# 56# If $success_or_failure is set, the meaning of the arguments is 57# changed as follows: 58# $2: A string to search for in the response; if found, this indicates 59# success and ${QEMU_STATUS[$1]} is set to 0. 60# $3: A string to search for in the response; if found, this indicates 61# failure and the test is either aborted (if $qemu_error_no_exit 62# is not set) or ${QEMU_STATUS[$1]} is set to -1 (otherwise). 63_timed_wait_for() 64{ 65 local h=${1} 66 shift 67 68 if [ -z "${success_or_failure}" ]; then 69 success_match=${*} 70 failure_match= 71 else 72 success_match=${1} 73 failure_match=${2} 74 fi 75 76 timeout=yes 77 78 QEMU_STATUS[$h]=0 79 while IFS= read -t ${QEMU_COMM_TIMEOUT} resp <&${QEMU_OUT[$h]} 80 do 81 if [ -z "${silent}" ] && [ -z "${mismatch_only}" ]; then 82 echo "${resp}" | _filter_testdir | _filter_qemu \ 83 | _filter_qemu_io | _filter_qmp | _filter_hmp 84 fi 85 if [ -n "${failure_match}" ]; then 86 grep -q "${failure_match}" < <(echo "${resp}") 87 if [ $? -eq 0 ]; then 88 timeout= 89 break 90 fi 91 fi 92 grep -q "${success_match}" < <(echo "${resp}") 93 if [ $? -eq 0 ]; then 94 return 95 fi 96 if [ -z "${silent}" ] && [ -n "${mismatch_only}" ]; then 97 echo "${resp}" | _filter_testdir | _filter_qemu \ 98 | _filter_qemu_io | _filter_qmp | _filter_hmp 99 fi 100 101 done 102 QEMU_STATUS[$h]=-1 103 if [ -z "${qemu_error_no_exit}" ]; then 104 if [ -n "${timeout}" ]; then 105 echo "Timeout waiting for ${success_match} on handle ${h}" 106 else 107 echo "Wrong response matching ${failure_match} on handle ${h}" 108 fi 109 exit 1 # Timeout or wrong match mean the test failed 110 fi 111} 112 113 114# Sends QMP or HMP command to QEMU, and waits for the expected response 115# 116# $1: QEMU handle to use 117# $2: String of the QMP command to send 118# ${@: -1} (Last string passed) 119# String that the QEMU response should contain. If it is a null 120# string, do not wait for a response 121# 122# Set qemu_cmd_repeat to the number of times to repeat the cmd 123# until either timeout, or a response. If it is not set, or <=0, 124# then the command is only sent once. 125# 126# If neither $silent nor $mismatch_only is set, and $cmd begins with '{', 127# echo the command before sending it the first time. 128# 129# If $qemu_error_no_exit is set, then even if the expected response 130# is not seen, we will not exit. $QEMU_STATUS[$1] will be set it -1 in 131# that case. 132# 133# If $success_or_failure is set, then the last two strings are the 134# strings the response will be scanned for. The first of the two 135# indicates success, the latter indicates failure. Failure is handled 136# like a timeout. 137_send_qemu_cmd() 138{ 139 local h=${1} 140 local count=1 141 local cmd= 142 local use_error=${qemu_error_no_exit} 143 shift 144 145 if [ ${qemu_cmd_repeat} -gt 0 ] 2>/dev/null; then 146 count=${qemu_cmd_repeat} 147 use_error="no" 148 fi 149 # This array element extraction is done to accommodate pathnames with spaces 150 if [ -z "${success_or_failure}" ]; then 151 cmd=${@: 1:${#@}-1} 152 shift $(($# - 1)) 153 else 154 cmd=${@: 1:${#@}-2} 155 shift $(($# - 2)) 156 fi 157 158 # Display QMP being sent, but not HMP (since HMP already echoes its 159 # input back to output); decide based on leading '{' 160 if [ -z "$silent" ] && [ -z "$mismatch_only" ] && 161 [ "$cmd" != "${cmd#\{}" ]; then 162 echo "${cmd}" | _filter_testdir | _filter_imgfmt 163 fi 164 while [ ${count} -gt 0 ] 165 do 166 echo "${cmd}" >&${QEMU_IN[${h}]} 167 if [ -n "${1}" ]; then 168 if [ -z "${success_or_failure}" ]; then 169 qemu_error_no_exit=${use_error} _timed_wait_for ${h} "${1}" 170 else 171 qemu_error_no_exit=${use_error} _timed_wait_for ${h} "${1}" "${2}" 172 fi 173 if [ ${QEMU_STATUS[$h]} -eq 0 ]; then 174 return 175 fi 176 fi 177 let count--; 178 done 179 if [ ${QEMU_STATUS[$h]} -ne 0 ] && [ -z "${qemu_error_no_exit}" ]; then 180 echo "Timeout waiting for ${1} on handle ${h}" 181 exit 1 #Timeout means the test failed 182 fi 183} 184 185 186# Launch a QEMU process. 187# 188# Input parameters: 189# $qemu_comm_method: set this variable to 'monitor' (case insensitive) 190# to use the QEMU HMP monitor for communication. 191# Otherwise, the default of QMP is used. 192# $qmp_pretty: Set this variable to 'y' to enable QMP pretty printing. 193# $keep_stderr: Set this variable to 'y' to keep QEMU's stderr output on stderr. 194# If this variable is empty, stderr will be redirected to stdout. 195# Returns: 196# $QEMU_HANDLE: set to a handle value to communicate with this QEMU instance. 197# 198_launch_qemu() 199{ 200 local comm= 201 local fifo_out= 202 local fifo_in= 203 204 if (shopt -s nocasematch; [[ "${qemu_comm_method}" == "monitor" ]]) 205 then 206 comm="-monitor stdio" 207 else 208 local qemu_comm_method="qmp" 209 if [ "$qmp_pretty" = "y" ]; then 210 comm="-monitor none -qmp-pretty stdio" 211 else 212 comm="-monitor none -qmp stdio" 213 fi 214 fi 215 216 fifo_out=${QEMU_FIFO_OUT}_${_QEMU_HANDLE} 217 fifo_in=${QEMU_FIFO_IN}_${_QEMU_HANDLE} 218 mkfifo "${fifo_out}" 219 mkfifo "${fifo_in}" 220 221 object_options= 222 if [ -n "$IMGKEYSECRET" ]; then 223 object_options="--object secret,id=keysec0,data=$IMGKEYSECRET" 224 fi 225 226 if [ -z "$keep_stderr" ]; then 227 QEMU_NEED_PID='y'\ 228 ${QEMU} ${object_options} -nographic -serial none ${comm} "${@}" >"${fifo_out}" \ 229 2>&1 \ 230 <"${fifo_in}" & 231 elif [ "$keep_stderr" = "y" ]; then 232 QEMU_NEED_PID='y'\ 233 ${QEMU} ${object_options} -nographic -serial none ${comm} "${@}" >"${fifo_out}" \ 234 <"${fifo_in}" & 235 else 236 exit 1 237 fi 238 239 if [[ "${BASH_VERSINFO[0]}" -ge "5" || 240 ("${BASH_VERSINFO[0]}" -ge "4" && "${BASH_VERSINFO[1]}" -ge "1") ]] 241 then 242 # bash >= 4.1 required for automatic fd 243 exec {_out_fd}<"${fifo_out}" 244 exec {_in_fd}>"${fifo_in}" 245 else 246 let _out_fd++ 247 let _in_fd++ 248 eval "exec ${_out_fd}<'${fifo_out}'" 249 eval "exec ${_in_fd}>'${fifo_in}'" 250 fi 251 252 QEMU_OUT[${_QEMU_HANDLE}]=${_out_fd} 253 QEMU_IN[${_QEMU_HANDLE}]=${_in_fd} 254 QEMU_STATUS[${_QEMU_HANDLE}]=0 255 256 if [ "${qemu_comm_method}" == "qmp" ] 257 then 258 # Don't print response, since it has version information in it 259 silent=yes _timed_wait_for ${_QEMU_HANDLE} "capabilities" 260 if [ "$qmp_pretty" = "y" ]; then 261 silent=yes _timed_wait_for ${_QEMU_HANDLE} "^}" 262 fi 263 fi 264 QEMU_HANDLE=${_QEMU_HANDLE} 265 let _QEMU_HANDLE++ 266} 267 268 269# Silently kills the QEMU process 270# 271# If $wait is set to anything other than the empty string, the process will not 272# be killed but only waited for, and any output will be forwarded to stdout. If 273# $wait is empty, the process will be killed and all output will be suppressed. 274_cleanup_qemu() 275{ 276 # QEMU_PID[], QEMU_IN[], QEMU_OUT[] all use same indices 277 for i in "${!QEMU_OUT[@]}" 278 do 279 local QEMU_PID 280 if [ -f "${QEMU_TEST_DIR}/qemu-${i}.pid" ]; then 281 read QEMU_PID < "${QEMU_TEST_DIR}/qemu-${i}.pid" 282 rm -f "${QEMU_TEST_DIR}/qemu-${i}.pid" 283 if [ -z "${wait}" ] && [ -n "${QEMU_PID}" ]; then 284 kill -KILL ${QEMU_PID} 2>/dev/null 285 fi 286 if [ -n "${QEMU_PID}" ]; then 287 wait ${QEMU_PID} 2>/dev/null # silent kill 288 fi 289 fi 290 291 if [ -n "${wait}" ]; then 292 cat <&${QEMU_OUT[$i]} | _filter_testdir | _filter_qemu \ 293 | _filter_qemu_io | _filter_qmp | _filter_hmp 294 fi 295 rm -f "${QEMU_FIFO_IN}_${i}" "${QEMU_FIFO_OUT}_${i}" 296 eval "exec ${QEMU_IN[$i]}<&-" # close file descriptors 297 eval "exec ${QEMU_OUT[$i]}<&-" 298 299 unset QEMU_IN[$i] 300 unset QEMU_OUT[$i] 301 done 302} 303