tests/qemu-iotests/common.qemu

   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
  28 QEMU_COMM_TIMEOUT=10
  29
  30 QEMU_FIFO_IN="${QEMU_TEST_DIR}/qmp-in-$$"
  31 QEMU_FIFO_OUT="${QEMU_TEST_DIR}/qmp-out-$$"
  32
  33 QEMU_HANDLE=0
  34 export _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 $capture_events is non-empty, then any QMP event names it lists
  57 # will not be echoed out, but instead collected in the $QEMU_EVENTS
  58 # variable. The _wait_event function can later be used to receive
  59 # the cached events.
  60 #
  61 # If $only_capture_events is set to anything but an empty string,
  62 # then an error will be raised if a QMP message is seen which is
  63 # not an event listed in $capture_events.
  64 #
  65 # If $success_or_failure is set, the meaning of the arguments is
  66 # changed as follows:
  67 # $2: A string to search for in the response; if found, this indicates
  68 #     success and ${QEMU_STATUS[$1]} is set to 0.
  69 # $3: A string to search for in the response; if found, this indicates
  70 #     failure and the test is either aborted (if $qemu_error_no_exit
  71 #     is not set) or ${QEMU_STATUS[$1]} is set to -1 (otherwise).
  72 _timed_wait_for()
  73 {
  74     local h=${1}
  75     shift
  76
  77     if [ -z "${success_or_failure}" ]; then
  78         success_match=${*}
  79         failure_match=
  80     else
  81         success_match=${1}
  82         failure_match=${2}
  83     fi
  84
  85     timeout=yes
  86
  87     QEMU_STATUS[$h]=0
  88     read_timeout="-t ${QEMU_COMM_TIMEOUT}"
  89     if [ -n "${GDB_OPTIONS}" ]; then
  90         read_timeout=
  91     fi
  92
  93     while IFS= read ${read_timeout} resp <&${QEMU_OUT[$h]}
  94     do
  95         if [ -n "$capture_events" ]; then
  96             capture=0
  97             local evname
  98             for evname in $capture_events
  99             do
 100                 case ${resp} in
 101                     *\"event\":\ \"${evname}\"* ) capture=1 ;;
 102                 esac
 103             done
 104             if [ $capture = 1 ];
 105             then
 106                 ev=$(echo "${resp}" | tr -d '\r' | tr % .)
 107                 QEMU_EVENTS="${QEMU_EVENTS:+${QEMU_EVENTS}%}${ev}"
 108                 if [ -n "$only_capture_events" ]; then
 109                     return
 110                 else
 111                     continue
 112                 fi
 113             fi
 114         fi
 115         if [ -n "$only_capture_events" ]; then
 116             echo "Only expected $capture_events but got ${resp}"
 117             exit 1
 118         fi
 119
 120         if [ -z "${silent}" ] && [ -z "${mismatch_only}" ]; then
 121             echo "${resp}" | _filter_testdir | _filter_qemu \
 122                            | _filter_qemu_io | _filter_qmp | _filter_hmp
 123         fi
 124         if [ -n "${failure_match}" ]; then
 125             grep -q "${failure_match}" < <(echo "${resp}")
 126             if [ $? -eq 0 ]; then
 127                 timeout=
 128                 break
 129             fi
 130         fi
 131         grep -q "${success_match}" < <(echo "${resp}")
 132         if [ $? -eq 0 ]; then
 133             return
 134         fi
 135         if [ -z "${silent}" ] && [ -n "${mismatch_only}" ]; then
 136             echo "${resp}" | _filter_testdir | _filter_qemu \
 137                            | _filter_qemu_io | _filter_qmp | _filter_hmp
 138         fi
 139
 140     done
 141     QEMU_STATUS[$h]=-1
 142     if [ -z "${qemu_error_no_exit}" ]; then
 143         if [ -n "${timeout}" ]; then
 144             echo "Timeout waiting for ${success_match} on handle ${h}"
 145         else
 146             echo "Wrong response matching ${failure_match} on handle ${h}"
 147         fi
 148         exit 1  # Timeout or wrong match mean the test failed
 149     fi
 150 }
 151
 152
 153 # Sends QMP or HMP command to QEMU, and waits for the expected response
 154 #
 155 # $1:       QEMU handle to use
 156 # $2:       String of the QMP command to send
 157 # ${@: -1}  (Last string passed)
 158 #             String that the QEMU response should contain. If it is a null
 159 #             string, do not wait for a response
 160 #
 161 # Set qemu_cmd_repeat to the number of times to repeat the cmd
 162 # until either timeout, or a response.  If it is not set, or <=0,
 163 # then the command is only sent once.
 164 #
 165 # If neither $silent nor $mismatch_only is set, and $cmd begins with '{',
 166 # echo the command before sending it the first time.
 167 #
 168 # If $qemu_error_no_exit is set, then even if the expected response
 169 # is not seen, we will not exit.  $QEMU_STATUS[$1] will be set it -1 in
 170 # that case.
 171 #
 172 # If $success_or_failure is set, then the last two strings are the
 173 # strings the response will be scanned for.  The first of the two
 174 # indicates success, the latter indicates failure.  Failure is handled
 175 # like a timeout.
 176 _send_qemu_cmd()
 177 {
 178     local h=${1}
 179     local count=1
 180     local cmd=
 181     local use_error=${qemu_error_no_exit}
 182     shift
 183
 184     if [ ${qemu_cmd_repeat} -gt 0 ] 2>/dev/null; then
 185         count=${qemu_cmd_repeat}
 186         use_error="no"
 187     fi
 188
 189     cmd=$1
 190     shift
 191
 192     # Display QMP being sent, but not HMP (since HMP already echoes its
 193     # input back to output); decide based on leading '{'
 194     if [ -z "$silent" ] && [ -z "$mismatch_only" ] &&
 195             [ "$cmd" != "${cmd#\{}" ]; then
 196         echo "${cmd}" | _filter_testdir | _filter_imgfmt
 197     fi
 198     while [ ${count} -gt 0 ]
 199     do
 200         echo "${cmd}" >&${QEMU_IN[${h}]}
 201         if [ -n "${1}" ]; then
 202             if [ -z "${success_or_failure}" ]; then
 203                 qemu_error_no_exit=${use_error} _timed_wait_for ${h} "${1}"
 204             else
 205                 qemu_error_no_exit=${use_error} _timed_wait_for ${h} "${1}" "${2}"
 206             fi
 207             if [ ${QEMU_STATUS[$h]} -eq 0 ]; then
 208                 return
 209             fi
 210         fi
 211         let count--;
 212     done
 213     if [ ${QEMU_STATUS[$h]} -ne 0 ] && [ -z "${qemu_error_no_exit}" ]; then
 214         echo "Timeout waiting for command ${1} response on handle ${h}"
 215         exit 1 #Timeout means the test failed
 216     fi
 217 }
 218
 219
 220 # Check event cache for a named QMP event
 221 #
 222 # Input parameters:
 223 # $1:       Name of the QMP event to check for
 224 #
 225 # Checks if the named QMP event that was previously captured
 226 # into $QEMU_EVENTS. When matched, the QMP event will be echoed
 227 # and the $matched variable set to 1.
 228 #
 229 # _wait_event is more suitable for test usage in most cases
 230 _check_cached_events()
 231 {
 232     local evname=${1}
 233
 234     local match="\"event\": \"$evname\""
 235
 236     matched=0
 237     if [ -n "$QEMU_EVENTS" ]; then
 238         CURRENT_QEMU_EVENTS=$QEMU_EVENTS
 239         QEMU_EVENTS=
 240         old_IFS=$IFS
 241         IFS="%"
 242         for ev in $CURRENT_QEMU_EVENTS
 243         do
 244             grep -q "$match" < <(echo "${ev}")
 245             if [ $? -eq 0 ] && [ $matched = 0 ]; then
 246                 echo "${ev}" | _filter_testdir | _filter_qemu \
 247                            | _filter_qemu_io | _filter_qmp | _filter_hmp
 248                 matched=1
 249             else
 250                 QEMU_EVENTS="${QEMU_EVENTS:+${QEMU_EVENTS}%}${ev}"
 251             fi
 252         done
 253         IFS=$old_IFS
 254     fi
 255 }
 256
 257 # Wait for a named QMP event
 258 #
 259 # Input parameters:
 260 # $1:       QEMU handle to use
 261 # $2:       Name of the QMP event to wait for
 262 #
 263 # Checks if the named QMP even was previously captured
 264 # into $QEMU_EVENTS. If none are present, then waits for the
 265 # event to arrive on the QMP channel. When matched, the QMP
 266 # event will be echoed
 267 _wait_event()
 268 {
 269     local h=${1}
 270     local evname=${2}
 271
 272     while true
 273     do
 274         _check_cached_events $evname
 275
 276         if [ $matched = 1 ];
 277         then
 278             return
 279         fi
 280
 281         only_capture_events=1 qemu_error_no_exit=1 _timed_wait_for ${h}
 282
 283         if [ ${QEMU_STATUS[$h]} -ne 0 ] ; then
 284             echo "Timeout waiting for event ${evname} on handle ${h}"
 285             exit 1 #Timeout means the test failed
 286         fi
 287     done
 288 }
 289
 290 # Launch a QEMU process.
 291 #
 292 # Input parameters:
 293 # $qemu_comm_method: set this variable to 'monitor' (case insensitive)
 294 #                    to use the QEMU HMP monitor for communication.
 295 #                    Otherwise, the default of QMP is used.
 296 # $qmp_pretty: Set this variable to 'y' to enable QMP pretty printing.
 297 # $keep_stderr: Set this variable to 'y' to keep QEMU's stderr output on stderr.
 298 #               If this variable is empty, stderr will be redirected to stdout.
 299 # Returns:
 300 # $QEMU_HANDLE: set to a handle value to communicate with this QEMU instance.
 301 #
 302 _launch_qemu()
 303 {
 304     local comm=
 305     local fifo_out=
 306     local fifo_in=
 307
 308     if (shopt -s nocasematch; [[ "${qemu_comm_method}" == "monitor" ]])
 309     then
 310         comm="-monitor stdio"
 311     else
 312         local qemu_comm_method="qmp"
 313         if [ "$qmp_pretty" = "y" ]; then
 314             comm="-monitor none -qmp-pretty stdio"
 315         else
 316             comm="-monitor none -qmp stdio"
 317         fi
 318     fi
 319
 320     fifo_out=${QEMU_FIFO_OUT}_${_QEMU_HANDLE}
 321     fifo_in=${QEMU_FIFO_IN}_${_QEMU_HANDLE}
 322     mkfifo "${fifo_out}"
 323     mkfifo "${fifo_in}"
 324
 325     object_options=
 326     if [ -n "$IMGKEYSECRET" ]; then
 327         object_options="--object secret,id=keysec0,data=$IMGKEYSECRET"
 328     fi
 329
 330     if [ -z "$keep_stderr" ]; then
 331         QEMU_NEED_PID='y'\
 332         ${QEMU} ${object_options} -nographic -serial none ${comm} "${@}" >"${fifo_out}" \
 333                                                        2>&1 \
 334                                                        <"${fifo_in}" &
 335     elif [ "$keep_stderr" = "y" ]; then
 336         QEMU_NEED_PID='y'\
 337         ${QEMU} ${object_options} -nographic -serial none ${comm} "${@}" >"${fifo_out}" \
 338                                                        <"${fifo_in}" &
 339     else
 340         exit 1
 341     fi
 342
 343     if [[ "${BASH_VERSINFO[0]}" -ge "5" ||
 344         ("${BASH_VERSINFO[0]}" -ge "4"  &&  "${BASH_VERSINFO[1]}" -ge "1") ]]
 345     then
 346         # bash >= 4.1 required for automatic fd
 347         exec {_out_fd}<"${fifo_out}"
 348         exec {_in_fd}>"${fifo_in}"
 349     else
 350         let _out_fd++
 351         let _in_fd++
 352         eval "exec ${_out_fd}<'${fifo_out}'"
 353         eval "exec ${_in_fd}>'${fifo_in}'"
 354     fi
 355
 356     QEMU_OUT[${_QEMU_HANDLE}]=${_out_fd}
 357     QEMU_IN[${_QEMU_HANDLE}]=${_in_fd}
 358     QEMU_STATUS[${_QEMU_HANDLE}]=0
 359
 360     if [ "${qemu_comm_method}" == "qmp" ]
 361     then
 362         # Don't print response, since it has version information in it
 363         silent=yes _timed_wait_for ${_QEMU_HANDLE} "capabilities"
 364         if [ "$qmp_pretty" = "y" ]; then
 365             silent=yes _timed_wait_for ${_QEMU_HANDLE} "^}"
 366         fi
 367     fi
 368     QEMU_HANDLE=${_QEMU_HANDLE}
 369     let _QEMU_HANDLE++
 370 }
 371
 372
 373 # Silently kills the QEMU process
 374 #
 375 # If $wait is set to anything other than the empty string, the process will not
 376 # be killed but only waited for, and any output will be forwarded to stdout. If
 377 # $wait is empty, the process will be killed and all output will be suppressed.
 378 _cleanup_qemu()
 379 {
 380     # QEMU_PID[], QEMU_IN[], QEMU_OUT[] all use same indices
 381     for i in "${!QEMU_OUT[@]}"
 382     do
 383         local QEMU_PID
 384         if [ -f "${QEMU_TEST_DIR}/qemu-${i}.pid" ]; then
 385             read QEMU_PID < "${QEMU_TEST_DIR}/qemu-${i}.pid"
 386             rm -f "${QEMU_TEST_DIR}/qemu-${i}.pid"
 387             if [ -z "${wait}" ] && [ -n "${QEMU_PID}" ]; then
 388                 kill -KILL ${QEMU_PID} 2>/dev/null
 389             fi
 390             if [ -n "${QEMU_PID}" ]; then
 391                 wait ${QEMU_PID} 2>/dev/null # silent kill
 392             fi
 393         fi
 394
 395         if [ -n "${wait}" ]; then
 396             cat <&${QEMU_OUT[$i]} | _filter_testdir | _filter_qemu \
 397                                   | _filter_qemu_io | _filter_qmp | _filter_hmp
 398         fi
 399         rm -f "${QEMU_FIFO_IN}_${i}" "${QEMU_FIFO_OUT}_${i}"
 400         eval "exec ${QEMU_IN[$i]}<&-"   # close file descriptors
 401         eval "exec ${QEMU_OUT[$i]}<&-"
 402
 403         unset QEMU_IN[$i]
 404         unset QEMU_OUT[$i]
 405     done
 406 }