source: trunk/packages/xen-common/xen-common/debian/xen-utils-common.xendomains.init @ 77

#!/bin/bash
### BEGIN INIT INFO
# Provides:          xendomains
# Required-Start:    $syslog $remote_fs xend
# Should-Start:
# Required-Stop:     $syslog $remote_fs xend
# Should-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:      S 0 1 6
# Default-Enabled:   yes
# Short-Description: Start/stop secondary xen domains
# Description:       Start / stop domains automatically when domain 0 
#                    boots / shuts down.
### END INIT INFO

PATH=/usr/lib/xen-common/bin:/sbin:/bin:/usr/sbin:/usr/bin
VERSION=$(xen-utils-version -q 2>/dev/null || true)
ROOT=/usr/lib/xen-$VERSION

test "$VERSION" || exit 0
test -e /proc/xen/privcmd || exit 0
grep -q "control_d" /proc/xen/capabilities || exit 0

LOCKFILE=/var/lock/xendomains
XENDOM_CONFIG=/etc/default/xendomains

test -r $XENDOM_CONFIG || { echo "$XENDOM_CONFIG not existing";
        if [ "$1" = "stop" ]; then exit 0;
        else exit 6; fi; }

. $XENDOM_CONFIG

_cmd=$1
declare -a _SMSG
if test "${_cmd}" = "status"; then
    _SMSG=(running dead dead unused unknown)
    _RC_UNUSED=3
else
    _SMSG=(done failed failed missed failed skipped unused failed failed)
    _RC_UNUSED=6
fi
. /lib/lsb/init-functions
echo_rc()
{
    if test ${_RC_RV} = 0; then
        log_success_msg "  [${_SMSG[${_RC_RV}]}] "
    else
        log_failure_msg "  [${_SMSG[${_RC_RV}]}] "
    fi
}
rc_reset() { _RC_RV=0; }
rc_failed()
{
    if test -z "$1"; then 
        _RC_RV=1;
    elif test "$1" != "0"; then 
        _RC_RV=$1; 
    fi
    return ${_RC_RV}
}
rc_check()
{
    return rc_failed $?
}       
rc_status()
{
    rc_failed $?
    if test "$1" = "-r"; then _RC_RV=0; shift; fi
    if test "$1" = "-s"; then rc_failed 5; echo_rc; rc_failed 3; shift; fi
    if test "$1" = "-u"; then rc_failed ${_RC_UNUSED}; echo_rc; rc_failed 3; shift; fi
    if test "$1" = "-v"; then echo_rc; shift; fi
    if test "$1" = "-r"; then _RC_RV=0; shift; fi
    return ${_RC_RV}
}
rc_exit() { exit ${_RC_RV}; }

if ! which usleep >&/dev/null
then
  usleep()
  {
    if [ -n "$1" ]
    then
      sleep $(( $1 / 1000000 ))
    fi
  }
fi

# Reset status of this service
rc_reset

##
# Returns 0 (success) if the given parameter names a directory, and that
# directory is not empty.
#
contains_something()
{
  if [ -d "$1" ] && [ `/bin/ls $1 | wc -l` -gt 0 ]
  then
    return 0
  else
    return 1
  fi
}

# read name from xen config file
rdname()
{
    NM=$(xm create --quiet --dryrun --defconfig "$1" |
         sed -n 's/^.*(name \(.*\))$/\1/p')
}

