[kvm-unit-tests PATCH v3 5/8] arch-run: rename migration variables

Nicholas Piggin
2024-02-09T07:02:38Z

Using 1 and 2 for source and destination is confusing, particularly
now with multiple migrations that flip between them. Do a rename
pass to tidy things up.

Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
---
scripts/arch-run.bash | 115 +++++++++++++++++++++---------------------
1 file changed, 58 insertions(+), 57 deletions(-)

diff --git a/scripts/arch-run.bash b/scripts/arch-run.bash
index a914ba17..0b45eb61 100644
--- a/scripts/arch-run.bash
+++ b/scripts/arch-run.bash
@@ -132,34 +132,34 @@ run_migration ()
migcmdline=$@

trap 'trap - TERM ; kill 0 ; exit 2' INT TERM
- trap 'rm -f ${migout1} ${migout2} ${migout_fifo1} ${migout_fifo2} ${migsock} ${qmp1} ${qmp2} ${fifo}' RETURN EXIT
-
- migsock=$(mktemp -u -t mig-helper-socket.XXXXXXXXXX)
- migout1=$(mktemp -t mig-helper-stdout1.XXXXXXXXXX)
- migout_fifo1=$(mktemp -u -t mig-helper-fifo-stdout1.XXXXXXXXXX)
- migout2=$(mktemp -t mig-helper-stdout2.XXXXXXXXXX)
- migout_fifo2=$(mktemp -u -t mig-helper-fifo-stdout2.XXXXXXXXXX)
- qmp1=$(mktemp -u -t mig-helper-qmp1.XXXXXXXXXX)
- qmp2=$(mktemp -u -t mig-helper-qmp2.XXXXXXXXXX)
- fifo=$(mktemp -u -t mig-helper-fifo.XXXXXXXXXX)
- qmpout1=/dev/null
- qmpout2=/dev/null
-
- mkfifo ${migout_fifo1}
- mkfifo ${migout_fifo2}
+ trap 'rm -f ${src_out} ${dst_out} ${src_outfifo} ${dst_outfifo} ${dst_incoming} ${src_qmp} ${dst_qmp} ${dst_infifo}' RETURN EXIT
+
+ dst_incoming=$(mktemp -u -t mig-helper-socket-incoming.XXXXXXXXXX)
+ src_out=$(mktemp -t mig-helper-stdout1.XXXXXXXXXX)
+ src_outfifo=$(mktemp -u -t mig-helper-fifo-stdout1.XXXXXXXXXX)
+ dst_out=$(mktemp -t mig-helper-stdout2.XXXXXXXXXX)
+ dst_outfifo=$(mktemp -u -t mig-helper-fifo-stdout2.XXXXXXXXXX)
+ src_qmp=$(mktemp -u -t mig-helper-qmp1.XXXXXXXXXX)
+ dst_qmp=$(mktemp -u -t mig-helper-qmp2.XXXXXXXXXX)
+ dst_infifo=$(mktemp -u -t mig-helper-fifo-stdin.XXXXXXXXXX)
+ src_qmpout=/dev/null
+ dst_qmpout=/dev/null
+
+ mkfifo ${src_outfifo}
+ mkfifo ${dst_outfifo}

eval "$migcmdline" \
- -chardev socket,id=mon1,path=${qmp1},server=on,wait=off \
- -mon chardev=mon1,mode=control > ${migout_fifo1} &
+ -chardev socket,id=mon,path=${src_qmp},server=on,wait=off \
+ -mon chardev=mon,mode=control > ${src_outfifo} &
live_pid=$!
- cat ${migout_fifo1} | tee ${migout1} &
+ cat ${src_outfifo} | tee ${src_out} &

# The test must prompt the user to migrate, so wait for the "migrate"
# keyword
- while ! grep -q -i "Now migrate the VM" < ${migout1} ; do
+ while ! grep -q -i "Now migrate the VM" < ${src_out} ; do
if ! ps -p ${live_pid} > /dev/null ; then
echo "ERROR: Test exit before migration point." >&2
- qmp ${qmp1} '"quit"'> ${qmpout1} 2>/dev/null
+ qmp ${src_qmp} '"quit"'> ${src_qmpout} 2>/dev/null
return 3
fi
sleep 0.1
@@ -172,7 +172,7 @@ run_migration ()

while ps -p ${live_pid} > /dev/null ; do
# Wait for EXIT or further migrations
- if ! grep -q -i "Now migrate the VM" < ${migout1} ; then
+ if ! grep -q -i "Now migrate the VM" < ${src_out} ; then
sleep 0.1
else
do_migration || return $?
@@ -194,79 +194,80 @@ do_migration ()
# We have to use cat to open the named FIFO, because named FIFO's,
# unlike pipes, will block on open() until the other end is also
# opened, and that totally breaks QEMU...
- mkfifo ${fifo}
+ mkfifo ${dst_infifo}
eval "$migcmdline" \
- -chardev socket,id=mon2,path=${qmp2},server=on,wait=off \
- -mon chardev=mon2,mode=control -incoming unix:${migsock} \
- < <(cat ${fifo}) > ${migout_fifo2} &
+ -chardev socket,id=mon,path=${dst_qmp},server=on,wait=off \
+ -mon chardev=mon,mode=control -incoming unix:${dst_incoming} \
+ < <(cat ${dst_infifo}) > ${dst_outfifo} &
incoming_pid=$!
- cat ${migout_fifo2} | tee ${migout2} &
+ cat ${dst_outfifo} | tee ${dst_out} &

