File build-vm-kvm of Package build
#
# kvm/qemu specific functions
#
################################################################
#
# Copyright (c) 1995-2014 SUSE Linux Products GmbH
# Copyright (c) 2021 SUSE LLC
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 or 3 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program (see the file COPYING); if not, write to the
# Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#
################################################################
kvm_bin=/usr/bin/qemu-kvm
test ! -x $kvm_bin -a -x /usr/bin/kvm && kvm_bin=/usr/bin/kvm
kvm_console=ttyS0
# assume virtio support by default
kvm_device=virtio-blk-pci
kvm_device_opts=
kvm_drive_opts="cache=unsafe"
kvm_serial_device=
kvm_rng_device=virtio-rng-pci
kvm_options=
kvm_qemu_append="no-kvmclock"
kvm_cpu="-cpu host"
kvm_check_ppc970() {
if ! grep -q -E '(kvm_rma_count.*kvm_hpt_count)|(kvm_hpt_count.*kvm_rma_count)' /proc/cmdline ; then
cleanup_and_exit 3 "put kvm_rma_count=<VM number> or kvm_hpt_count=<> to your boot options"
fi
}
kvm_check_hugetlb() {
if ! grep -q "$HUGETLBFSPATH" /proc/mounts ; then
cleanup_and_exit 4 "hugetlbfs is not mounted to $HUGETLBFSPATH"
fi
local HUGETLBBLKSIZE=$(stat -f -c "%S" "$HUGETLBFSPATH")
HUGETLBBLKSIZE=$(( ${HUGETLBBLKSIZE:-0} / 1024 ))
if test "$HUGETLBBLKSIZE" -lt 1 -o ! -e "/sys/kernel/mm/hugepages/hugepages-${HUGETLBBLKSIZE}kB" ; then
cleanup_and_exit 4 "could not determine hugetlbfs block size"
fi
local PAGES_FREE=$(cat /sys/kernel/mm/hugepages/hugepages-${HUGETLBBLKSIZE}kB/free_hugepages)
local PAGES_REQ=$(( ${VM_MEMSIZE:-64} * 1024 / $HUGETLBBLKSIZE ))
if test "$PAGES_FREE" -lt "$PAGES_REQ" ; then
echo "expected $PAGES_REQ to be available (have $PAGES_FREE)"
echo "please adjust nr_hugepages"
cleanup_and_exit 4
fi
}
vm_verify_options_kvm() {
if test -n "$KILL" -o -n "$DO_WIPE" ; then
return
fi
vm_kernel=
vm_initrd=
vm_cmdline=
# newer Ubuntu versions have only kvm executable
if test -x "/usr/bin/kvm" -a ! -x "$kvm_bin"; then
kvm_bin="/usr/bin/kvm"
fi
# overwrite some options for specific host architectures
case `uname -m` in
armv7l)
kvm_bin="/usr/bin/qemu-system-arm"
kvm_console=ttyAMA0
kvm_options="-enable-kvm -M virt"
vm_kernel=/boot/zImage
vm_initrd=/boot/initrd
test -e /boot/kernel.obs.guest && vm_kernel=/boot/kernel.obs.guest
test -e /boot/initrd.obs.guest && vm_initrd=/boot/initrd.obs.guest
# prefer the guest kernel/initrd
test -e /boot/zImage.guest && vm_kernel=/boot/zImage.guest
test -e /boot/initrd.guest && vm_initrd=/boot/initrd.guest
kvm_device=virtio-blk-device
kvm_rng_device=virtio-rng-device
;;
armv8l|aarch64)
kvm_bin="/usr/bin/qemu-system-aarch64"
kvm_console=ttyAMA0
kvm_options="-enable-kvm"
vm_kernel=/boot/Image
vm_initrd=/boot/initrd
test -e /boot/kernel.obs.guest && vm_kernel=/boot/kernel.obs.guest
test -e /boot/initrd.obs.guest && vm_initrd=/boot/initrd.obs.guest
if test "${BUILD_ARCH#aarch}" != "$BUILD_ARCH" -o "${BUILD_ARCH#armv8}" != "$BUILD_ARCH"; then
test -e /boot/Image.guest && vm_kernel=/boot/Image.guest
test -e /boot/initrd.guest && vm_initrd=/boot/initrd.guest
else
# Running an armv7 kernel on aarch64
# prefer the guest kernel/initrd
test -e /boot/Image.guest32 && vm_kernel=/boot/Image.guest32
test -e /boot/initrd.guest32 && vm_initrd=/boot/initrd.guest32
fi
# We want to use the host gic version in order to make use
# of all available features (e.g. more than 8 CPUs) and avoid
# the emulation overhead of vGICv2 on a GICv3 host.
kvm_options="$kvm_options -M virt,accel=kvm,usb=off,gic-version=host -sandbox on"
kvm_device=virtio-blk-device
kvm_rng_device=virtio-rng-device
;;
ppc|ppcle|ppc64|ppc64le)
kvm_bin="/usr/bin/qemu-system-ppc64"
kvm_console=hvc0
kvm_options="-enable-kvm -M pseries"
if grep -q POWER8 /proc/cpuinfo ; then
# This option only exists with QEMU 5.0 or newer
if $kvm_bin -machine 'pseries,?' 2>&1 | grep -q cap-ccf-assist ; then
kvm_options="-enable-kvm -M pseries,cap-ccf-assist=off"
fi
fi
if grep -q "POWER9" /proc/cpuinfo; then
local backward_compability_hack
test -n "$BUILD_DIST" && backward_compability_hack=`queryconfig --dist "$BUILD_DIST" --configdir "$CONFIG_DIR" --archpath "$BUILD_ARCH" buildflags kvm-max-cpu-compat-power8`
if test -n "$backward_compability_hack" ; then
# old compability hack to limit the cpu guest to power8, even when running on power9
if $kvm_bin -machine 'help' 2>&1 | grep -q ^pseries-6; then
# This option has been changed in QEMU 2.10
kvm_options="-enable-kvm -M pseries,max-cpu-compat=power8"
else
kvm_cpu="-cpu host,compat=power8"
fi
fi
fi
grep -q PPC970MP /proc/cpuinfo && kvm_check_ppc970
vm_kernel=/boot/vmlinux
vm_initrd=/boot/initrd
test -e /boot/kernel.obs.guest && vm_kernel=/boot/kernel.obs.guest
test -e /boot/initrd.obs.guest && vm_initrd=/boot/initrd.obs.guest
if test "$BUILD_ARCH" = ppc64le -a -e /boot/vmlinuxle ; then
vm_kernel=/boot/vmlinuxle
vm_initrd=/boot/initrdle
fi
if test -e /boot/vmlinuxbe -a -e /boot/initrdbe ; then
if test "$BUILD_ARCH" = ppc -o "$BUILD_ARCH" = ppc64 ; then
vm_kernel=/boot/vmlinuxbe
vm_initrd=/boot/initrdbe
fi
fi
grep -q "pSeries" /proc/cpuinfo && kvm_device=scsi-hd # no virtio on pSeries
grep -q "PowerNV" /proc/cpuinfo || kvm_device=scsi-hd # no virtio on ppc != power7 yet
;;
s390|s390x)
kvm_bin="/usr/bin/qemu-system-s390x"
kvm_options="-enable-kvm"
kvm_console=hvc0
vm_kernel=/boot/image
vm_initrd=/boot/initrd
test -e /boot/kernel.obs.guest && vm_kernel=/boot/kernel.obs.guest
test -e /boot/initrd.obs.guest && vm_initrd=/boot/initrd.obs.guest
kvm_device=virtio-blk-ccw
kvm_serial_device=virtio-serial-ccw
kvm_rng_device=virtio-rng-ccw
;;
i586|i686|x86_64)
test ! -x $kvm_bin -a -x /usr/bin/qemu-system-x86_64 && kvm_bin=/usr/bin/qemu-system-x86_64
# build minimal machine - TODO enable sandbox on all architectures
# options to evaluate: mem-merge=off
kvm_options="-M pc,accel=kvm,usb=off,dump-guest-core=off,vmport=off -sandbox on"
# from qemu-microvm, minified and hardened PC bios (slightly faster than seabios)
test -e /usr/share/qemu/qboot.rom && kvm_options="$kvm_options -bios /usr/share/qemu/qboot.rom"
;;
esac
# check if we can run kvm
if ! test -r /dev/kvm ; then
cleanup_and_exit 4 "kvm device not accessible: either the kvm kernel-module is not loaded or hardware virtualization is deactivated in the BIOS."
fi
if ! test -x "$kvm_bin" ; then
cleanup_and_exit 4 "$kvm_bin is not installed"
fi
# check hugepages
test -n "$HUGETLBFSPATH" -a "$VM_TYPE" = kvm && kvm_check_hugetlb
# set kernel
test -n "$VM_KERNEL" && vm_kernel="$VM_KERNEL"
if test -z "$vm_kernel" ; then
vm_kernel=/boot/vmlinuz
test -e /boot/kernel.obs.guest && vm_kernel=/boot/kernel.obs.guest
fi
# set initrd
test -n "$VM_INITRD" && vm_initrd="$VM_INITRD"
test -n "$VM_CMDLINE" && vm_cmdline="$VM_CMDLINE"
if test -z "$vm_initrd" ; then
# find a nice default
if test -e /boot/initrd.obs.guest ; then
vm_initrd=/boot/initrd.obs.guest
elif test -e "/boot/initrd-build" ; then
vm_initrd="/boot/initrd-build"
elif test -e "/boot/initrd-virtio" ; then
vm_initrd="/boot/initrd-virtio"
else
vm_initrd="/boot/initrd"
kvm_device=ide-hd
# use /etc/sysconfig/kernel as indication if we have virtio
if test -e /etc/sysconfig/kernel ; then
local im=$(INITRD_MODULES=; . /etc/sysconfig/kernel; echo "$INITRD_MODULES")
if test "$im" != "${im/virtio/}" ; then
kvm_device=virtio-blk-pci
fi
fi
fi
fi
case $kvm_device in
virtio*)
VM_ROOTDEV=/dev/disk/by-id/virtio-0
VM_SWAPDEV=/dev/disk/by-id/virtio-1
kvm_qemu_append="kvmclock"
;;
*)
VM_ROOTDEV=/dev/sda
VM_SWAPDEV=/dev/sdb
;;
esac
if test -n "$VM_NETOPT" -o -n "$VM_NETDEVOPT" ; then
if test -n "$VM_NETOPT" ; then
for item in "${VM_NETOPT[@]}" ; do
kvm_options="$kvm_options -net $item"
done
fi
if test -n "$VM_NETDEVOPT" ; then
for item in "${VM_NETDEVOPT[@]}" ; do
kvm_options="$kvm_options -netdev $item"
done
fi
fi
if test -n "$VM_DEVICEOPT" ; then
for item in "${VM_DEVICEOPT[@]}" ; do
kvm_options="$kvm_options -device $item"
done
fi
if test -n "$kvm_rng_device" ; then
if test -c /dev/hwrng &&
test -w /dev/hwrng &&
test -f /sys/class/misc/hw_random/rng_current &&
test "$(cat /sys/class/misc/hw_random/rng_current)" != none; then
rng_dev="/dev/hwrng"
else
rng_dev="/dev/random"
fi
kvm_options="$kvm_options -object rng-random,filename=$rng_dev,id=rng0 -device $kvm_rng_device,rng=rng0"
fi
}
kvm_add_console_args() {
local serial_device="$1"
# the serial console device needs to be compiled into the target kernel
# which is why we can not use virtio-serial on other platforms
if test -n "$serial_device" ; then
if test -n "$VM_CONSOLE_INPUT" ; then
echo "Using virtio-serial support and enabling console input"
qemu_args=("${qemu_args[@]}" -device "$serial_device" -device virtconsole,chardev=virtiocon0 -chardev stdio,mux=on,id=virtiocon0 -mon chardev=virtiocon0)
else
echo "Using virtio-serial support"
qemu_args=("${qemu_args[@]}" -device "$serial_device" -device virtconsole,chardev=virtiocon0 -chardev stdio,id=virtiocon0)
fi
elif test -n "$VM_CONSOLE_INPUT" ; then
echo "Enabling console input"
qemu_args=("${qemu_args[@]}" -serial mon:stdio)
else
echo "Using UART console"
qemu_args=("${qemu_args[@]}" -serial stdio)
fi
# setup the monitor
if ! test -e "${VM_ROOT}.qemu/monitor"; then
mkdir -p "${VM_ROOT}.qemu"
mkfifo "${VM_ROOT}.qemu/monitor"
test -n "$VM_USER" && chown "$VM_USER" "${VM_ROOT}.qemu"
fi
qemu_args=("${qemu_args[@]}" -chardev socket,id=monitor,server=on,wait=off,path="${VM_ROOT}.qemu/monitor" -mon chardev=monitor,mode=readline)
}
vm_startup_kvm() {
qemu_bin="$kvm_bin"
qemu_args=("$@" -drive file="$VM_ROOT",format=raw,if=none,id=disk,$kvm_drive_opts -device "$kvm_device$kvm_device_opts",drive=disk,serial=0)
if [ -n "$VM_USER" ] ; then
getent passwd "$VM_USER" > /dev/null || cleanup_and_exit 3 "cannot find KVM user '$VM_USER'"
elif test $UID = 0 ; then
# use qemu user by default if available
getent passwd qemu >/dev/null && VM_USER=qemu
fi
[ -n "$VM_USER" ] && kvm_options="$kvm_options -runas $VM_USER"
if test -n "$VM_SWAP" ; then
qemu_args=("${qemu_args[@]}" -drive file="$VM_SWAP",format=raw,if=none,id=swap,$kvm_drive_opts -device "$kvm_device$kvm_device_opts",drive=swap,serial=1)
fi
kvm_add_console_args "$kvm_serial_device"
# figure out kvm cpu based on possible provided hostarch file
case `uname -m` in
armv8l|aarch64)
if test "$BUILD_HOST_ARCH" != "aarch64" ; then
kvm_cpu="-cpu host,aarch64=off"
fi
;;
esac
if test -n "$BUILD_JOBS" -a "$icecream" = 0 -a -z "$BUILD_THREADS" ; then
qemu_args=("${qemu_args[@]}" "-smp" "$BUILD_JOBS")
elif test -n "$BUILD_JOBS" -a -n "$BUILD_THREADS" ; then
qemu_args=("${qemu_args[@]}" "-smp" "$BUILD_JOBS,threads=$BUILD_THREADS")
fi
if test "$VM_TYPE" = kvm ; then
test -n "$HUGETLBFSPATH" && kvm_options="$kvm_options -mem-prealloc -mem-path $HUGETLBFSPATH"
fi
qemu_append="root=$VM_ROOTDEV"
if test -n "$VMDISK_FILESYSTEM" ; then
qemu_append="$qemu_append rootfstype=$VMDISK_FILESYSTEM"
fi
if test -n "$VMDISK_MOUNT_OPTIONS" ; then
qemu_append="$qemu_append rootflags=${VMDISK_MOUNT_OPTIONS#-o }"
fi
if test -n "$vm_cmdline" ; then
qemu_append="$qemu_append $vm_cmdline"
else
# Pick sensible defaults
qemu_append="$qemu_append $kvm_qemu_append $vm_linux_kernel_parameter elevator=noop"
qemu_append="$qemu_append nmi_watchdog=0 rw rd.driver.pre=binfmt_misc"
fi
qemu_append="$qemu_append $vm_linux_always_append console=$kvm_console init=$vm_init_script"
if test -z "$VM_NETOPT" -a -z "$VM_NETDEVOPT"; then
kvm_options="$kvm_options -net none"
fi
if test -n "$VM_TELNET"; then
kvm_options="$kvm_options -netdev user,id=telnet,hostfwd=tcp:127.0.0.1:$VM_TELNET-:23 -device e1000,netdev=telnet"
fi
if test -n "$VM_CUSTOMOPT"; then
kvm_options="$kvm_options $VM_CUSTOMOPT"
fi
set -- $qemu_bin -nodefaults -no-reboot -nographic -vga none $kvm_cpu $kvm_options \
-kernel $vm_kernel \
-initrd $vm_initrd \
-append "$qemu_append" \
${VM_MEMSIZE:+-m $VM_MEMSIZE} \
"${qemu_args[@]}"
if test "$PERSONALITY" != 0 ; then
# have to switch back to PER_LINUX to make qemu work
set -- linux64 "$@"
fi
export QEMU_AUDIO_DRV=none # we do not want to have sound inside the VMs
echo "$@"
"$@"
qemu_ret=$?
test "$qemu_ret" = "137" && cleanup_and_exit 3 "qemu got SIGKILL"
test "$qemu_ret" = "143" && cleanup_and_exit 1 "qemu got SIGTERM"
}
vm_kill_kvm() {
if ! fuser -k -TERM "$VM_ROOT" ; then
echo "could not kill build in $VM_ROOT, kvm instance is dead already"
return
fi
local tries=0
while test $tries -lt 1800 ; do
sleep .1
fuser -s "$VM_ROOT" || return
tries=$(( $tries + 1 ))
done
fuser -k "$VM_ROOT"
}
vm_fixup_kvm() {
# check if we will use a kernel from the build root, in this case
# we assume the kernel does virtio
if test -z "$VM_KERNEL" -a -e "$BUILD_ROOT/.build.kernel.$VM_TYPE" ; then
# ide-hd is the non-virtio default
if test "$kvm_device" = ide-hd ; then
kvm_device=virtio-blk-pci
VM_ROOTDEV=/dev/disk/by-id/virtio-0
VM_SWAPDEV=/dev/disk/by-id/virtio-1
kvm_qemu_append="kvmclock"
fi
fi
if test "$VM_TYPE" = kvm -a -z "$kvm_serial_device" ; then
if test -f "$BUILD_ROOT/.build.console.kvm" -a ! -L "$BUILD_ROOT/.build.console.kvm" && grep -q '^virtio$' "$BUILD_ROOT/.build.console.kvm" ; then
echo "Detected virtio-serial support"
kvm_serial_device=virtio-serial,max_ports=2
kvm_console=hvc0
fi
fi
# move IO into separate I/O thread for some architectures
if test "${kvm_device%%-*}" = "virtio" ; then
if $kvm_bin -version | grep -F -q 7.1.0; then
echo "QEMU 7.1.0 detected: Skipping iothreads because of bsc#1204082"
else
kvm_options="$kvm_options -object iothread,id=io0"
kvm_device_opts=",iothread=io0"
fi
case $(uname -m) in
ppc|ppcle|ppc64|ppc64le)
# PowerPC currently not reliably working
# https://bugzilla.suse.com/show_bug.cgi?id=1200564
echo "Skipping io_uring on PowerPC because of bsc#1200564"
;;
*)
if ldd $kvm_bin | grep -E -q 'liburing.so.[2-9]' ; then
kvm_drive_opts="$kvm_drive_opts,aio=io_uring"
fi
;;
esac
fi
}
vm_attach_root_kvm() {
:
}
vm_attach_swap_kvm() {
:
}
vm_detach_root_kvm() {
:
}
vm_detach_swap_kvm() {
:
}
vm_cleanup_kvm() {
:
}
vm_sysrq_kvm() {
perl -e 'use Socket; socket(SOCK, PF_UNIX, SOCK_STREAM, 0) || die("socket: $!\n");
connect(SOCK, sockaddr_un($ARGV[0])) || die("connect: $!\n");
syswrite(SOCK, "$ARGV[1]\n");
shutdown(SOCK, 1);
my $output;
read(SOCK, $output, 8192);' "$VM_ROOT.qemu/monitor" "sendkey alt-print-$1"
}
vm_wipe_kvm() {
:
}
