#!/bin/bash

set -o errexit

cd $(dirname $0)

CMD=$(pwd)/$(basename $0)

mode=$1

shift || mode="no_action"

ROOT=../..

MYPWD=$( pwd )

IMAGE=$( readlink -f $ROOT/minix_x86.img )

DISK=$( readlink -f $ROOT/minix_x86.disk )

RC=$( readlink -f $ROOT/minix_x86.rc )

CONF=$( readlink -f $ROOT/minix_x86.conf )

MKFS=$( readlink -f $ROOT/../obj.i386/tooldir*/bin/nbmkfs.mfs )

MAKE=$( readlink -f $ROOT/../obj.i386/tooldir*/bin/nbmake-i386 )

ADDR2LINE=$( readlink -f $ROOT/../obj.i386/tooldir*/bin/i586-elf32-minix-addr2line )

BATCH=${BATCH:-0}

HYPER=${HYPER:-}

DISK_SIZE=${DISK_SIZE:-1024}

DISK_MNT=${DISK_MNT:-/media/minix-disk}

OUT=${OUT:-S} # S=STDOUT, F=FILE, C=CONSOLE, P=PTY

APPEND=${APPEND:-}

TIMEOUT=${TIMEOUT:-60}

BOOT_TIMEOUT=${BOOT_TIMEOUT:-45}

function rc_create {

cat <<EOF

#!/bin/sh

set -o errexit

[ -d /ext ] || mkdir /ext

mount /dev/c0d1 /ext

if [ -f /ext/etc/rc ]; then

sh /ext/etc/rc

fi

EOF

}

function rc_ext_default_create {

cat <<EOF

#!/bin/sh

echo "/ext/etc/rc: /ext mounted correctly."

EOF

}

function rc_ext_runcmd_create {

cat <<EOF

#!/bin/sh

echo "____runcmd_start"

$*

RET=\$?

echo "____runcmd_end \$RET status"

EOF

}

function minix_conf_create {

cat <<EOF

#!/bin/sh

GUEST_NIC=$guest_nic

HOST_FTP_USER=$host_ftp_user

HOST_FTP_PASS=$host_ftp_pass

HOST_FTP_PORT=$host_ftp_port

HOST_FTP_DIR=$host_ftp_dir

HOST_IP_ADDR=$host_ip_addr

EOF

}

#

# Configuration variables

#

CONF_VARS="guest_nic host_ftp_user host_ftp_pass host_ftp_port host_ftp_dir host_ip_addr"

function conf_init

{

for v in $CONF_VARS

do

if [ -z ${!v} ]; then

eval ${v}="NULL"

fi

done

}

function get_conf_value

{

local conf_var=$1

local msg="$2"

local default=$3

local values=""

[ ! -z $VALUES ] && values="$VALUES, "

line="$msg [${values}Default=$default]: "

(

echo -n "$line"

) 2>&1

if [ "${!conf_var}" == "NULL" ]; then

if [ $BATCH -eq 0 ]; then

read -r $conf_var

echo -en "\e[1A"

else

eval $conf_var=""

fi

fi

if [ "${!conf_var}" == "" ]; then

eval $conf_var=$default

fi

(

echo -en "\e[0K\r"

echo -n "$line"

echo ${!conf_var}

) 2>&1

RET=${!conf_var}

}

function get_conf_value_repeat

{

local check=$1

shift

local conf_var=$1

while true

do

get_conf_value "$@"

eval $check $RET || break

eval $conf_var="NULL"

done

}

function __get_conf_value_check_list

{

for v in $( echo $VALUES | sed "s/|/ /g" )

do

[ "$1" == "$v" ] && return 1

done

return 0

}

function get_conf_value_list

{

get_conf_value_repeat __get_conf_value_check_list "$@"

}

function get_conf_value_yn

{

VALUES="y|n" get_conf_value_list "$@"

}

function __get_conf_value_check_int_range

{

min=$( echo $VALUES | sed "s/|/ /g" | cut -d' ' -f 1 )

max=$( echo $VALUES | sed "s/|/ /g" | cut -d' ' -f 2 )

case $min in

''|*[!0-9]*) return 0 ;;

esac

case $max in

''|*[!0-9]*) return 0 ;;

esac

[ $1 -ge $min ] && [ $1 -le $max ] && return 1

return 0

}

function get_conf_value_int_range

{

get_conf_value_repeat __get_conf_value_check_int_range "$@"

}

function get_conf_value_nic

{

VALUES="0|13" get_conf_value_int_range "$@"

}

function __get_conf_value_check_string

{

return 1

}

function get_conf_value_string

{

get_conf_value_repeat __get_conf_value_check_string "$@"

}

function disk_mount {

local mnt=$1

echo "* Mounting ${DISK} to $mnt..."

[ -d $mnt ] || sudo mkdir -p $mnt

disk_umount &> /dev/null || true

sudo mount -o loop $DISK $mnt || true

}

function disk_umount {

echo "* Unmounting ${DISK}..."

sudo umount $DISK

}

