Add Xen 4.11.0 packages (forgotten files from previous commit)


(bouyer)

#include <inttypes.h>
#include <sys/ioctl.h>
#include <sys/disklabel.h>
#include "tapdisk.h"
#include "blk.h"

int blk_getimagesize(int fd, uint64_t *size)
{
	int rc;
	struct disklabel dl;

	*size = 0;
	rc = ioctl(fd, DIOCGDINFO, &dl);
	if (rc) {
		DPRINTF("ERR: DIOCGDINFO failed, couldn't stat image");
		return -EINVAL;
	}

	*size = dl.d_secsize * dl.d_secpercyl;

	return 0;
}

int blk_getsectorsize(int fd, uint64_t *sector_size)
{
	int rc;
	struct disklabel dl;

	*sector_size = DEV_BSIZE;
	rc = ioctl(fd, DIOCGDINFO, &dl);
	if (rc) {
		DPRINTF("ERR: DIOCGDINFO failed, couldn't stat image");
		return 0; /* fallback to DEV_BSIZE */
	}

	*sector_size = dl.d_secsize;
	return 0;
}

#include "blktaplib.h"
#include "blktapctrl.h"


int blktap_interface_open(void)
{
	/* not yet implemented */
	return -1;
}

int blktap_interface_create(int ctlfd, int *major, int *minor, blkif_t *blkif)
{
	/* not yet implemented */
	return -1;
}

#!/bin/sh
#
# Copyright (c) 2016, Christoph Badura.  All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
#

LOCK_BASEDIR="$XEN_LOCK_DIR/xen-hotplug"

_lockfd=9
_have_lock=0	# lock not taken yet.

SHLOCK="shlock ${_shlock_debug-}"

_lock_set_vars() {
	_lockfile="$LOCK_BASEDIR/$1.lock"
	_lockfifo="$LOCK_BASEDIR/$1.fifo"
}

_lock_init() {
	mkdir -p "$LOCK_BASEDIR" 2>/dev/null || true
	mkfifo $_lockfifo 2>/dev/null || true
}

#
# use a named pipe as condition variable
# opening for read-only blocks when there's no writer.
# opening for read-write never blocks but unblocks any waiting readers.
# 
_lock_wait_cv() {
	eval "exec $_lockfd<  $_lockfifo ; exec $_lockfd<&-"
}
_lock_signal_cv() {
	eval "exec $_lockfd<> $_lockfifo ; exec $_lockfd<&-"
}

claim_lock() {
	_lock_set_vars $1
	_lock_init
	until $SHLOCK -f $_lockfile -p $$; do
		_lock_wait_cv
	done
	_have_lock=1
	# be sure to release the lock when the shell exits
	trap "release_lock $1" 0 1 2 15
}

release_lock() {
	_lock_set_vars $1
	[ "$_have_lock" != 0 -a -f $_lockfile ] && rm $_lockfile
	_have_lock=0
	_lock_signal_cv;
}

#!@RCD_SCRIPTS_SHELL@
#
# PROVIDE: xen-watchdog
# REQUIRE: DAEMON
#
# description: Run domain watchdog daemon
#

. /etc/rc.subr

name="xenwatchdog"
rcvar=$name
command="@PREFIX@/sbin/xenwatchdogd"
start_cmd="echo Starting ${name}. && PATH=${PATH}:@PREFIX@/sbin ${command} 30 15"

load_rc_config $name
run_rc_command "$1"

#!@RCD_SCRIPTS_SHELL@
#
# PROVIDE: xencommons
# REQUIRE: DAEMON

. /etc/rc.subr

name="xencommons"
rcvar=$name
start_precmd="xen_precmd"
start_cmd="xen_startcmd"
stop_cmd="xen_stop"
status_cmd="xen_status"
extra_commands="status"
required_files="/kern/xen/privcmd"

XENSTORED_PIDFILE="/var/run/xenstored.pid"
XENCONSOLED_PIDFILE="/var/run/xenconsoled.pid"

BINDIR=@PREFIX@/bin
SBINDIR=@PREFIX@/sbin
LIBEXEC_BIN=@PREFIX@/libexec/xen/bin

xen_precmd()
{
	mkdir -p /var/run/xen || exit 1
	mkdir -p /var/run/xenstored || exit 1
}

xen_startcmd()
{
	printf "Starting xenservices: xenstored, xenconsoled.\n"
	if test ! -r ${required_files}; then
		warn "${required_files} is not readable."
	fi
	XENSTORED_ARGS=" --pid-file ${XENSTORED_PIDFILE}"
	if [ -n "${XENSTORED_TRACE}" ]; then
		XENSTORED_ARGS="${XENSTORED_ARGS} -T /var/log/xen/xenstored-trace.log"
	fi

	${SBINDIR}/xenstored ${XENSTORED_ARGS}
	sleep 5

        printf "Setting domain 0 name, domid and JSON config...\n"
        ${LIBEXEC_BIN}/xen-init-dom0

	XENCONSOLED_ARGS=""
	if [ -n "${XENCONSOLED_TRACE}" ]; then
		XENCONSOLED_ARGS="${XENCONSOLED_ARGS} --log=${XENCONSOLED_TRACE}"
	fi

	${SBINDIR}/xenconsoled ${XENCONSOLED_ARGS}
}

xen_stop()
{
	pids=""
	printf "Stopping xencommons"

	rc_pid=$(check_pidfile ${XENCONSOLED_PIDFILE} ${SBINDIR}/xenconsoled)
	pids="$pids $rc_pid"
	rc_pid=$(check_pidfile ${XENSTORED_PIDFILE} ${SBINDIR}/xenstored)
	pids="$pids $rc_pid"

	kill -${sig_stop:-TERM} $pids
	wait_for_pids $pids

	printf ".\n"
}