# The test must prompt the user to migrate, so wait for the "migrate" keyword
- while ! grep -q -i "Now migrate the VM" < ${migout1} ; do
+ while ! grep -q -i "Now migrate the VM" < ${src_out} ; do
if ! ps -p ${live_pid} > /dev/null ; then
echo "ERROR: Test exit before migration point." >&2
- echo > ${fifo}
- qmp ${qmp1} '"quit"'> ${qmpout1} 2>/dev/null
- qmp ${qmp2} '"quit"'> ${qmpout2} 2>/dev/null
+ echo > ${dst_infifo}
+ qmp ${src_qmp} '"quit"'> ${src_qmpout} 2>/dev/null
+ qmp ${dst_qmp} '"quit"'> ${dst_qmpout} 2>/dev/null
return 3
fi
sleep 0.1
done

# Wait until the destination has created the incoming and qmp sockets
- while ! [ -S ${migsock} ] ; do sleep 0.1 ; done
- while ! [ -S ${qmp2} ] ; do sleep 0.1 ; done
+ while ! [ -S ${dst_incoming} ] ; do sleep 0.1 ; done
+ while ! [ -S ${dst_qmp} ] ; do sleep 0.1 ; done

- qmp ${qmp1} '"migrate", "arguments": { "uri": "unix:'${migsock}'" }' > ${qmpout1}
+ qmp ${src_qmp} '"migrate", "arguments": { "uri": "unix:'${dst_incoming}'" }' > ${src_qmpout}

# Wait for the migration to complete
- migstatus=`qmp ${qmp1} '"query-migrate"' | grep return`
+ migstatus=`qmp ${src_qmp} '"query-migrate"' | grep return`
while ! grep -q '"completed"' <<<"$migstatus" ; do
sleep 0.1
- if ! migstatus=`qmp ${qmp1} '"query-migrate"'`; then
+ if ! migstatus=`qmp ${src_qmp} '"query-migrate"'`; then
echo "ERROR: Querying migration state failed." >&2
- echo > ${fifo}
- qmp ${qmp2} '"quit"'> ${qmpout2} 2>/dev/null
+ echo > ${dst_infifo}
+ qmp ${dst_qmp} '"quit"'> ${dst_qmpout} 2>/dev/null
return 2
fi
migstatus=`grep return <<<"$migstatus"`
if grep -q '"failed"' <<<"$migstatus"; then
echo "ERROR: Migration failed." >&2
- echo > ${fifo}
- qmp ${qmp1} '"quit"'> ${qmpout1} 2>/dev/null
- qmp ${qmp2} '"quit"'> ${qmpout2} 2>/dev/null
+ echo > ${dst_infifo}
+ qmp ${src_qmp} '"quit"'> ${src_qmpout} 2>/dev/null
+ qmp ${dst_qmp} '"quit"'> ${dst_qmpout} 2>/dev/null
return 2
fi
done

- qmp ${qmp1} '"quit"'> ${qmpout1} 2>/dev/null
+ qmp ${src_qmp} '"quit"'> ${src_qmpout} 2>/dev/null

# keypress to dst so getchar completes and test continues
- echo > ${fifo}
- rm ${fifo}
+ echo > ${dst_infifo}
+ rm ${dst_infifo}

# Ensure the incoming socket is removed, ready for next destination
- if [ -S ${migsock} ] ; then
+ if [ -S ${dst_incoming} ] ; then
echo "ERROR: Incoming migration socket not removed after migration." >& 2
- qmp ${qmp2} '"quit"'> ${qmpout2} 2>/dev/null
+ qmp ${dst_qmp} '"quit"'> ${dst_qmpout} 2>/dev/null
return 2
fi

wait ${live_pid}
ret=$?

- # Now flip the variables because dest becomes source
+ # Now flip the variables because destination machine becomes source
+ # for the next migration.
live_pid=${incoming_pid}
- tmp=${migout1}
- migout1=${migout2}
- migout2=${tmp}
- tmp=${migout_fifo1}
- migout_fifo1=${migout_fifo2}
- migout_fifo2=${tmp}
- tmp=${qmp1}
- qmp1=${qmp2}
- qmp2=${tmp}
+ tmp=${src_out}
+ src_out=${dst_out}
+ dst_out=${tmp}
+ tmp=${src_outfifo}
+ src_outfifo=${dst_outfifo}
+ dst_outfifo=${tmp}
+ tmp=${src_qmp}
+ src_qmp=${dst_qmp}
+ dst_qmp=${tmp}

return $ret
}
@@ -289,8 +290,8 @@ run_panic ()
qmp=$(mktemp -u -t panic-qmp.XXXXXXXXXX)

# start VM stopped so we don't miss any events
- eval "$@" -chardev socket,id=mon1,path=${qmp},server=on,wait=off \
- -mon chardev=mon1,mode=control -S &
+ eval "$@" -chardev socket,id=mon,path=${qmp},server=on,wait=off \
+ -mon chardev=mon,mode=control -S &

panic_event_count=$(qmp_events ${qmp} | jq -c 'select(.event == "GUEST_PANICKED")' | wc -l)
if [ "$panic_event_count" -lt 1 ]; then
--
2.42.0