serenity/Meta/run.sh

555 lines
22 KiB
Bash
Raw Normal View History

#!/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"
2019-11-05 17:56:13 +00:00
# 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"
2022-10-03 23:48:37 +00:00
# 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.
2022-10-03 23:48:37 +00:00
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
2022-10-03 23:48:37 +00:00
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
2019-11-01 22:46:39 +00:00
2020-06-24 09:01:31 +00:00
[ -z "$SERENITY_DISK_IMAGE" ] && {
if [ "$SERENITY_RUN" = q35grub ] || [ "$SERENITY_RUN" = qgrub ]; then
2020-06-24 09:01:31 +00:00
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"
2020-06-24 09:01:31 +00:00
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
2020-06-24 09:01:31 +00:00
}
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
Kernel: Finish base implementation of VirtQueues This commit includes a lot of small changes and additions needed to finalize the base implementation of VirtIOQueues and VirtDevices: * The device specific driver implementation now has to handle setting up the queues it needs before letting the base device class know it finised initialization * Supplying buffers to VirtQueues is now done via ScatterGatherLists instead of arbitary buffer pointers - this ensures the pointers are physical and allows us to follow the specification in regards to the requirement that individual descriptors must point to physically contiguous buffers. This can be further improved in the future by implementating support for the Indirect-Descriptors feature (as defined by the specification) to reduce descriptor usage for very fragmented buffers. * When supplying buffers to a VirtQueue the driver must supply a (temporarily-)unique token (usually the supplied buffer's virtual address) to ensure the driver can discern which buffer has finished processing by the device in the case in which the device does not offer the F_IN_ORDER feature. * Device drivers now handle queue updates (supplied buffers being returned from the device) by implementing a single pure virtual method instead of setting a seperate callback for each queue * Two new VirtQueue methods were added to allow the device driver to either discard or get used/returned buffers from the device by cleanly removing them off the descriptor chain (This also allows the VirtQueue implementation to reuse those freed descriptors) This also includes the necessary changes to the VirtIOConsole implementation to match these interface changes. Co-authored-by: Sahan <sahan.h.fernando@gmail.com>
2021-04-15 09:39:48 +00:00
-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
"
2019-05-01 19:45:17 +00:00
export SDL_VIDEO_X11_DGAMOUSE=0
: "${SERENITY_BUILD:=.}"
cd -P -- "$SERENITY_BUILD" || die "Could not cd to \"$SERENITY_BUILD\""
if [ "$SERENITY_RUN" = "b" ]; then
2020-06-24 03:08:19 +00:00
# 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
2020-06-24 03:08:19 +00:00
# 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
2020-06-24 03:08:19 +00:00
# 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 \
2019-11-05 17:56:13 +00:00
$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 \
2019-11-05 17:56:13 +00:00
$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
2020-06-24 03:08:19 +00:00
# Meta/run.sh: qemu with user networking
"$SERENITY_QEMU_BIN" \
$SERENITY_COMMON_QEMU_ARGS \
$SERENITY_VIRT_TECH_ARG \
2019-11-05 17:56:13 +00:00
$SERENITY_PACKET_LOGGING_ARG \
$SERENITY_NETFLAGS_WITH_DEFAULT_DEVICE \
$SERENITY_KERNEL_AND_INITRD \
-append "${SERENITY_KERNEL_CMDLINE}"
fi