rdnames()
{
    NAMES=
    if ! contains_something "$XENDOMAINS_AUTO"
    then 
        return
    fi
    for dom in $XENDOMAINS_AUTO/*; do
        rdname $dom
        if test -z $NAMES; then 
            NAMES=$NM; 
        else
            NAMES="$NAMES|$NM"
        fi
    done
}

parseln()
{
    name=`echo $1 | cut -d\  -f1`
    name=${name%% *}
    rest=`echo $1 | cut -d\  -f2-`
    read id mem cpu vcpu state tm < <(echo "$rest")
}

is_running()
{
    rdname $1
    RC=1
    while read LN; do
        parseln "$LN"
        if test $id = 0; then continue; fi
        case $name in 
            ($NM)
                RC=0
                ;;
        esac
    done < <(xm list | tail -n +2)
    return $RC
}

start() 
{
    if [ -f $LOCKFILE ]; then 
        echo -n "xendomains already running (lockfile exists)"
        return; 
    fi

    if [ "$XENDOMAINS_RESTORE" = "true" ] &&
       contains_something "$XENDOMAINS_SAVE"
    then
        mkdir -p $(dirname "$LOCKFILE")
        touch $LOCKFILE
        echo -n "Restoring Xen domains:"
        for dom in $XENDOMAINS_SAVE/*; do
            echo -n " ${dom##*/}"
            xm restore $dom
            if [ $? -ne 0 ]; then
                rc_failed $?
                echo -n '!'
            else
                # mv $dom ${dom%/*}/.${dom##*/}
                rm $dom
            fi
        done
        echo .
    fi

    if contains_something "$XENDOMAINS_AUTO"
    then
        touch $LOCKFILE
        echo -n "Starting auto Xen domains:"
        # We expect config scripts for auto starting domains to be in
        # XENDOMAINS_AUTO - they could just be symlinks to files elsewhere

        # Create all domains with config files in XENDOMAINS_AUTO.
        # TODO: We should record which domain name belongs 
        # so we have the option to selectively shut down / migrate later
        for dom in $XENDOMAINS_AUTO/*; do
            echo -n " ${dom##*/}"
            if is_running $dom; then
                echo -n "(skip)"
            else
                xm create --quiet --defconfig $dom
                if [ $? -ne 0 ]; then
                    rc_failed $?
                    echo -n '!'
                else
                    usleep $XENDOMAINS_CREATE_USLEEP
                fi
            fi
        done
    fi  
}

all_zombies()
{
    while read LN; do
        parseln "$LN"
        if test $id = 0; then continue; fi
        if test "$state" != "-b---d" -a "$state" != "-----d"; then
            return 1;
        fi
    done < <(xm list | tail -n +2)
    return 0
}

# Wait for max $XENDOMAINS_STOP_MAXWAIT for xm $1 to finish;
# if it has not exited by that time kill it, so the init script will
# succeed within a finite amount of time; if $2 is nonnull, it will
# kill the command as well as soon as no domain (except for zombies)
# are left (used for shutdown --all).
watchdog_xm()
{
    if test -z "$XENDOMAINS_STOP_MAXWAIT" -o "$XENDOMAINS_STOP_MAXWAIT" = "0"; then
        exit
    fi
    usleep 20000
    for no in `seq 0 $XENDOMAINS_STOP_MAXWAIT`; do
        # exit if xm save/migrate/shutdown is finished
        PSAX=`ps axlw | grep "xm $1" | grep -v grep`
        if test -z "$PSAX"; then exit; fi
        echo -n "."; sleep 1
        # go to kill immediately if there's only zombies left
        if all_zombies && test -n "$2"; then break; fi
    done
    sleep 1
    read PSF PSUID PSPID PSPPID < <(echo "$PSAX")
    # kill xm $1
    kill $PSPID >/dev/null 2>&1
}