function disk_build {

local size=$1

local tmp_mnt=$( mktemp -d /tmp/clientctl-XXXXX )

echo "* Building ${size} MB disk image..."

dd if=/dev/zero of=$DISK bs=1M count=$size

$MKFS $DISK

echo "* Setting up /ext/etc/rc file executed at startup..."

rc_create > $RC

disk_mount $tmp_mnt

[ -d $tmp_mnt/etc ] || mkdir -p $tmp_mnt/etc

rc_ext_default_create > $tmp_mnt/etc/rc

disk_umount

rm -rf $tmp_mnt

}

function minix_conf {

conf_init

nics="virbr0 virbr1 eth0 eth1 wlan0 wlan1"

for n in $nics

do

host_ip_addr_default=$( ifconfig $n 2> /dev/null | perl -nle'/dr:(\S+)/ && print $1' )

[ -z "$host_ip_addr_default" ] || break

done

get_conf_value_nic guest_nic "[NIC] Which nic do you want to use on MINIX (see MINIX' \`netconf -c\`)?" 7

get_conf_value_string host_ftp_user "[FTP] Username for FTP server running on the host?" ftptest

get_conf_value_string host_ftp_pass "[FTP] Password for FTP server running on the host?" ftptest

get_conf_value_string host_ftp_port "[FTP] Port for FTP server running on the host?" 21

get_conf_value_string host_ftp_dir "[FTP] Base directory for FTP server running on the host?" /home/$host_ftp_user

get_conf_value_string host_ip_addr "[HOSTS] Host ip address?" $host_ip_addr_default

echo ""

echo "* Setting up configuration settings in $CONF..."

minix_conf_create > $CONF

}

function wait_output {

RET=0

date

timeout $1 watch -n 1 -e \! grep -q "$2" $3 &> /dev/null < /dev/null || RET=$?

if [ $RET -eq 124 ]; then

echo "* Timed out after $1 seconds!" 1>&2

return 1

fi

echo "* Done." 1>&2

date

return 0

}

function run_cmd_exec {

echo "* Waiting for MINIX to boot..." 1>&2

wait_output $BOOT_TIMEOUT "__runcmd_start" runcmd.log || return 33

echo "* Waiting for command \"$*\"..." 1>&2

wait_output $TIMEOUT "__runcmd_end" runcmd.log || return 66

RET=$( grep __runcmd_end runcmd.log | cut -d' ' -f 2 )

return $RET

}

function run_cmd {

echo "* Setting up configuration..." 1>&2

[ -f $DISK ] || $CMD builddisk

[ -f $IMAGE ] || $CMD buildimage

$CMD mountdisk

[ ! -f $DISK_MNT/etc/rc ] || mv $DISK_MNT/etc/rc $DISK_MNT/etc/rc.bak

rc_ext_runcmd_create $* > $DISK_MNT/etc/rc

$CMD umountdisk

echo "* Starting up..." 1>&2

rm -f runcmd.*

OUT=S $CMD run &> runcmd.log &

PID=$!

RUNCMD_RET=0

run_cmd_exec $* || RUNCMD_RET=$?

cat runcmd.log | awk '/__runcmd_end/ {N=0;} { if (N==1) print; } /__runcmd_start/ {N=1;}' > runcmd.out

echo "* Shutting down..." 1>&2

for pid in $(ps ax -o pid,args --sort start_time | grep -e "$CMD run[^a-zA-Z]" -e qemu -e kvm | grep -v grep | cut -d' ' -f 1 | head -3 )

do

kill $pid &> /dev/null || true

done

$CMD mountdisk

[ ! -f $DISK_MNT/etc/rc.bak ] || mv $DISK_MNT/etc/rc.bak $DISK_MNT/etc/rc

echo "* COMMAND: \"$*\", RET: $RUNCMD_RET, OUTPUT:"

cat runcmd.out

return $RUNCMD_RET

}

function run {

if [ "$HYPER" == "" ]; then

if [ -e /dev/kvm ]; then

HYPER="qemu-system-i386 --enable-kvm"

else

HYPER=qemu-system-i386

fi

fi

opts="-m 256 -hda $IMAGE"

append="$APPEND rootdevname=c0d0p0"

[ ! -f $DISK ] || opts="$opts -hdb $DISK"

if [ "$OUT" == "F" ]; then

opts="$opts -curses -serial file:$MYPWD/serial.out"

append="$append cttyline=0"

echo "tail -f $MYPWD/serial.out" > $MYPWD/connect.cmd

elif [ "$OUT" == "C" ]; then

opts="$opts -curses -chardev socket,id=serial0,path=$MYPWD/serial.sock,server,nowait -serial chardev:serial0"

append="$append cttyline=0"

echo "(cd $MYPWD && minicom -D unix\#serial.sock)" > $MYPWD/connect.cmd

else

opts="$opts -nographic"

append="$append console=tty00"

if [ "$OUT" == "P" ]; then

opts="$opts -serial pty"

[ -z $PTS ] && PTS=$( $HYPER -serial pty 2>&1 | grep pts | sed "s/.* \([^ ]*pts[^ ]*\) .*/\1/g" )

echo "minicom -D $PTS" > $MYPWD/connect.cmd

else

echo "echo Cannot connect with OUT=S option." > $MYPWD/connect.cmd

fi

fi

(cd ../../../obj.i386/destdir.i386/boot/minix/.temp && $HYPER -kernel kernel -append "$append" $opts -initrd "mod01_ds,mod02_rs,mod03_pm,mod04_sched,mod05_vfs,mod06_memory,mod07_tty,mod08_mfs,mod09_vm,mod10_pfs,mod11_init")

}

