ladybird/Meta/run.sh

#!/bin/sh
# shellcheck disable=SC2086 # FIXME: fix these globing warnings

set -e

die() {
    echo "die: $*"
    exit 1
}

SCRIPT_DIR="$(dirname "${0}")"

# https://www.shellcheck.net/wiki/SC1090 No need to shellcheck private config.
# shellcheck source=/dev/null
[ -x "$SCRIPT_DIR/../run-local.sh" ] && . "$SCRIPT_DIR/../run-local.sh"

#SERENITY_PACKET_LOGGING_ARG="-object filter-dump,id=hue,netdev=breh,file=e1000.pcap"

# FIXME: Enable for SERENITY_ARCH=aarch64 if on an aarch64 host?

# Check if SERENITY_VIRTUALIZATION_SUPPORT is unset
if [ -z ${SERENITY_VIRTUALIZATION_SUPPORT+x} ]; then
    VIRTUALIZATION_SUPPORT="0"
    [ -e /dev/kvm ] && [ -r /dev/kvm ] && [ -w /dev/kvm ] && [ "$SERENITY_ARCH" != "aarch64" ] && [ "$(uname -m)" != "aarch64" ] && VIRTUALIZATION_SUPPORT="1"
    command -v wslpath >/dev/null && VIRTUALIZATION_SUPPORT="1"
else
    VIRTUALIZATION_SUPPORT="$SERENITY_VIRTUALIZATION_SUPPORT"
fi

[ -z "$SERENITY_BOCHS_BIN" ] && SERENITY_BOCHS_BIN="bochs"

# To support virtualization acceleration on mac
# we need to use 64-bit qemu
if [ "$(uname)" = "Darwin" ]; then

    if [ "$SERENITY_ARCH" != "aarch64" ]; then
        [ -z "$SERENITY_QEMU_BIN" ] && SERENITY_QEMU_BIN="qemu-system-x86_64"
    else
        [ -z "$SERENITY_QEMU_BIN" ] && SERENITY_QEMU_BIN="qemu-system-aarch64"
    fi

    if [ "$(uname -m)" = "x86_64" ]; then
        if $SERENITY_QEMU_BIN --accel help | grep -q hvf; then
            SERENITY_VIRT_TECH_ARG="--accel hvf"
        fi
    fi
fi

# Prepend the toolchain qemu directory so we pick up QEMU from there
PATH="$SCRIPT_DIR/../Toolchain/Local/qemu/bin:$PATH"

# Also prepend the x86_64 toolchain directory because that's where most
# people will have their QEMU binaries if they built them before the
# directory was changed to Toolchain/Local/qemu.
PATH="$SCRIPT_DIR/../Toolchain/Local/x86_64/bin:$PATH"

SERENITY_RUN="${SERENITY_RUN:-$1}"

if [ -z "$SERENITY_QEMU_BIN" ]; then
    if command -v wslpath >/dev/null; then
        # Some Windows systems don't have reg.exe's directory on the PATH by default.
        PATH=$PATH:/mnt/c/Windows/System32
        QEMU_INSTALL_DIR=$(reg.exe query 'HKLM\Software\QEMU' /v Install_Dir /t REG_SZ | grep '^    Install_Dir' | sed 's/    / /g' | cut -f4- -d' ')
        if [ -z "$QEMU_INSTALL_DIR" ]; then
            if [ "$VIRTUALIZATION_SUPPORT" -eq "0" ]; then
                die "Could not determine where QEMU for Windows is installed. Please make sure QEMU is installed or set SERENITY_QEMU_BIN if it is already installed."
            fi
        else
            QEMU_BINARY_PREFIX="$(wslpath -- "${QEMU_INSTALL_DIR}" | tr -d '\r\n')/"
            QEMU_BINARY_SUFFIX=".exe"
        fi
    fi
    if [ "$SERENITY_ARCH" = "aarch64" ]; then
        SERENITY_QEMU_BIN="${QEMU_BINARY_PREFIX}qemu-system-aarch64${QEMU_BINARY_SUFFIX}"
    elif [ "$SERENITY_ARCH" = "x86_64" ]; then
        SERENITY_QEMU_BIN="${QEMU_BINARY_PREFIX}qemu-system-x86_64${QEMU_BINARY_SUFFIX}"
    else
        die "Please specify a valid CPU architecture."
    fi
