path: root/build-vm-zvm

#
# z/VM specific functions
#
################################################################
#
# Copyright (c) 1995-2014 SUSE Linux Products GmbH
#
# 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
#
################################################################

# z/VM: use default kernel image from local machine
# lets go with the default parameters. However zvm_initrd will be a required parameter
#zvm_kernel=/boot/image
#zvm_initrd=/boot/initrd_worker
zvm_param="root=/dev/disk/by-path/ccw-0.0.0150-part1 hvc_iucv=8 console=hvc0"
zvm_mult_pass="THR4ME"
zvm_init_script="/.build/build"

#######################################################################################

# this once was in zvm_functions

zvm_fatal() {
    echo "$1"
    test -n "$ZVM_CLEANUP" && exit 1
    cleanup_and_exit 1
}

zvm_prevent_detach() {
    if test "$1" = "150" -o "$1" = "0150"; then
        zvm_fatal "don't detach local root"
    fi
}

zvm_memset() {
    # defining the worker also resets the operating system. Be careful
    # $1: user name
    # $2: amount in MB
    # Note, that this is also limited by the worker definition in the user directory
    if test -n "$2"; then
        if ! vmcp send $1 define storage ${2}M ; then
            zvm_fatal "Could not redefine storage of $1 to ${2}M"
        fi
    fi
}

zvm_logon() {
    # kill machine if it already runs
    # autolog machine
    # Needs machine name as $1
    if test -n "$1" ; then
        if $(vmcp q "$1" >& /dev/null) ; then
            vmcp force $1
            sleep 1
        fi
        if ! $(vmcp q "$1" >& /dev/null) ; then
            if ! $(vmcp xautolog $1 >& /dev/null) ; then
                zvm_fatal "Could not start machine $1. Is $1 defined in the user directory?"
            else
                # give the worker a moment to initialize
                sleep 2
                zvm_memset $1 $VM_MEMSIZE
		sleep 2
            fi
        fi
    fi
}

zvm_ipl() {
    # IPL worker. Needs user as $1 and ipl device as $2.
    if test -n "$1" -a -n "$2" ; then
        if ! $(vmcp q "$1" >& /dev/null); then
            zvm_fatal "User $1 not logged on."
        else
            if ! $(vmcp send $1 ipl $2); then
                 zvm_fatal "Could not send command to $1"
            fi
        fi
    else
        zvm_fatal "Not enough arguments for ipl. Need user and device number."
    fi
}


zvm_destroy() {
    # Destroy build. Done by killing the worker machine.
    # needs user as $1
    if test -n "$1"; then
        if ! $(vmcp force $1 ) ; then
            zvm_fatal "Could not force $1"
        fi
    fi
}

zvm_get_local_devnr() {
    # $1 is base address, either 150 or 250
    # $2 is worker number
    # there is room for up to 100 workers for this controlling guest, however in our setup I expect only up to 10 workers.
    #echo "Debug: zvm_get_local_devnr: arg1: $1 arg2: $2"
    if test "$2" -ge 100 ; then
        zvm_fatal "Not more than 100 workers supported by one controlling guest."
    fi
    if test "$1" = "0150" -o "$1" = "150" ; then 
        DEVNR=$((300+$2))
    else
        if test "$1" = "0250" -o "$1" = "250" ; then 
            DEVNR=$((400+$2))
        else
            zvm_fatal "The disk devices for root and swap must be 150 and 250 respectively."
        fi
    fi
    echo $DEVNR
}

zvm_volume_link_local() {
    # attach worker disk to local system as preparation for 
    # a) prepare worker for build
    # b) get rpms of the swap disk after build finished
    # disk must be detached from worker first
    # The following arguments are needed:
    # 1. Worker user name
    # 2. Worker disk device number
    # 3. Mult password for the disk
    # 4. Worker number to generate a uniq local device number
    if test -n "$4"; then
        DEVNR=$(zvm_get_local_devnr $2 $4)
        if ! vmcp link $1 $2 $DEVNR MW pass=THR4ME >& /dev/null ; then
            zvm_fatal "Could not link disk $2 from user $1 to local device $DEVNR."
        fi
        dasd_configure 0.0.0$DEVNR 1 0 >& /dev/null
	udevadm settle
        DEVICE=$(ls /sys/bus/ccw/devices/0.0.0$DEVNR/block/)
        if ! test -b /dev/${DEVICE}1 ; then
            zvm_fatal "The device /sys/bus/ccw/devices/0.0.0$DEVNR has not been setup correctly."
        fi
        echo "${DEVICE}1"
    else
        zvm_fatal "Not enough arguments given to volume_link_local."
    fi 
}

