Execute o processo em primeiro plano até que o processo em segundo plano seja encerrado no shell

Você pode pesquisar o desaparecimento do processo qemu e encerrar mais cedo quando isso acontecer. Este é um código testado rapidamente e notavelmente não testado com qemu-system.

Também tem bastante. Você pode remover as #DEBUGlinhas, mas se estiver interessado em ver como tudo se encaixa, descomente-as e compare a saída do programa com o código.

#!/bin/bash

InvokeQemu()
{
    local i pid pidFile=qemu.pid

    # Start the qemu process, and return the PID if possible
    #
    (
        # qemu-system ... -pidFile "$pidFile" -daemonize
        ( sleep 30 & sleep 0.5 && echo $! >"$pidFile" )    # FAKE IT for half a minute
    ) >/dev/null 2>&1 </dev/null

    #echo "InvokeQemu: checking for successful daemonisation" >&2    #DEBUG
    for i in 1 2 3
    do
        # Does the PID file exist yet
        #echo "InvokeQemu: attempt $i" >&2    #DEBUG
        if [[ -s "$pidFile" ]] && pid=$(cat "$pidFile") && [[ -n "$pid" ]]
        then
            printf "%s\n" $pid
            #echo "InvokeQemu: pid=$pid" >&2    #DEBUG
            return 0
        fi

        # Pause a moment or so before trying again
        sleep 2
    done
    return 1
}

MonitorPIDs()
{
    local pid

    for pid in "$@"
    do
        #echo "MonitorPIDs: checking pid $pid" >&2    #DEBUG
        if err=$(kill -0 "$pid" 2>&1) || [[ "$err" == *permitted* || "$err" == *denied* ]]
        then
            # Process still exists
            :
            #echo "MonitorPIDs: pid $pid still alive" >&2    #DEBUG
        else
            #echo "MonitorPIDs: pid $pid has died" >&2    #DEBUG
            echo "$pid"
            return 1
        fi
    done
    #echo "MonitorPIDs: all good" >&2    #DEBUG
    return 0
}

########################################################################
# Go
myPid=$$

# Start the qemu emulator
echo "Starting qemu emulator"
qemuPid=$(InvokeQemu)

if [[ -z "$qemuPid" ]]
then
    echo "Could not start qemu" >&2
    exit 1
fi

# Start the monitor process
#
# Once any of them is no longer running it will fire SIGTERM to its
# remaining PIDs and then exit
echo "Starting monitor process"
(
    while MonitorPIDs $qemuPid $myPid >/dev/null
    do
        #echo "(Monitor): all good" >&2    #DEBUG
        sleep 2
    done
    kill $qemuPid $myPid 2>/dev/null
) &

# Start your interactive foreground process
#
# You will receive SIGTERM within a few seconds of the emulator exiting,
# so you may want to trap that
echo "Starting interactive process"
while read -p "What do you want to do? " x
do
    echo "OK"
    sleep 1
done
exit 0

Finalmente acabei com o seguinte código:

qemu-system ... -pidfile ./qemu.pid -daemonize

{
  tail -f --pidfile="$(cat ./qemu.pid)" /dev/null
  kill -INT 0
} &

/my/custom/interactive/process
kill $!

pkill -F ./qemu.pid

Script em chaves é na verdade um monitor pidfile rodando em segundo plano. Uma vez que o pid se foi, monitore o grupo de processos atual. Eu usei kill -INT 0porque dá resultado mais confiável e limpo para mim.

Outras opções eram:

kill -- 0(matar com sinal TERM, não finaliza corretamente o processo interativo)

kill -INT $$(mata apenas o processo de shell, não encerra corretamente o processo interativo)

kill -- -$$(kill process group denotado por pid do shell, nem sempre funciona corretamente, suponho devido à invocação com sudoatuação como líder do grupo de processos)

pkill -P $$(matar apenas o processo filho, na verdade funciona, mas eu preferi usar o shell embutido e confiar no comportamento de processamento Ctrl-C).

Outro ponto é que, se meu processo interativo for concluído por conta própria, terei que matar o processo do monitor para evitar mais inferências na saída e limpeza do script.