fi


# For default values, see Kernel/CommandLine.cpp
[ -z "$SERENITY_KERNEL_CMDLINE" ] && SERENITY_KERNEL_CMDLINE="hello"

[ -z "$SERENITY_RAM_SIZE" ] && SERENITY_RAM_SIZE=1G

[ -z "$SERENITY_DISK_IMAGE" ] && {
    if [ "$SERENITY_RUN" = q35grub ] || [ "$SERENITY_RUN" = qgrub ]; then
        SERENITY_DISK_IMAGE="grub_disk_image"
    elif [ "$SERENITY_RUN" = limine ]; then
        SERENITY_DISK_IMAGE="limine_disk_image"
    elif [ "$SERENITY_RUN" = qextlinux ]; then
        SERENITY_DISK_IMAGE="extlinux_disk_image"
    else
        SERENITY_DISK_IMAGE="_disk_image"
    fi
    if command -v wslpath >/dev/null; then
        case "$SERENITY_QEMU_BIN" in
            /mnt/?/*)
                SERENITY_DISK_IMAGE=$(wslpath -w "$SERENITY_DISK_IMAGE")
                ;;
        esac
    fi
}

SERENITY_QEMU_MIN_REQ_MAJOR_VERSION=6
SERENITY_QEMU_MIN_REQ_MINOR_VERSION=2
SERENITY_QEMU_MIN_REQ_VERSION="$SERENITY_QEMU_MIN_REQ_MAJOR_VERSION.$SERENITY_QEMU_MIN_REQ_MINOR_VERSION"
if ! command -v "$SERENITY_QEMU_BIN" >/dev/null 2>&1 ; then
    die "Please install QEMU version $SERENITY_QEMU_MIN_REQ_VERSION or newer or use the Toolchain/BuildQemu.sh script."
fi

installed_major_version=$("$SERENITY_QEMU_BIN" -version | head -n 1 | sed -E 's/QEMU emulator version ([1-9][0-9]*|0).*/\1/')
installed_minor_version=$("$SERENITY_QEMU_BIN" -version | head -n 1 | sed -E 's/QEMU emulator version [0-9]+\.([1-9][0-9]*|0).*/\1/')
if [ "$installed_major_version" -lt "$SERENITY_QEMU_MIN_REQ_MAJOR_VERSION" ] ||
   { [ "$installed_major_version" -eq "$SERENITY_QEMU_MIN_REQ_MAJOR_VERSION" ] &&
     [ "$installed_minor_version" -lt "$SERENITY_QEMU_MIN_REQ_MINOR_VERSION" ]; }; then
    echo "Required QEMU >= $SERENITY_QEMU_MIN_REQ_VERSION! Found $($SERENITY_QEMU_BIN -version | head -n 1)"
    echo "Please install a newer version of QEMU or use the Toolchain/BuildQemu.sh script."
    die
fi

NATIVE_WINDOWS_QEMU="0"

if command -v wslpath >/dev/null; then
    case "$SERENITY_QEMU_BIN" in
        /mnt/?/*)
            if [ -z "$SERENITY_VIRT_TECH_ARG" ]; then
                if [ "$VIRTUALIZATION_SUPPORT" -eq "1" ]; then
                    if [ "$installed_major_version" -gt 5 ]; then
                        SERENITY_VIRT_TECH_ARG="-accel whpx,kernel-irqchip=off"
                    else
                        SERENITY_VIRT_TECH_ARG="-accel whpx"
                    fi
                fi
                SERENITY_VIRT_TECH_ARG="$SERENITY_VIRT_TECH_ARG -accel tcg"
            fi
            [ -z "$SERENITY_QEMU_CPU" ] && SERENITY_QEMU_CPU="max,vmx=off"
            SERENITY_KERNEL_CMDLINE="$SERENITY_KERNEL_CMDLINE disable_virtio"
            NATIVE_WINDOWS_QEMU="1"
            ;;
    esac
fi

[ "$VIRTUALIZATION_SUPPORT" -eq "1" ] && [ "$NATIVE_WINDOWS_QEMU" -ne "1" ] && SERENITY_VIRT_TECH_ARG="-enable-kvm"

[ -z "$SERENITY_QEMU_CPU" ] && SERENITY_QEMU_CPU="max"

if [ "$SERENITY_ARCH" != "aarch64" ]; then
    [ -z "$SERENITY_CPUS" ] && SERENITY_CPUS="2"
    if [ "$SERENITY_CPUS" -le 8 ]; then
        # Explicitly disable x2APIC so we can test it more easily
        SERENITY_QEMU_CPU="$SERENITY_QEMU_CPU,-x2apic"
    fi

    if [ -z "$SERENITY_SPICE" ] && "${SERENITY_QEMU_BIN}" -chardev help | grep -iq qemu-vdagent; then
        SERENITY_SPICE_SERVER_CHARDEV="-chardev qemu-vdagent,clipboard=on,mouse=off,id=vdagent,name=vdagent"
    elif "${SERENITY_QEMU_BIN}" -chardev help | grep -iq spicevmc; then
        SERENITY_SPICE_SERVER_CHARDEV="-chardev spicevmc,id=vdagent,name=vdagent"
    fi
fi

if [ "$(uname)" = "Darwin" ]; then
    SERENITY_AUDIO_BACKEND="-audiodev coreaudio,id=snd0"
elif [ "$NATIVE_WINDOWS_QEMU" -eq "1" ]; then
    SERENITY_AUDIO_BACKEND="-audiodev dsound,id=snd0,timer-period=2000"
elif "$SERENITY_QEMU_BIN" -audio-help 2>&1 | grep -- "-audiodev id=sdl" >/dev/null; then
    SERENITY_AUDIO_BACKEND="-audiodev sdl,id=snd0"
else
    SERENITY_AUDIO_BACKEND="-audiodev pa,timer-period=2000,id=snd0"
fi

SERENITY_AUDIO_HARDWARE="${SERENITY_AUDIO_HARDWARE:-intelhda}"
if [ "${SERENITY_AUDIO_HARDWARE}" = 'ac97' ]; then
    SERENITY_AUDIO_DEVICE='-device ac97,audiodev=snd0'
elif [ "${SERENITY_AUDIO_HARDWARE}" = 'intelhda' ]; then
    SERENITY_AUDIO_DEVICE='-device ich9-intel-hda -device hda-output,audiodev=snd0'
else
    echo "Unknown audio hardware: ${SERENITY_AUDIO_HARDWARE}"
    echo 'Supported values: ac97, intelhda'
    exit 1
fi

if [ "$installed_major_version" -eq 5 ] && [ "$installed_minor_version" -eq 0 ]; then
    SERENITY_AUDIO_PC_SPEAKER="-soundhw pcspk"
else
    SERENITY_AUDIO_PC_SPEAKER="-machine pcspk-audiodev=snd0"
fi

SERENITY_SCREENS="${SERENITY_SCREENS:-1}"
if [ "$SERENITY_SPICE" ]; then
    SERENITY_QEMU_DISPLAY_BACKEND="${SERENITY_QEMU_DISPLAY_BACKEND:-spice-app}"
elif [ "$NATIVE_WINDOWS_QEMU" -eq "1" ]; then
    # QEMU for windows does not like gl=on, so detect if we are building in wsl, and if so, disable it
    # Also, when using the GTK backend we run into this problem: https://github.com/SerenityOS/serenity/issues/7657
    SERENITY_QEMU_DISPLAY_BACKEND="${SERENITY_QEMU_DISPLAY_BACKEND:-sdl,gl=off}"
elif [ $SERENITY_SCREENS -gt 1 ] && "${SERENITY_QEMU_BIN}" --display help | grep -iq sdl; then
    SERENITY_QEMU_DISPLAY_BACKEND="${SERENITY_QEMU_DISPLAY_BACKEND:-sdl,gl=off}"
elif ! command -v wslpath >/dev/null && ("${SERENITY_QEMU_BIN}" --display help | grep -iq sdl) && (ldconfig -p | grep -iq virglrenderer); then
    SERENITY_QEMU_DISPLAY_BACKEND="${SERENITY_QEMU_DISPLAY_BACKEND:-sdl,gl=on}"
elif "${SERENITY_QEMU_BIN}" --display help | grep -iq cocoa; then
    # QEMU for OSX seems to only support cocoa
    SERENITY_QEMU_DISPLAY_BACKEND="${SERENITY_QEMU_DISPLAY_BACKEND:-cocoa,gl=off}"
elif [ "$(uname -s)" = "SerenityOS" ]; then
    SERENITY_QEMU_DISPLAY_BACKEND="${SERENITY_QEMU_DISPLAY_BACKEND:-sdl,gl=off}"
else
    SERENITY_QEMU_DISPLAY_BACKEND="${SERENITY_QEMU_DISPLAY_BACKEND:-gtk,gl=off}"
fi

SERENITY_GL="${SERENITY_GL:-0}"
if [ -z "$SERENITY_QEMU_DISPLAY_DEVICE" ]; then
    if [ "$SERENITY_GL" = "1" ]; then
        # QEMU appears to not support the GL backend for VirtIO GPU variant on macOS.
        if [ "$(uname)" = "Darwin" ]; then
            die "SERENITY_GL is not supported since there's no GL backend on macOS"
        else
            SERENITY_QEMU_DISPLAY_DEVICE="virtio-vga-gl "
        fi
        
        if [ "$SERENITY_SCREENS" -gt 1 ]; then
            die "SERENITY_GL and multi-monitor support cannot be setup simultaneously"
        fi
    elif [ "$SERENITY_SCREENS" -gt 1 ]; then
        # QEMU appears to not support the virtio-vga VirtIO GPU variant on macOS.
        # To ensure we can still boot on macOS with VirtIO GPU, use the virtio-gpu-pci
        # variant, which lacks any VGA compatibility (which is not relevant for us anyway).
        if [ "$(uname)" = "Darwin" ]; then
            SERENITY_QEMU_DISPLAY_DEVICE="virtio-gpu-pci,max_outputs=$SERENITY_SCREENS "
        else
            SERENITY_QEMU_DISPLAY_DEVICE="virtio-vga,max_outputs=$SERENITY_SCREENS "
        fi

        # QEMU appears to always relay absolute mouse coordinates relative to the screen that the mouse is
        # pointed to, without any way for us to know what screen it was. So, when dealing with multiple
        # displays force using relative coordinates only
        SERENITY_KERNEL_CMDLINE="$SERENITY_KERNEL_CMDLINE vmmouse=off"
    else
        SERENITY_QEMU_DISPLAY_DEVICE="VGA,vgamem_mb=64 "
    fi
fi

if [ "$SERENITY_ARCH" = 'aarch64' ]; then
    SERENITY_BOOT_DRIVE="-drive file=${SERENITY_DISK_IMAGE},if=sd,format=raw"
elif [ -z "${SERENITY_NVME_ENABLE}" ] || [ "${SERENITY_NVME_ENABLE}" -eq 1 ]; then
    # NVME is enabled by default; disable by setting SERENITY_NVME_ENABLE=0
    SERENITY_BOOT_DRIVE="-drive file=${SERENITY_DISK_IMAGE},format=raw,index=0,media=disk,if=none,id=disk"
    SERENITY_BOOT_DRIVE="${SERENITY_BOOT_DRIVE} -device i82801b11-bridge,id=bridge4 -device sdhci-pci,bus=bridge4"
    SERENITY_BOOT_DRIVE="${SERENITY_BOOT_DRIVE} -device nvme,serial=deadbeef,drive=disk,bus=bridge4,logical_block_size=4096,physical_block_size=4096"
    SERENITY_KERNEL_CMDLINE="${SERENITY_KERNEL_CMDLINE} root=nvme0:1:0"
else
    SERENITY_BOOT_DRIVE="-drive file=${SERENITY_DISK_IMAGE},format=raw,index=0,media=disk,id=disk"
fi

if [ -n "${SERENITY_USE_SDCARD}" ] && [ "${SERENITY_USE_SDCARD}" -eq 1 ]; then
    SERENITY_BOOT_DRIVE="-device sdhci-pci -device sd-card,drive=sd-boot-drive -drive id=sd-boot-drive,if=none,format=raw,file=${SERENITY_DISK_IMAGE}"
    SERENITY_KERNEL_CMDLINE="$SERENITY_KERNEL_CMDLINE root=sd2:0:0"
fi

if [ -z "$SERENITY_HOST_IP" ]; then
    SERENITY_HOST_IP="127.0.0.1"
fi

if command -v wslpath >/dev/null; then
   SERENITY_DISABLE_GDB_SOCKET=1
fi

if [ "$(uname)" = "Darwin" ] &&
   [ "${SERENITY_VIRT_TECH_ARG}" = "--accel hvf" ]; then
  # HVF doesn't support gdbstub per https://wiki.qemu.org/Features/HVF
  SERENITY_DISABLE_GDB_SOCKET=1
fi

if [ -z "$SERENITY_DISABLE_GDB_SOCKET" ]; then
    SERENITY_EXTRA_QEMU_ARGS="$SERENITY_EXTRA_QEMU_ARGS -gdb tcp:${SERENITY_HOST_IP}:1234"
fi

if [ -z "$SERENITY_ETHERNET_DEVICE_TYPE" ]; then
  SERENITY_ETHERNET_DEVICE_TYPE="e1000"
fi

if [ "$SERENITY_ARCH" = "aarch64" ]; then
    SERENITY_NETFLAGS=
    SERENITY_NETFLAGS_WITH_DEFAULT_DEVICE=
else
    SERENITY_NETFLAGS="-netdev user,id=breh,hostfwd=tcp:${SERENITY_HOST_IP}:8888-10.0.2.15:8888,hostfwd=tcp:${SERENITY_HOST_IP}:8823-10.0.2.15:23,hostfwd=tcp:${SERENITY_HOST_IP}:8000-10.0.2.15:8000,hostfwd=tcp:${SERENITY_HOST_IP}:2222-10.0.2.15:22"
    SERENITY_NETFLAGS_WITH_DEFAULT_DEVICE="
    $SERENITY_NETFLAGS
    -device $SERENITY_ETHERNET_DEVICE_TYPE,netdev=breh
    "
fi

# add -machine vmport=off below to run the machine with ps/2 mouse
if [ -z "$SERENITY_MACHINE" ]; then
    if [ "$SERENITY_ARCH" = "aarch64" ]; then
        SERENITY_MACHINE="
        -M raspi3b
        -serial stdio
        "
    else
        SERENITY_MACHINE="
        -m $SERENITY_RAM_SIZE
        -smp $SERENITY_CPUS
        -display $SERENITY_QEMU_DISPLAY_BACKEND
        -device $SERENITY_QEMU_DISPLAY_DEVICE
        -device virtio-serial,max_ports=2
        -device virtconsole,chardev=stdout
        -device isa-debugcon,chardev=stdout
        -device virtio-rng-pci
        $SERENITY_AUDIO_BACKEND
        $SERENITY_AUDIO_PC_SPEAKER
        $SERENITY_AUDIO_DEVICE
        -device pci-bridge,chassis_nr=1,id=bridge1 -device $SERENITY_ETHERNET_DEVICE_TYPE,bus=bridge1
        -device i82801b11-bridge,bus=bridge1,id=bridge2 -device sdhci-pci,bus=bridge2
        -device i82801b11-bridge,id=bridge3 -device sdhci-pci,bus=bridge3
        -device ich9-ahci,bus=bridge3
        -chardev stdio,id=stdout,mux=on
        "
    fi
fi

if [ "$NATIVE_WINDOWS_QEMU" -ne "1" ]; then
    SERENITY_MACHINE="$SERENITY_MACHINE
    -qmp unix:qmp-sock,server,nowait"
fi

if [ "$SERENITY_ARCH" = "aarch64" ]; then
    SERENITY_KERNEL_AND_INITRD="
    -kernel Kernel/Kernel
    "
else
    SERENITY_KERNEL_AND_INITRD="
    -kernel Kernel/Prekernel/Prekernel
    -initrd Kernel/Kernel
    "
fi


[ -z "$SERENITY_COMMON_QEMU_ARGS" ] && SERENITY_COMMON_QEMU_ARGS="
$SERENITY_EXTRA_QEMU_ARGS
$SERENITY_MACHINE
$SERENITY_BOOT_DRIVE
-cpu $SERENITY_QEMU_CPU
-name SerenityOS
-d guest_errors
-usb
$SERENITY_SPICE_SERVER_CHARDEV
"

if [ "$SERENITY_ARCH" != "aarch64" ]; then
    if [ "${SERENITY_SPICE}" ] && "${SERENITY_QEMU_BIN}" -chardev help | grep -iq spice; then
        SERENITY_COMMON_QEMU_ARGS="$SERENITY_COMMON_QEMU_ARGS
        -spice port=5930,agent-mouse=off,disable-ticketing=on
        "
    fi
    if "${SERENITY_QEMU_BIN}" -chardev help | grep -iq 'spice\|vdagent'; then
        SERENITY_COMMON_QEMU_ARGS="$SERENITY_COMMON_QEMU_ARGS
        -device virtserialport,chardev=vdagent,nr=1
        "
    fi
fi

[ -z "$SERENITY_COMMON_QEMU_ISA_PC_ARGS" ] && SERENITY_COMMON_QEMU_ISA_PC_ARGS="
$SERENITY_EXTRA_QEMU_ARGS
-m $SERENITY_RAM_SIZE
-cpu qemu64
-machine isapc
-d guest_errors
-device isa-vga
-chardev stdio,id=stdout,mux=on
-device isa-debugcon,chardev=stdout
$SERENITY_BOOT_DRIVE
"

[ -z "$SERENITY_COMMON_QEMU_MICROVM_ARGS" ] && SERENITY_COMMON_QEMU_MICROVM_ARGS="
$SERENITY_EXTRA_QEMU_ARGS
-m $SERENITY_RAM_SIZE
-machine microvm,pit=on,rtc=on,pic=on
-cpu qemu64
-d guest_errors
-chardev stdio,id=stdout,mux=on
-device isa-debugcon,chardev=stdout
-device isa-vga
-device isa-ide
$SERENITY_BOOT_DRIVE
-device i8042 
-device ide-hd,drive=disk
"

[ -z "$SERENITY_COMMON_QEMU_Q35_ARGS" ] && SERENITY_COMMON_QEMU_Q35_ARGS="
$SERENITY_EXTRA_QEMU_ARGS
-m $SERENITY_RAM_SIZE
-cpu $SERENITY_QEMU_CPU
-machine q35
-d guest_errors
-smp $SERENITY_CPUS
-vga none
-device vmware-svga
-device ich9-usb-ehci1,bus=pcie.0,multifunction=on,addr=0x5.0x0
-device ich9-usb-ehci2,bus=pcie.0,addr=0x5.0x2
-device ich9-usb-uhci1,bus=pcie.0,multifunction=on,addr=0x7.0x0
-device ich9-usb-uhci2,bus=pcie.0,addr=0x7.0x1
-device ich9-usb-uhci3,bus=pcie.0,addr=0x7.0x2
-device ich9-usb-uhci4,bus=pcie.0,addr=0x7.0x3
-device ich9-usb-uhci5,bus=pcie.0,addr=0x7.0x4
-device ich9-usb-uhci6,bus=pcie.0,addr=0x7.0x5
-device pcie-root-port,port=0x10,chassis=1,id=pcie.1,bus=pcie.0,multifunction=on,addr=0x6
-device pcie-root-port,port=0x11,chassis=2,id=pcie.2,bus=pcie.0,addr=0x6.0x1
-device pcie-root-port,port=0x12,chassis=3,id=pcie.3,bus=pcie.0,addr=0x6.0x2
-device pcie-root-port,port=0x13,chassis=4,id=pcie.4,bus=pcie.0,addr=0x6.0x3
-device pcie-root-port,port=0x14,chassis=5,id=pcie.5,bus=pcie.0,addr=0x6.0x4
-device pcie-root-port,port=0x15,chassis=6,id=pcie.6,bus=pcie.0,addr=0x6.0x5
-device pcie-root-port,port=0x16,chassis=7,id=pcie.7,bus=pcie.0,addr=0x6.0x6
-device pcie-root-port,port=0x17,chassis=8,id=pcie.8,bus=pcie.0,addr=0x6.0x7
-device ich9-intel-hda,bus=pcie.2,addr=0x03.0x0
-device bochs-display
-device nec-usb-xhci,bus=pcie.2,addr=0x11.0x0
-device pci-bridge,chassis_nr=1,id=bridge1,bus=pcie.4,addr=0x3.0x0
-device sdhci-pci,bus=bridge1,addr=0x1.0x0
-display $SERENITY_QEMU_DISPLAY_BACKEND
-device virtio-serial
-chardev stdio,id=stdout,mux=on
-device virtconsole,chardev=stdout
-device isa-debugcon,chardev=stdout
-device virtio-rng-pci
$SERENITY_AUDIO_BACKEND
$SERENITY_AUDIO_PC_SPEAKER
$SERENITY_BOOT_DRIVE
"

export SDL_VIDEO_X11_DGAMOUSE=0

: "${SERENITY_BUILD:=.}"
cd -P -- "$SERENITY_BUILD" || die "Could not cd to \"$SERENITY_BUILD\""

if [ "$SERENITY_RUN" = "b" ]; then
    # Meta/run.sh b: bochs
    [ -z "$SERENITY_BOCHSRC" ] && {
        # Make sure that SERENITY_SOURCE_DIR is set and not empty
        [ -z "$SERENITY_SOURCE_DIR" ] && die 'SERENITY_SOURCE_DIR not set or empty'
        SERENITY_BOCHSRC="$SERENITY_SOURCE_DIR/Meta/bochsrc"
    }
    "$SERENITY_BOCHS_BIN" -q -f "$SERENITY_BOCHSRC"
elif [ "$SERENITY_RUN" = "qn" ]; then
    # Meta/run.sh qn: qemu without network
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_ARGS \
        -device $SERENITY_ETHERNET_DEVICE_TYPE \
        $SERENITY_KERNEL_AND_INITRD \
        -append "${SERENITY_KERNEL_CMDLINE}"
elif [ "$SERENITY_RUN" = "qtap" ]; then
    # Meta/run.sh qtap: qemu with tap
    sudo ip tuntap del dev tap0 mode tap || true
    sudo ip tuntap add dev tap0 mode tap user "$(id -u)"
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_ARGS \
        $SERENITY_VIRT_TECH_ARG \
        $SERENITY_PACKET_LOGGING_ARG \
        -netdev tap,ifname=tap0,id=br0 \
        -device $SERENITY_ETHERNET_DEVICE_TYPE,netdev=br0 \
        $SERENITY_KERNEL_AND_INITRD \
        -append "${SERENITY_KERNEL_CMDLINE}"
    sudo ip tuntap del dev tap0 mode tap
elif [ "$SERENITY_RUN" = "qgrub" ] || [ "$SERENITY_RUN" = "qextlinux" ]; then
    # Meta/run.sh qgrub: qemu with grub/extlinux
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_ARGS \
        $SERENITY_VIRT_TECH_ARG \
        $SERENITY_PACKET_LOGGING_ARG \
        $SERENITY_NETFLAGS_WITH_DEFAULT_DEVICE
elif [ "$SERENITY_RUN" = "q35" ]; then
    # Meta/run.sh q35: qemu (q35 chipset) with SerenityOS
    echo "Starting SerenityOS with QEMU Q35 machine, Commandline: ${SERENITY_KERNEL_CMDLINE}"
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_Q35_ARGS \
        $SERENITY_VIRT_TECH_ARG \
        $SERENITY_NETFLAGS_WITH_DEFAULT_DEVICE \
        $SERENITY_KERNEL_AND_INITRD \
        -append "${SERENITY_KERNEL_CMDLINE}"
elif [ "$SERENITY_RUN" = "isapc" ]; then
    # Meta/run.sh q35: qemu (q35 chipset) with SerenityOS
    echo "Starting SerenityOS with QEMU ISA-PC machine, Commandline: ${SERENITY_KERNEL_CMDLINE}"
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_ISA_PC_ARGS \
        $SERENITY_VIRT_TECH_ARG \
        $SERENITY_NETFLAGS \
        -device ne2k_isa,netdev=breh \
        $SERENITY_KERNEL_AND_INITRD \
        -append "${SERENITY_KERNEL_CMDLINE}"
elif [ "$SERENITY_RUN" = "microvm" ]; then
    # Meta/run.sh q35: qemu (q35 chipset) with SerenityOS
    echo "Starting SerenityOS with QEMU MicroVM machine, Commandline: ${SERENITY_KERNEL_CMDLINE}"
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_MICROVM_ARGS \
        $SERENITY_VIRT_TECH_ARG \
        $SERENITY_NETFLAGS \
        -device ne2k_isa,netdev=breh \
        $SERENITY_KERNEL_AND_INITRD \
        -append "${SERENITY_KERNEL_CMDLINE}"
elif [ "$SERENITY_RUN" = "q35grub" ]; then
    # Meta/run.sh q35grub: qemu (q35 chipset) with SerenityOS, using a grub disk image
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_Q35_ARGS \
        $SERENITY_VIRT_TECH_ARG \
        $SERENITY_NETFLAGS_WITH_DEFAULT_DEVICE
elif [ "$SERENITY_RUN" = "limine" ]; then
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_ARGS \
        $SERENITY_VIRT_TECH_ARG
elif [ "$SERENITY_RUN" = "ci" ]; then
    # Meta/run.sh ci: qemu in text mode
    echo "Running QEMU in CI"
    if [ "$SERENITY_ARCH" = "aarch64" ]; then
      "$SERENITY_QEMU_BIN" \
            $SERENITY_EXTRA_QEMU_ARGS \
            $SERENITY_VIRT_TECH_ARG \
            $SERENITY_BOOT_DRIVE \
            -M raspi3b \
            -d guest_errors \
            -no-reboot \
            -nographic \
            -monitor none \
            -display none \
            -serial file:debug.log \
            -serial stdio \
            $SERENITY_KERNEL_AND_INITRD \
            -append "${SERENITY_KERNEL_CMDLINE}"
    else
        "$SERENITY_QEMU_BIN" \
            $SERENITY_EXTRA_QEMU_ARGS \
            $SERENITY_VIRT_TECH_ARG \
            $SERENITY_BOOT_DRIVE \
            -m $SERENITY_RAM_SIZE \
            -cpu $SERENITY_QEMU_CPU \
            -d guest_errors \
            -no-reboot \
            -smp ${SERENITY_CPUS} \
            -device ich9-ahci \
            -nographic \
            -display none \
            -debugcon file:debug.log \
            $SERENITY_KERNEL_AND_INITRD \
            -append "${SERENITY_KERNEL_CMDLINE}"
    fi
else
    # Meta/run.sh: qemu with user networking
    "$SERENITY_QEMU_BIN" \
        $SERENITY_COMMON_QEMU_ARGS \
        $SERENITY_VIRT_TECH_ARG \
        $SERENITY_PACKET_LOGGING_ARG \
        $SERENITY_NETFLAGS_WITH_DEFAULT_DEVICE \
        $SERENITY_KERNEL_AND_INITRD \
        -append "${SERENITY_KERNEL_CMDLINE}"
fi