mirror of
git://git.yoctoproject.org/poky.git
synced 2025-07-19 21:09:03 +02:00
7911ec5de9
runqemu-internal is sourced so should be returning with an error code in case of errors. runqemu needs to deal with this. This patch fixes up the various error paths so we're consistent and get a sane exit status for runqemu which helps a lot in its use in the qemu runtime testing on the autobuilder. (From OE-Core rev: 22a54741167dd6cc011a1b98787c82cc992158ed) Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
426 lines
14 KiB
Bash
Executable File
426 lines
14 KiB
Bash
Executable File
#!/bin/bash
|
|
#
|
|
# Handle running OE images standalone with QEMU
|
|
#
|
|
# Copyright (C) 2006-2011 Linux Foundation
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License version 2 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; if not, write to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
usage() {
|
|
MYNAME=`basename $0`
|
|
echo ""
|
|
echo "Usage: you can run this script with any valid combination"
|
|
echo "of the following options (in any order):"
|
|
echo " QEMUARCH - the qemu machine architecture to use"
|
|
echo " KERNEL - the kernel image file to use"
|
|
echo " ROOTFS - the rootfs image file or nfsroot directory to use"
|
|
echo " MACHINE - the machine name (optional, autodetected from KERNEL filename if unspecified)"
|
|
echo " RAMFS - boot a ramfs-based image"
|
|
echo " Simplified QEMU command-line options can be passed with:"
|
|
echo " nographic - disables video console"
|
|
echo " serial - enables a serial console on /dev/ttyS0"
|
|
echo " kvm - enables KVM when running qemux86/qemux86-64 (VT-capable CPU required)"
|
|
echo " qemuparams=\"xyz\" - specify custom parameters to QEMU"
|
|
echo " bootparams=\"xyz\" - specify custom kernel parameters during boot"
|
|
echo ""
|
|
echo "Examples:"
|
|
echo " $MYNAME qemuarm"
|
|
echo " $MYNAME qemux86-64 core-image-sato ext3"
|
|
echo " $MYNAME path/to/bzImage-qemux86.bin path/to/nfsrootdir/ serial"
|
|
echo " $MYNAME qemux86 ramfs"
|
|
echo " $MYNAME qemux86 qemuparams=\"-m 256\""
|
|
echo " $MYNAME qemux86 bootparams=\"psplash=false\""
|
|
exit 1
|
|
}
|
|
|
|
if [ "x$1" = "x" ]; then
|
|
usage
|
|
fi
|
|
|
|
error() {
|
|
echo "Error: "$*
|
|
usage
|
|
}
|
|
|
|
MACHINE=${MACHINE:=""}
|
|
KERNEL=${KERNEL:=""}
|
|
ROOTFS=${ROOTFS:=""}
|
|
FSTYPE=""
|
|
LAZY_ROOTFS=""
|
|
SCRIPT_QEMU_OPT=""
|
|
SCRIPT_QEMU_EXTRA_OPT=""
|
|
SCRIPT_KERNEL_OPT=""
|
|
|
|
# Determine whether the file is a kernel or QEMU image, and set the
|
|
# appropriate variables
|
|
process_filename() {
|
|
filename=$1
|
|
|
|
# Extract the filename extension
|
|
EXT=`echo $filename | awk -F . '{ print \$NF }'`
|
|
case /$EXT/ in
|
|
/bin/)
|
|
# A file ending in .bin is a kernel
|
|
[ -z "$KERNEL" ] && KERNEL=$filename || \
|
|
error "conflicting KERNEL args [$KERNEL] and [$filename]"
|
|
;;
|
|
/ext[234]/|/jffs2/|/btrfs/)
|
|
# A file ending in a supportted fs type is a rootfs image
|
|
if [ -z "$FSTYPE" -o "$FSTYPE" = "$EXT" ]; then
|
|
FSTYPE=$EXT
|
|
ROOTFS=$filename
|
|
else
|
|
error "conflicting FSTYPE types [$FSTYPE] and [$EXT]"
|
|
fi
|
|
;;
|
|
*)
|
|
error "unknown file arg [$filename]"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Parse command line args without requiring specific ordering. It's a
|
|
# bit more complex, but offers a great user experience.
|
|
KVM_ENABLED="no"
|
|
while true; do
|
|
arg=${1}
|
|
case "$arg" in
|
|
"qemux86" | "qemux86-64" | "qemuarm" | "qemumips" | "qemumipsel" | "qemumips64" | "qemush4" | "qemuppc")
|
|
[ -z "$MACHINE" ] && MACHINE=$arg || \
|
|
error "conflicting MACHINE types [$MACHINE] and [$arg]"
|
|
;;
|
|
"ext2" | "ext3" | "ext4" | "jffs2" | "nfs" | "btrfs")
|
|
[ -z "$FSTYPE" -o "$FSTYPE" = "$arg" ] && FSTYPE=$arg || \
|
|
error "conflicting FSTYPE types [$FSTYPE] and [$arg]"
|
|
;;
|
|
*-image*)
|
|
[ -z "$ROOTFS" ] || \
|
|
error "conflicting ROOTFS args [$ROOTFS] and [$arg]"
|
|
if [ -f "$arg" ]; then
|
|
process_filename $arg
|
|
elif [ -d "$arg" ]; then
|
|
# Handle the case where the nfsroot dir has -image-
|
|
# in the pathname
|
|
echo "Assuming $arg is an nfs rootfs"
|
|
FSTYPE=nfs
|
|
ROOTFS=$arg
|
|
else
|
|
ROOTFS=$arg
|
|
LAZY_ROOTFS="true"
|
|
fi
|
|
;;
|
|
"ramfs")
|
|
FSTYPE=cpio.gz
|
|
RAMFS=true
|
|
;;
|
|
"nographic")
|
|
SCRIPT_QEMU_OPT="$SCRIPT_QEMU_OPT -nographic"
|
|
SCRIPT_KERNEL_OPT="$SCRIPT_KERNEL_OPT console=ttyS0"
|
|
;;
|
|
"serial")
|
|
SCRIPT_QEMU_OPT="$SCRIPT_QEMU_OPT -serial stdio"
|
|
SCRIPT_KERNEL_OPT="$SCRIPT_KERNEL_OPT console=ttyS0"
|
|
;;
|
|
"qemuparams="*)
|
|
SCRIPT_QEMU_EXTRA_OPT="${arg##qemuparams=}"
|
|
|
|
# Warn user if they try to specify serial or kvm options
|
|
# to use simplified options instead
|
|
serial_option=`expr "$SCRIPT_QEMU_EXTRA_OPT" : '.*\(-serial\)'`
|
|
kvm_option=`expr "$SCRIPT_QEMU_EXTRA_OPT" : '.*\(-enable-kvm\)'`
|
|
[ ! -z "$serial_option" -o ! -z "$kvm_option" ] && \
|
|
error "Please use simplified serial or kvm options instead"
|
|
;;
|
|
"bootparams="*)
|
|
SCRIPT_KERNEL_OPT="$SCRIPT_KERNEL_OPT ${arg##bootparams=}"
|
|
;;
|
|
"audio")
|
|
if [ "x$MACHINE" = "xqemux86" -o "x$MACHINE" = "xqemux86-64" ]; then
|
|
echo "Enabling audio in qemu."
|
|
echo "Please install snd_intel8x0 or snd_ens1370 driver in linux guest."
|
|
QEMU_AUDIO_DRV="alsa"
|
|
SCRIPT_QEMU_OPT="$SCRIPT_QEMU_OPT -soundhw ac97,es1370"
|
|
fi
|
|
;;
|
|
"kvm")
|
|
KVM_ENABLED="yes"
|
|
KVM_CAPABLE=`grep -q 'vmx\|svm' /proc/cpuinfo && echo 1`
|
|
;;
|
|
"") break ;;
|
|
*)
|
|
# A directory name is an nfs rootfs
|
|
if [ -d "$arg" ]; then
|
|
echo "Assuming $arg is an nfs rootfs"
|
|
if [ -z "$FSTYPE" -o "$FSTYPE" = "nfs" ]; then
|
|
FSTYPE=nfs
|
|
else
|
|
error "conflicting FSTYPE types [$arg] and nfs"
|
|
fi
|
|
|
|
if [ -z "$ROOTFS" ]; then
|
|
ROOTFS=$arg
|
|
else
|
|
error "conflicting ROOTFS args [$ROOTFS] and [$arg]"
|
|
fi
|
|
elif [ -f "$arg" ]; then
|
|
process_filename $arg
|
|
else
|
|
error "unable to classify arg [$arg]"
|
|
fi
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
if [ ! -c /dev/net/tun ] ; then
|
|
echo "TUN control device /dev/net/tun is unavailable; you may need to enable TUN (e.g. sudo modprobe tun)"
|
|
exit 1
|
|
elif [ ! -w /dev/net/tun ] ; then
|
|
echo "TUN control device /dev/net/tun is not writable, please fix (e.g. sudo chmod 666 /dev/net/tun)"
|
|
exit 1
|
|
fi
|
|
|
|
# Report errors for missing combinations of options
|
|
if [ -z "$MACHINE" -a -z "$KERNEL" ]; then
|
|
error "you must specify at least a MACHINE or KERNEL argument"
|
|
fi
|
|
if [ "$FSTYPE" = "nfs" -a -z "$ROOTFS" ]; then
|
|
error "NFS booting without an explicit ROOTFS path is not yet supported"
|
|
fi
|
|
|
|
if [ -z "$MACHINE" ]; then
|
|
MACHINE=`basename $KERNEL | sed 's/.*\(qemux86-64\|qemux86\|qemuarm\|qemumips64\|qemumips\|qemuppc\|qemush4\).*/\1/'`
|
|
if [ -z "$MACHINE" ]; then
|
|
error "Unable to set MACHINE from kernel filename [$KERNEL]"
|
|
fi
|
|
echo "Set MACHINE to [$MACHINE] based on kernel [$KERNEL]"
|
|
fi
|
|
|
|
YOCTO_KVM_WIKI="https://wiki.yoctoproject.org/wiki/How_to_enable_KVM_for_Poky_qemu"
|
|
YOCTO_PARAVIRT_KVM_WIKI="https://wiki.yoctoproject.org/wiki/Running_an_x86_Yocto_Linux_image_under_QEMU_KVM"
|
|
# Detect KVM configuration
|
|
if [ "x$KVM_ENABLED" = "xyes" ]; then
|
|
if [ -z "$KVM_CAPABLE" ]; then
|
|
echo "You are trying to enable KVM on a cpu without VT support."
|
|
echo "Remove kvm from the command-line, or refer"
|
|
echo "$YOCTO_KVM_WIKI";
|
|
exit 1;
|
|
fi
|
|
if [ "x$MACHINE" != "xqemux86" -a "x$MACHINE" != "xqemux86-64" ]; then
|
|
echo "KVM only support x86 & x86-64. Remove kvm from the command-line";
|
|
exit 1;
|
|
fi
|
|
if [ ! -e /dev/kvm ]; then
|
|
echo "Missing KVM device. Have you inserted kvm modules?"
|
|
echo "For further help see:"
|
|
echo "$YOCTO_KVM_WIKI";
|
|
exit 1;
|
|
fi
|
|
if [ ! -e /dev/vhost-net ]; then
|
|
echo "Missing virtio net device. Have you inserted vhost-net module?"
|
|
echo "For further help see:"
|
|
echo "$YOCTO_PARAVIRT_KVM_WIKI";
|
|
exit 1;
|
|
fi
|
|
if [ -w /dev/kvm -a -r /dev/kvm ]; then
|
|
SCRIPT_QEMU_OPT="$SCRIPT_QEMU_OPT -enable-kvm -cpu host"
|
|
KVM_ACTIVE="yes"
|
|
else
|
|
echo "You have no rights on /dev/kvm."
|
|
echo "Please change the ownership of this file as described at:"
|
|
echo "$YOCTO_KVM_WIKI";
|
|
exit 1;
|
|
fi
|
|
if [ ! -w /dev/vhost-net -o ! -r /dev/vhost-net ]; then
|
|
echo "You have no rights on /dev/vhost-net."
|
|
echo "Please change the ownership of this file as described at:"
|
|
echo "$YOCTO_PARAVIRT_KVM_WIKI";
|
|
exit 1;
|
|
fi
|
|
fi
|
|
|
|
machine2=`echo $MACHINE | tr 'a-z' 'A-Z' | sed 's/-/_/'`
|
|
# MACHINE is now set for all cases
|
|
|
|
# Defaults used when these vars need to be inferred
|
|
QEMUX86_DEFAULT_KERNEL=bzImage-qemux86.bin
|
|
QEMUX86_DEFAULT_FSTYPE=ext3
|
|
|
|
QEMUX86_64_DEFAULT_KERNEL=bzImage-qemux86-64.bin
|
|
QEMUX86_64_DEFAULT_FSTYPE=ext3
|
|
|
|
QEMUARM_DEFAULT_KERNEL=zImage-qemuarm.bin
|
|
QEMUARM_DEFAULT_FSTYPE=ext3
|
|
|
|
QEMUMIPS_DEFAULT_KERNEL=vmlinux-qemumips.bin
|
|
QEMUMIPS_DEFAULT_FSTYPE=ext3
|
|
|
|
QEMUMIPSEL_DEFAULT_KERNEL=vmlinux-qemumipsel.bin
|
|
QEMUMIPSEL_DEFAULT_FSTYPE=ext3
|
|
|
|
QEMUMIPS64_DEFAULT_KERNEL=vmlinux-qemumips64.bin
|
|
QEMUMIPS64_DEFAULT_FSTYPE=ext3
|
|
|
|
QEMUSH4_DEFAULT_KERNEL=vmlinux-qemumips.bin
|
|
QEMUSH4_DEFAULT_FSTYPE=ext3
|
|
|
|
QEMUPPC_DEFAULT_KERNEL=vmlinux-qemuppc.bin
|
|
QEMUPPC_DEFAULT_FSTYPE=ext3
|
|
|
|
AKITA_DEFAULT_KERNEL=zImage-akita.bin
|
|
AKITA_DEFAULT_FSTYPE=jffs2
|
|
|
|
SPITZ_DEFAULT_KERNEL=zImage-spitz.bin
|
|
SPITZ_DEFAULT_FSTYPE=ext3
|
|
|
|
setup_tmpdir() {
|
|
if [ -z "$OE_TMPDIR" ]; then
|
|
# Try to get OE_TMPDIR from bitbake
|
|
type -P bitbake &>/dev/null || {
|
|
echo "In order for this script to dynamically infer paths";
|
|
echo "to kernels or filesystem images, you either need";
|
|
echo "bitbake in your PATH or to source oe-init-build-env";
|
|
echo "before running this script" >&2;
|
|
exit 1; }
|
|
|
|
# We have bitbake in PATH, get OE_TMPDIR from bitbake
|
|
OE_TMPDIR=`MACHINE=$MACHINE bitbake -e | grep ^TMPDIR=\" | cut -d '=' -f2 | cut -d '"' -f2`
|
|
if [ -z "$OE_TMPDIR" ]; then
|
|
# Check for errors from bitbake that the user needs to know about
|
|
BITBAKE_OUTPUT=`bitbake -e | wc -l`
|
|
if [ "$BITBAKE_OUTPUT" -eq "0" ]; then
|
|
echo "Error: this script needs to be run from your build directory,"
|
|
echo "or you need to explicitly set OE_TMPDIR in your environment"
|
|
else
|
|
echo "There was an error running bitbake to determine TMPDIR"
|
|
echo "Here is the output from 'bitbake -e':"
|
|
bitbake -e
|
|
fi
|
|
exit 1
|
|
fi
|
|
fi
|
|
}
|
|
|
|
setup_sysroot() {
|
|
# Toolchain installs set up $OECORE_NATIVE_SYSROOT in their
|
|
# environment script. If that variable isn't set, we're
|
|
# either in an in-tree build scenario or the environment
|
|
# script wasn't source'd.
|
|
if [ -z "$OECORE_NATIVE_SYSROOT" ]; then
|
|
setup_tmpdir
|
|
BUILD_ARCH=`uname -m`
|
|
BUILD_OS=`uname | tr '[A-Z]' '[a-z]'`
|
|
BUILD_SYS="$BUILD_ARCH-$BUILD_OS"
|
|
|
|
OECORE_NATIVE_SYSROOT=$OE_TMPDIR/sysroots/$BUILD_SYS
|
|
fi
|
|
}
|
|
|
|
# Locate a rootfs image to boot which matches our expected
|
|
# machine and fstype.
|
|
findimage() {
|
|
where=$1
|
|
machine=$2
|
|
extension=$3
|
|
|
|
# Sort rootfs candidates by modification time - the most
|
|
# recently created one is the one we most likely want to boot.
|
|
filenames=`ls -t $where/*-image*$machine.$extension 2>/dev/null | xargs`
|
|
for name in $filenames; do
|
|
case $name in
|
|
*core-image-sato* | \
|
|
*core-image-lsb* | \
|
|
*core-image-basic* | \
|
|
*core-image-minimal* )
|
|
ROOTFS=$name
|
|
return
|
|
;;
|
|
esac
|
|
done
|
|
|
|
echo "Couldn't find a $machine rootfs image in $where."
|
|
exit 1
|
|
}
|
|
|
|
if [ -e "$ROOTFS" -a -z "$FSTYPE" ]; then
|
|
# Extract the filename extension
|
|
EXT=`echo $ROOTFS | awk -F . '{ print \$NF }'`
|
|
if [ "x$EXT" = "xext2" -o "x$EXT" = "xext3" -o \
|
|
"x$EXT" = "xjffs2" -o "x$EXT" = "xbtrfs" ]; then
|
|
FSTYPE=$EXT
|
|
else
|
|
echo "Note: Unable to determine filesystem extension for $ROOTFS"
|
|
echo "We will use the default FSTYPE for $MACHINE"
|
|
# ...which is done further below...
|
|
fi
|
|
fi
|
|
|
|
if [ -z "$KERNEL" ]; then
|
|
setup_tmpdir
|
|
eval kernel_file=\$${machine2}_DEFAULT_KERNEL
|
|
KERNEL=$OE_TMPDIR/deploy/images/$kernel_file
|
|
|
|
if [ -z "$KERNEL" ]; then
|
|
error "Unable to determine default kernel for MACHINE [$MACHINE]"
|
|
fi
|
|
fi
|
|
# KERNEL is now set for all cases
|
|
|
|
if [ -z "$FSTYPE" ]; then
|
|
eval FSTYPE=\$${machine2}_DEFAULT_FSTYPE
|
|
|
|
if [ -z "$FSTYPE" ]; then
|
|
error "Unable to determine default fstype for MACHINE [$MACHINE]"
|
|
fi
|
|
fi
|
|
|
|
# FSTYPE is now set for all cases
|
|
|
|
# Handle cases where a ROOTFS type is given instead of a filename, e.g.
|
|
# core-image-sato
|
|
if [ "$LAZY_ROOTFS" = "true" ]; then
|
|
setup_tmpdir
|
|
echo "Assuming $ROOTFS really means $OE_TMPDIR/deploy/images/$ROOTFS-$MACHINE.$FSTYPE"
|
|
ROOTFS=$OE_TMPDIR/deploy/images/$ROOTFS-$MACHINE.$FSTYPE
|
|
fi
|
|
|
|
if [ -z "$ROOTFS" ]; then
|
|
setup_tmpdir
|
|
T=$OE_TMPDIR/deploy/images
|
|
eval rootfs_list=\$${machine2}_DEFAULT_ROOTFS
|
|
findimage $T $MACHINE $FSTYPE
|
|
|
|
if [ -z "$ROOTFS" ]; then
|
|
error "Unable to determine default rootfs for MACHINE [$MACHINE]"
|
|
fi
|
|
fi
|
|
# ROOTFS is now set for all cases
|
|
|
|
echo ""
|
|
echo "Continuing with the following parameters:"
|
|
echo "KERNEL: [$KERNEL]"
|
|
echo "ROOTFS: [$ROOTFS]"
|
|
echo "FSTYPE: [$FSTYPE]"
|
|
|
|
setup_sysroot
|
|
# OECORE_NATIVE_SYSROOT is now set for all cases
|
|
|
|
INTERNAL_SCRIPT="$0-internal"
|
|
if [ ! -f "$INTERNAL_SCRIPT" -o ! -r "$INTERNAL_SCRIPT" ]; then
|
|
INTERNAL_SCRIPT=`which runqemu-internal`
|
|
fi
|
|
|
|
. $INTERNAL_SCRIPT
|
|
exit $?
|