mirror of
https://github.com/SerenityOS/serenity
synced 2024-09-06 17:06:31 +00:00
![Jelle Raaijmakers](/assets/img/avatar_default.png)
This broke in c2e24a2fa1
where the boot
drive was removed from `SERENITY_MACHINE`. We now add the boot drive to
the common Qemu arguments, so it gets included in the aarch64 run
configuration as well.
555 lines
22 KiB
Bash
Executable file
555 lines
22 KiB
Bash
Executable file
#!/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
|