zvm_volume_detach_local() {
    # we need
    # 1. worker device number
    # 2. worker number
    DEVNR=$(zvm_get_local_devnr $1 $2)
    zvm_prevent_detach $DEVNR
    dasd_configure 0.0.0$DEVNR 0 0
    if ! vmcp detach $DEVNR >& /dev/null ; then
        zvm_fatal "Could not locally detach disk number $1 from worker $2"
    fi
}

zvm_volume_attach() {
    # link the local disk of the worker 
    # $1: user name
    # $2: disk device number
    # send link * nr nr
    if ! vmcp send $1 link \* $2 $2 ; then
        zvm_fatal "Could not link remote worker disk number $2 from user $1"
    fi 
}

zvm_volume_detach() {
    # send machine detach nr
    # $1: user name
    # $2: disk
    if ! vmcp send $1 detach $2 ; then
        zvm_fatal "Could not detach disk $2 on worker $1"
    fi
}

zvm_worker_init() {
    # 1. Worker user name
    # 2. Worker root device number
    # 3. Worker swap device number
    # 4. Worker number to generate a uniq local device number
    # Check for: 
    # - still mounted dasd
    # - configured dasd
    # - linked dasd
    # - reset worker with force and autolog 
    DEVNR_ROOT=$(zvm_get_local_devnr $2 $4) 
    DEVNR_SWAP=$(zvm_get_local_devnr $3 $4)
    # First, check for mounts:
    for DEVNR in $DEVNR_ROOT $DEVNR_SWAP ; do
        if test -d /sys/bus/ccw/devices/0.0.0$DEVNR/block ; then
            DEV=$(ls /sys/bus/ccw/devices/0.0.0$DEVNR/block/)
            echo "Found device of worker $1 available at $DEVNR, device is /dev/$DEV."
            grep "/dev/$DEV" /proc/mounts >& /dev/null && umount /dev/${DEV}1
        fi
    done
    # Second, check if devices are online
    for DEVNR in $DEVNR_ROOT $DEVNR_SWAP ; do
        lsdasd $DEVNR | grep $DEVNR && dasd_configure 0.0.0$DEVNR 0 0
    done
    # Third, remove stale links
    for DEVNR in $DEVNR_ROOT $DEVNR_SWAP ; do
        zvm_prevent_detach $DEVNR
        if vmcp q v $DEVNR 2> /dev/null ; then
            vmcp detach $DEVNR
        fi
    done
    # Fourth, reset worker
    zvm_logon $1
}

zvm_cp() {
    modprobe vmcp || zvm_fatal "Cannod load vmcp module"
    if test -n "$1" ; then
        case "$1" in 
            start)                shift ; zvm_logon "$@"         ;;
            ipl)                  shift ; zvm_ipl "$@"           ;;
            destroy)              shift ; zvm_destroy "$@"       ;;
            volume_attach)        shift ; zvm_volume_attach "$@" ;;
            volume_detach)        shift ; zvm_volume_detach "$@" ;;
            volume_link_local)    shift ; zvm_volume_link_local "$@" ;;
            volume_detach_local)  shift ; zvm_volume_detach_local "$@" ;;
            memset)               shift ; zvm_memset "$@"        ;;
            worker_init)          shift ; zvm_worker_init "$@"   ;;
        esac
    fi
}

#######################################################################################