function minix_connect {

echo "*****"

echo "***** Running: $( cat $MYPWD/connect.cmd )"

echo "*****"

eval $MYPWD/connect.cmd

}

function minix_unstack {

local service=$1

shift

if [ ! -f $ROOT/minix.mods.map ]; then

echo "$ROOT/minix.mods.map does not exist, run relink.llvm first!"

return 1

fi

path=$(grep "^$service=" $ROOT/minix.mods.map | cut -d= -f 2)

path=$ROOT/../obj.i386/$path/$service

$ADDR2LINE -p -f -e $path $*

}

function minix_test {

JOBS=${JOBS:-8}

RUNCMD=${RUNCMD:-ls}

C=${C:-full}

LOG=$(pwd)/test.log

if [ "$C" == "full" ]; then

cd $ROOT

JOBS=$JOBS BUILDVARS="-V MKBITCODE=yes" ./releasetools/x86_hdimage.sh -b 2>&1 | tee $LOG; test ${PIPESTATUS[0]} -eq 0 || exit 125

cd -

else

C=$C ./relink.llvm 2>&1 | tee $LOG; test ${PIPESTATUS[0]} -eq 0 || exit 125

./clientctl buildimage 2>&1 | tee -a $LOG; test ${PIPESTATUS[0]} -eq 0 || exit 125

fi

if [ "$RUNCMD" != "" ]; then

./clientctl runcmd $RUNCMD 2>&1 | tee -a $LOG; test ${PIPESTATUS[0]} -eq 0 || exit 2

fi

exit 0

}

function minix_bisect {

cd $ROOT

git bisect reset

echo " * Enter bad commit: "

read bad

echo " * Enter good commit: "

read good

git bisect start $bad $good

git bisect run minix/llvm/clientctl test

cd -

}

# Usage: [C=set] ./clientctl buildasr [num]

#

# Build 'num' sets of ASR-randomized service binaries for the 'set' set of

# services. Defaults to one set (in addition to the set used to boot) for

# all services. To be used after building the full system.

#

# The MINIX3 counterpart of the generation taking place here is the

# update_asr(8) command, which cycles through the generated binaries.

#

function minix_buildasr {

MINIXLLVMDIR=$ROOT/minix/llvm

ASRDIR=/usr/service/asr

. $MINIXLLVMDIR/common.inc # get DESTDIR

DESTDIR="$DESTDIR/destdir.i386" # correct DESTDIR

ASRDESTDIR="$DESTDIR$ASRDIR"

COUNT=${1:-1} # take count from command line, default to 1

C=${C:-"servers,fs,net,drivers"}

# start by relinking everything against the magic library

C=$C $MINIXLLVMDIR/relink.llvm magic

# we are replacing any previously made ASR binaries

rm -rf $ASRDESTDIR/*

# generate $COUNT number of sets of ASR-randomized service binaries

# TODO: do not use current time as random seed

N=1

while [ $N -le $COUNT ]; do

mkdir $ASRDESTDIR/$N

export BINDIR=$ASRDIR/$N

C=$C $MINIXLLVMDIR/build.llvm magic asr

sleep 1 # just to make sure they're guaranteed to be different

N=$(($N + 1))

done

# generate the initial set of service binaries, different as well

unset BINDIR

C=$C $MINIXLLVMDIR/build.llvm magic asr

# finally generate the image

# x86_hdimage will automatically add the binaries to the image set

$MINIXLLVMDIR/clientctl buildimage

}

case "$mode" in

'buildimage')

(cd $ROOT && CREATE_IMAGE_ONLY=1 releasetools/x86_hdimage.sh -b)

;;

'buildboot')

(cd $ROOT && $MAKE -C releasetools do-hdboot)

;;

'conf')

minix_conf

;;

'builddisk')

rm -f $DISK

disk_build $DISK_SIZE

;;

'mountdisk')

disk_mount $DISK_MNT

;;

'umountdisk')

disk_umount

;;

'runcmd')

run_cmd $*

;;

'run')

run

;;

'connect')

minix_connect

;;

'unstack')

minix_unstack $*

;;

'test')

minix_test

;;

'bisect')

minix_bisect

;;

'buildasr')

minix_buildasr $*

;;

*)

echo "Invalid action: $mode"

exit 1

;;

esac