xen_status()
{
	xenstored_pid=$(check_pidfile ${XENSTORED_PIDFILE} ${SBINDIR}/xenstored)
	if test -n ${xenstored_pid}; then
		pids="$pids $xenstored_pid"
	fi

	xenconsoled_pid=$(check_pidfile ${XENCONSOLED_PIDFILE} ${SBINDIR}/xenconsoled)
	if test -n ${xenconsoled_pid}; then
		pids="$pids $xenconsoled_pid"
	fi

	if test -n "$xenconsoled_pid" -a -n "$xenstored_pid";
	then
		echo "xencommons are running as pids $pids."
		return 0
	fi
	if test -a -z "$xenconsoled_pid" -a -z "$xenstored_pid";
	then
		echo "xencommons are not running."
		return 0
	fi

	if test -n "$xenstored_pid"; then
		echo "xenstored is running as pid $xenstored_pid."
	else
		echo "xenstored is not running."
	fi
	if test -n "$xenconsoled_pid"; then
		echo "xenconsoled is running as pid $xenconsoled_pid."
	else
		echo "xenconsoled is not running."
	fi
}

load_rc_config $name
run_rc_command "$1"

#!@RCD_SCRIPTS_SHELL@
#
# PROVIDE: xendomains
# REQUIRE: xencommons
# KEYWORD: shutdown
#
# xendomains		This required variable is a whitespace-separated
#			list of domains, e.g., xendomains="dom1 dom2 dom3".
#
# xendomains_config	This optional variable is a format string that
#			represents the path to the configuration file for
#			each domain.  "%s" is substituted with the name of
#			the domain.  The default is "@PKG_SYSCONFDIR@/%s".
#
# xendomains_prehook	This optional variable is a format string that
#			represents the command to run, if it exists, before
#			starting each domain.  "%s" is substituted with the
#			name of the domain.  The default is
#			"@PKG_SYSCONFDIR@/%s-pre".
#
# xendomains_posthook	This optional variable is a format string that
#			represents the command to run, if it exists, after
#			stopping each domain.  "%s" is substituted with the
#			name of the domain.  The default is
#			"@PKG_SYSCONFDIR@/%s-post".
#

. /etc/rc.subr

name="xendomains"
ctl_command="@PREFIX@/sbin/xl"
start_cmd="xendomains_start"
stop_cmd="xendomains_stop"
list_cmd="xendomains_list"
extra_commands="list"
required_files="/kern/xen/privcmd"

xendomains_start()
{
	[ -n "$xendomains" ] || return

	echo "Starting xen domains."
	for domain in $xendomains; do
		case "$domain" in
		"")	continue ;;
		esac

		# Start off by running the pre-hook script if it's present.
		if [ -n "${xendomains_prehook}" ]; then
			cmdline=`printf "${xendomains_prehook}" $domain`
			cmd="${cmdline%% *}"
			if [ -x "$cmd" ]; then
				if ! $cmdline; then
					echo "Pre-hook \`\`$cmdline'' failed... skipping $domain."
					continue
				fi
			fi
		fi

		# Ask xend to create the domain.
		if [ -n "${xendomains_config}" ]; then
			file=`printf "${xendomains_config}" $domain`
			if [ -f "$file" ]; then
				${ctl_command} create "$file"
			fi
		fi
	done
}

xendomains_list() {
	# Output a whitespace-separated list of live guest domains.
	${ctl_command} list | awk '
		(FNR <= 2) { next }
		($5 !~ /s/) { s = s " " $1 }
		END { sub(" *", "", s); print s }'
}

xendomains_stop()
{
	# Determine an appropriate timeout waiting for all domains to
	# stop -- always wait at least 60s, and add 5s per active domain.
	#
	numdomains=$(xendomains_list | awk '{ print NF }')
	[ $numdomains -gt 0 ] || return
	timeout=$((60 + numdomains * 5))

	# Ask xend to stop every domain, and poll xend every 10s up to the
	# timeout period to check if all the domains are stopped.  We
	# consider a domain in the "s" (shutdown) state to be stopped.
	#
	echo "Stopping xen domains."
	for domain in $(xendomains_list); do
		${ctl_command} shutdown -F $domain
	done
	while [ $timeout -gt 0 ]; do
		livedomains=$(xendomains_list)
		[ -n "$livedomains" ] || break
		timeout=$((timeout - 10))
		sleep 10
	done
	livedomains=$(xendomains_list)
	if [ -n "$livedomains" ]; then
		echo "Failed to stop: $livedomains"
	else
		echo "All domains stopped."
	fi

	# Finish off by running the post-hook script if it's present.
	for domain in $xendomains; do
		case "$domain" in
		"")	continue ;;
		esac
		if [ -n "${xendomains_posthook}" ]; then
			cmdline=`printf "${xendomains_posthook}" $domain`
			cmd="${cmdline%% *}"
			if [ -x "$cmd" ]; then
				$cmdline || echo "Post-hook \`\`$cmdline'' failed."
			fi
		fi
	done
}

load_rc_config $name

: ${xendomains_config="@PKG_SYSCONFDIR@/%s"}
: ${xendomains_prehook="@PKG_SYSCONFDIR@/%s-pre"}
: ${xendomains_posthook="@PKG_SYSCONFDIR@/%s-post"}

run_rc_command "$1"