stop()
{
    # Collect list of domains to shut down
    if test "$XENDOMAINS_AUTO_ONLY" = "true"; then
        rdnames
    fi
    echo -n "Shutting down Xen domains:"
    while read LN; do
        parseln "$LN"
        if test $id = 0; then continue; fi
        echo -n " $name"
        if test "$XENDOMAINS_AUTO_ONLY" = "true"; then
            case $name in
                ($NAMES)
                    # nothing
                    ;;
                (*)
                    echo -n "(skip)"
                    continue
                    ;;
            esac
        fi
        # XENDOMAINS_SYSRQ chould be something like just "s" 
        # or "s e i u" or even "s e s i u o"
        # for the latter, you should set XENDOMAINS_USLEEP to 1200000 or so
        if test -n "$XENDOMAINS_SYSRQ"; then
            for sysrq in $XENDOMAINS_SYSRQ; do
                echo -n "(SR-$sysrq)"
                xm sysrq $id $sysrq
                if test $? -ne 0; then
                    rc_failed $?
                    echo -n '!'
                fi
                # usleep just ignores empty arg
                usleep $XENDOMAINS_USLEEP
            done
        fi
        if test "$state" = "-b---d" -o "$state" = "-----d"; then
            echo -n "(zomb)"
            continue
        fi
        if test -n "$XENDOMAINS_MIGRATE"; then
            echo -n "(migr)"
            watchdog_xm migrate &
            WDOG_PID=$!
            xm migrate $id $XENDOMAINS_MIGRATE
            if test $? -ne 0; then
                rc_failed $?
                echo -n '!'
                kill $WDOG_PID >/dev/null 2>&1
            else
                kill $WDOG_PID >/dev/null 2>&1
                continue
            fi
        fi
        if test -n "$XENDOMAINS_SAVE"; then
            echo -n "(save)"
            watchdog_xm save &
            WDOG_PID=$!
            mkdir -p "$XENDOMAINS_SAVE"
            xm save $id $XENDOMAINS_SAVE/$name
            if test $? -ne 0; then
                rc_failed $?
                echo -n '!'
                kill $WDOG_PIG >/dev/null 2>&1
            else
                kill $WDOG_PIG >/dev/null 2>&1
                continue
            fi
        fi
        if test -n "$XENDOMAINS_SHUTDOWN"; then
            # XENDOMAINS_SHUTDOWN should be "--halt --wait"
            echo -n "(shut)"
            watchdog_xm shutdown &
            WDOG_PID=$!
            xm shutdown $id $XENDOMAINS_SHUTDOWN
            if test $? -ne 0; then
                rc_failed $?
                echo -n '!'
            fi
            kill $WDOG_PIG >/dev/null 2>&1
        fi
    done < <(xm list | tail -n +2)

    # NB. this shuts down ALL Xen domains (politely), not just the ones in
    # AUTODIR/*
    # This is because it's easier to do ;-) but arguably if this script is run
    # on system shutdown then it's also the right thing to do.
    if ! all_zombies && test -n "$XENDOMAINS_SHUTDOWN_ALL"; then
        # XENDOMAINS_SHUTDOWN_ALL should be "--all --halt --wait"
        echo -n " SHUTDOWN_ALL "
        watchdog_xm shutdown 1 &
        WDOG_PID=$!
        xm shutdown $XENDOMAINS_SHUTDOWN_ALL
        if test $? -ne 0; then
            rc_failed $?
            echo -n '!'
        fi
        kill $WDOG_PID >/dev/null 2>&1
    fi

    # Unconditionally delete lock file
    rm -f $LOCKFILE
}

check_domain_up()
{
    while read LN; do
        parseln "$LN"
        if test $id = 0; then continue; fi
        case $name in 
            ($1)
                return 0
                ;;
        esac
    done < <(xm list | tail -n +2)
    return 1
}

check_all_auto_domains_up()
{
    if ! contains_something "$XENDOMAINS_AUTO"
    then
      return 0
    fi
    missing=
    for nm in $XENDOMAINS_AUTO/*; do
        rdname $nm
        found=0
        if check_domain_up "$NM"; then 
            echo -n " $name"
        else 
            missing="$missing $NM"
        fi
    done
    if test -n "$missing"; then
        echo -n " MISS AUTO:$missing"
        return 1
    fi
    return 0
}

check_all_saved_domains_up()
{
    if ! contains_something "$XENDOMAINS_SAVE" 
    then
      return 0
    fi
    missing=`/bin/ls $XENDOMAINS_SAVE`
    echo -n " MISS SAVED: " $missing
    return 1
}

# This does NOT necessarily restart all running domains: instead it
# stops all running domains and then boots all the domains specified in
# AUTODIR.  If other domains have been started manually then they will
# not get restarted.
# Commented out to avoid confusion!

restart()
{
    stop
    start
}

reload()
{
    restart
}


case "$1" in
    start)
        start
        rc_status
        if test -f $LOCKFILE; then rc_status -v; fi
        ;;

    stop)
        stop
        rc_status -v
        ;;

    restart)
        restart
        ;;
    force-reload|reload)
        reload
        ;;

    status)
        echo -n "Checking for xendomains:" 
        if test ! -f $LOCKFILE; then 
            rc_failed 3
        else
            check_all_auto_domains_up
            rc_status
            check_all_saved_domains_up
            rc_status
        fi
        rc_status -v
        ;;

    *)
        echo "Usage: $0 {start|stop|restart|reload|force-reload|status}"
        rc_failed 3
        rc_status -v
        ;;
esac

rc_exit