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