vm_verify_options_zvm() {
    VM_IMAGE=/dev/dasda1
    VM_SWAP=/dev/dasdb1

    VM_SWAPDEV=/dev/dasdb1	# in the vm

    if test -z "$VM_VOLUME_ROOT" ; then
	if test -n "$BUILD_ROOT" -a ${#BUILD_ROOT} -le 4 ; then
	    VM_VOLUME_ROOT="$BUILD_ROOT"
	else
	    VM_VOLUME_ROOT="0150"
	fi
    fi
    # In z/VM, this is a 4 digit hex number instead of a linux device.
    # This is the swap disk defined in user direct
    # This number can be given with the parameter --swap NR.
    if test -z "$VM_VOLUME_SWAP" ; then
	if test -n "$VM_SWAP" -a ${#VM_SWAP} -le 4 ; then
	    VM_VOLUME_SWAP="$VM_SWAP"
	else
	    VM_VOLUME_SWAP="0250"
	fi
    fi
    # z/VM guest name that is already defined in z/VM
    if test -z "$VM_WORKER" ; then
	echo "ERROR: No z/VM worker id specified"
	cleanup_and_exit 3
    fi
    if test -z "$VM_WORKER_NR" ; then
	echo "ERROR: No z/VM worker number specified"
	cleanup_and_exit 3
    fi
    # need the name for a kernel in zvm
    if test -n "$VM_KERNEL" ; then
	vm_kernel="$VM_KERNEL"
    elif test -e "/boot/vmlinux.gz" ; then
	vm_kernel="/boot/vmlinux.gz"
    else
	echo "ERROR: No z/VM kernel specified"
	cleanup_and_exit 3
    fi
    # need the name for an initrd in zvm
    # this normally will not be the local initrd
    if test -n "$VM_INITRD" ; then
	vm_initrd="$VM_INITRD"
    else
	echo "ERROR: No z/VM initrd specified"
	cleanup_and_exit 3
    fi
    zvm_cp worker_init $VM_WORKER $VM_VOLUME_ROOT $VM_VOLUME_SWAP $VM_WORKER_NR
    zvm_cp volume_detach $VM_WORKER $VM_VOLUME_ROOT
    zvm_cp volume_detach $VM_WORKER $VM_VOLUME_SWAP
}

vm_startup_zvm() {
    # link root/swap to the worker
    zvm_cp volume_attach $VM_WORKER $VM_VOLUME_ROOT
    zvm_cp volume_attach $VM_WORKER $VM_VOLUME_SWAP
    zvm_cp ipl $VM_WORKER $VM_VOLUME_ROOT
    # start IUCV Console
    # IPL needs some time until IPL really starts...
    sleep 2
    # start iucv console. This blocks until build process is finished.
    iucvconn $VM_WORKER lnxhvc0
    # sleep some time before taking root and swap devices from worker
    # This might be critical regarding timing (IUCV_CONSOLE down, but machine still running)
    sleep 5
    zvm_cp volume_detach $VM_WORKER $VM_VOLUME_ROOT
    zvm_cp volume_detach $VM_WORKER $VM_VOLUME_SWAP
}

vm_kill_zvm() {
    if vmcp q "$VM_WORKER" > /dev/null 2>&1 ; then
	if ! zvm_cp destroy $VM_WORKER ; then
	    echo "could not kill zvm worker $VM_WORKER"
	    cleanup_and_exit 1
	fi
    fi
}

vm_fixup_zvm() {
    # initrd is created in obsstoragesetup.
    # If it is desired to use a project dependent kernel, use make_guestinitrd from zvm_functions.
    # have to copy kernel/initrd and run zipl to be able to IPL
    # have to set init_script before unmounting, thus doing it statically for now.
    zvm_init_script="/.build/build"
    mkdir -p $BUILD_ROOT/boot
    cp $vm_kernel $vm_initrd $BUILD_ROOT/boot
    mkdir -p $BUILD_ROOT/boot/zipl
    # finally, install bootloader to the worker disk
    zipl -t $BUILD_ROOT/boot/zipl -i ${BUILD_ROOT}${vm_kernel} -r ${BUILD_ROOT}${vm_initrd} \
	--parameters "${zvm_param} init=$zvm_init_script rootfsopts=noatime"
}

vm_attach_root_zvm() {
    VM_IMAGE=$(ZVM_CLEANUP=1 zvm_cp volume_link_local $VM_WORKER $VM_VOLUME_ROOT $zvm_mult_pass $VM_WORKER_NR )
    if test "${VM_IMAGE}" = "${VM_IMAGE#dasd}" ; then
	echo "did not get a real device for VM_IMAGE: $VM_IMAGE"
	cleanup_and_exit 3
    fi
    VM_IMAGE="/dev/$VM_IMAGE"
}

vm_attach_swap_zvm() {
    VM_SWAP=$(ZVM_CLEANUP=1 zvm_cp volume_link_local $VM_WORKER $VM_VOLUME_SWAP $zvm_mult_pass $VM_WORKER_NR )
    if test "${VM_SWAP}" = "${VM_SWAP#dasd}" ; then
	echo "did not get a real device for VM_SWAP: $VM_SWAP"
	cleanup_and_exit 3
    fi
    VM_SWAP="/dev/$VM_SWAP"
}

vm_detach_root_zvm () {
    zvm_cp volume_detach_local $VM_VOLUME_ROOT $VM_WORKER_NR
}

vm_detach_swap_zvm() {
    zvm_cp volume_detach_local $VM_VOLUME_SWAP $VM_WORKER_NR
}

vm_cleanup_zvm() {
    if test -n "$VM_WORKER" -a -n "$VM_WORKER_NR" -a -n "$VM_VOLUME_ROOT" -a -n "$VM_VOLUME_SWAP" ; then
	ZVM_CLEANUP=1
	(zvm_cp volume_detach $VM_WORKER $VM_VOLUME_ROOT >/dev/null 2>&1)
	(zvm_cp volume_detach $VM_WORKER $VM_VOLUME_SWAP >/dev/null 2>&1)
	(zvm_cp volume_detach_local $VM_VOLUME_ROOT $VM_WORKER_NR >/dev/null 2>&1)
	(zvm_cp volume_detach_local $VM_VOLUME_SWAP $VM_WORKER_NR >/dev/null 2>&1)
    fi
}