#!/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