#!/bin/bash
# ----------------------------------------------------------------------
# File: eosd
# Author: Andreas-Joachim Peters - CERN
# ----------------------------------------------------------------------

# ************************************************************************
# * EOS - the CERN Disk Storage System                                   *
# * Copyright (C) 2011 CERN/Switzerland                                  *
# *                                                                      *
# * This program is free software: you can redistribute it and/or modify *
# * it under the terms of the GNU General Public License as published by *
# * the Free Software Foundation, either version 3 of the License, or    *
# * (at your option) any later version.                                  *
# *                                                                      *
# * 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, see <http://www.gnu.org/licenses/>.*
# ************************************************************************
#
#       /etc/rc.d/init.d/eosd
#
# Starts eosd 
#
# chkconfig: 345 96 6
# description: Starts eosd 
# processname: eosd

# Source function library.

export EOS_ROOT=/usr
export EOSD=eosd


. /etc/init.d/functions

if test ! -x ${EOS_ROOT}/bin/${EOSD} ; then
  echo Error: ${EOS_ROOT}/bin/${EOSD} does not exist!
  exit 0
fi

[ -f /etc/sysconfig/eos ] && . /etc/sysconfig/eos

RETVAL=0
prog="${EOSD}"

[ -z "${EOS_FUSE_MOUNTS}" ] && EOS_FUSE_MOUNTS="main";

FUSE_OPT_SAVE=${FUSE_OPT}

kill_mountpoint_users() {
    local MNTPT="$1"
    lsof -w > /tmp/eosd.lsof.list
    local NAMEPOS=$(grep -b -o NAME /tmp/eosd.lsof.list | grep -o [0-9]*)
    if [ "A${NAMEPOS}" = "A" ]; then
    echo "Error killing users of mountpoint $1" >&2
    fi
    local PIDS=$(tail -n +2 /tmp/eosd.lsof.list | grep "^.\{${NAMEPOS}\}${MNTPT}\$" | awk '{ print $2 }' | xargs echo)
    PIDS="$PIDS $(tail -n +2 /tmp/eosd.lsof.list | grep "^.\{$NAMEPOS\}${MNTPT}/" | awk '{ print $2 }' | xargs echo)"
    # if there is no PID to kill, it's a success
    if [[ ! "$PIDS" =~ ^[\ ]*[0-9]+[0-9\ ]*$ ]]; then return 0; fi;
    local ACTION=$([ "A$2" = "A-9" ] && echo "killing" || echo "terminating")
    echo -n "Cleaning mountpoint $MNTPT : ${ACTION} processes $PIDS"
    echo 
    echo_warning
    echo 
    if [ "A$2" = "A-9" ]; then
        kill $PIDS
    else 
        kill -9 $PIDS
    fi
}

start() {
    if [ -n "$1" ]; then
        EOS_FUSE_MOUNTS="$1";
    fi  
    for i in ${EOS_FUSE_MOUNTS}; do
        (
        # in any case, we make sure that there is no leftover in the environment from the previous iteration

        unset EOS_FUSE_DEBUG EOS_FUSE_LOWLEVEL_DEBUGEOS_FUSE_NOACCESS EOS_FUSE_SYNC EOS_FUSE_KERNELCACHE EOS_FUSE_DIRECTIO EOS_FUSE_CACHE EOS_FUSE_CACHE_SIZE EOS_FUSE_CACHE_PAGE_SIZE EOS_FUSE_BIGWRITES EOS_FUSE_EXEC EOS_FUSE_NO_MT EOS_FUSE_USER_KRB5CC EOS_FUSE_USER_UNSAFEKRB5 EOS_FUSE_USER_GSIPROXY EOS_FUSE_USER_KRB5FIRST EOS_FUSE_FALLBACKTONOBODY EOS_FUSE_PIDMAP EOS_FUSE_RMLVL_PROTECT EOS_FUSE_RDAHEAD EOS_FUSE_RDAHEAD_WINDOW EOS_FUSE_LAZYOPENRO EOS_FUSE_LAZYOPENRW EOS_FUSE_LOG_PREFIX EOS_FUSE_STREAMERRORWINDOW FUSE_OPT EOS_FUSE_ATTR_CACHE_TIME EOS_FUSE_ENTRY_CACHE_TIME EOS_FUSE_NEG_ENTRY_CACHE_TIME EOS_FUSE_FILE_WB_CACHE_SIZE EOS_FUSE_CREATOR_CAP_LIFETIME EOS_FUSE_REMOTEDIR EOS_FUSE_INLINE_REPAIR EOS_FUSE_MAX_INLINE_REPAIR_SIZE EOS_FUSE_SHOW_SPECIAL_FILES EOS_FUSE_SHOW_EOS_ATTRIBUTES EOS_FUSE_MAX_WB_INMEMORY_SIZE

        # then we use the values from the main /etc/sysconfig/eos config file (if any) as default values
        [ -f /etc/sysconfig/eos ] && . /etc/sysconfig/eos
        if [ "$i" != "main" ]; then
            # then, we override the env vars with the ones in the instance specific config file /etc/sysconfig/eos.$i
            if [ -f /etc/sysconfig/eos.$i ]; then
                . /etc/sysconfig/eos.$i
            else
                echo -n "Skipping fuse mount for instance $i - no /etc/sysconfig/eos.$i configuration file"
                echo 
                echo_warning
                echo 
                continue;
            fi
        fi

	# If we are called from mount.eos we can get the local mount dir passed and overwrite the sysconfig setting	
	if [ -n "${EOS_FUSE_WRAPPER_MOUNTDIR}" ]; then 
	    export EOS_FUSE_MOUNTDIR=${EOS_FUSE_WRAPPER_MOUNTDIR}
	fi

        # Check if eosd is already running
        echo
        eosdpid=`pgrep -f "${EOS_ROOT}/bin/${EOSD} ${EOS_FUSE_MOUNTDIR}"`
        getstatus $i
        eosdstatus="$?"
        export EOS_FUSE_PING_TIMEOUT=${EOS_FUSE_PING_TIMEOUT-15}
        export EOS_FUSE_DEBUG=${EOS_FUSE_DEBUG-0}
        export EOS_FUSE_LOWLEVEL_DEBUG=${EOS_FUSE_LOWLEVEL_DEBUG-0}
        export EOS_FUSE_NOACCESS=${EOS_FUSE_NOACCESS-1}
        export EOS_FUSE_SYNC=${EOS_FUSE_SYNC-0}
        export EOS_FUSE_KERNELCACHE=${EOS_FUSE_KERNELCACHE-1}
        export EOS_FUSE_DIRECTIO=${EOS_FUSE_DIRECTIO-0}
        export EOS_FUSE_CACHE=${EOS_FUSE_CACHE-1}
        export EOS_FUSE_CACHE_SIZE=${EOS_FUSE_CACHE_SIZE-67108864}
        export EOS_FUSE_CACHE_PAGE_SIZE=${EOS_FUSE_CACHE_PAGE_SIZE-262144}
        export EOS_FUSE_BIGWRITES=${EOS_FUSE_BIGWRITES-1}    
        export EOS_FUSE_EXEC=${EOS_FUSE_EXEC-0}
        export EOS_FUSE_NO_MT=${EOS_FUSE_NO_MT-0}
        export EOS_FUSE_SSS_KEYTAB=${EOS_FUSE_SSS_KEYTAB-""}
        export EOS_FUSE_USER_KRB5CC=${EOS_FUSE_USER_KRB5CC-0}
        export EOS_FUSE_USER_UNSAFEKRB5=${EOS_FUSE_USER_UNSAFEKRB5-0}
        export EOS_FUSE_USER_GSIPROXY=${EOS_FUSE_USER_GSIPROXY-0}
        export EOS_FUSE_USER_KRB5FIRST=${EOS_FUSE_USER_KRB5FIRST-0}
        export EOS_FUSE_FALLBACKTONOBODY=${EOS_FUSE_FALLBACKTONOBODY-0}
        export EOS_FUSE_PIDMAP=${EOS_FUSE_PIDMAP-0}
        export EOS_FUSE_RMLVL_PROTECT=${EOS_FUSE_RMLVL_PROTECT-1}
        export EOS_FUSE_RDAHEAD=${EOS_FUSE_RDAHEAD-0}
        export EOS_FUSE_RDAHEAD_WINDOW=${EOS_FUSE_RDAHEAD_WINDOW-131072}
        export EOS_FUSE_LAZYOPENRO=${EOS_FUSE_LAZYOPENRO-0}
        export EOS_FUSE_LAZYOPENRW=${EOS_FUSE_LAZYOPENRW-1}
        export EOS_FUSE_ASYNC_OPEN=${EOS_FUSE_ASYNC_OPEN-0}
        export EOS_FUSE_SHOW_SPECIAL_FILES=${EOS_FUSE_SHOW_SPECIAL_FILES-0}
        export EOS_FUSE_SHOW_EOS_ATTRIBUTES=${EOS_FUSE_SHOW_EOS_ATTRIBUTES-0}
        export EOS_FUSE_INLINE_REPAIR=${EOS_FUSE_INLINE_REPAIR-1}
        export EOS_FUSE_MAX_INLINE_REPAIR_SIZE=${EOS_FUSE_MAX_INLINE_REPAIR_SIZE-268435456}
        export EOS_FUSE_LOG_PREFIX=${EOS_FUSE_LOG_PREFIX-$i}
        export EOS_FUSE_ENTRY_CACHE_TIME=${EOS_FUSE_ENTRY_CACHE_TIME-2}
        export EOS_FUSE_ATTR_CACHE_TIME=${EOS_FUSE_ATTR_CACHE_TIME-2}
        export EOS_FUSE_NEG_ENTRY_CACHE_TIME=${EOS_FUSE_NEG_ENTRY_CACHE_TIME-30}
        export EOS_FUSE_CREATOR_CAP_LIFETIME=${EOS_FUSE_CREATOR_CAP_LIFETIME-30}
        export EOS_FUSE_FILE_WB_CACHE_SIZE=${EOS_FUSE_FILE_WB_CACHE_SIZE-67108864}
        export EOS_FUSE_MOUNTDIR=${EOS_FUSE_MOUNTDIR-/eos/}
        export EOS_FUSE_REMOTEDIR=${EOS_FUSE_REMOTEDIR-${EOS_FUSE_MOUNTDIR}}
	export EOS_FUSE_MAX_WB_INMEMORY_SIZE=${EOS_FUSE_MAX_WB_INMEMORY_SIZE-536870912}
	export EOS_FUSE_XRDBUGNULLRESPONSE_RETRYCOUNT=${EOS_FUSE_XRDBUGNULLRESPONSE_RETRYCOUNT-3}
        export EOS_FUSE_XRDBUGNULLRESPONSE_RETRYSLEEPMS=${EOS_FUSE_XRDBUGNULLRESPONSE_RETRYSLEEPMS-1}
	export EOS_FUSE_RETRY_SOCKET_ERROR=${EOS_FUSE_RETRY_SOCKET_ERROR-3}
	export EOS_FUSE_RETRY_CONNECTION_ERROR=${EOS_FUSE_RETRY_CONNECTION_ERROR-30}
        export XRD_RUNFORKHANDLER=1
        # use sss only if we don't use any of krb5 and gsi 
        [[ "x$EOS_FUSE_SSS_KEYTAB" != "x" ]]  && [[ "x$EOS_FUSE_USER_KRB5CC" = "x0" || "x$EOS_FUSE_USER_KRB5CC" = "x" ]] && [[  "x$EOS_FUSE_USER_GSIPROXY" = "x0" || "x$EOS_FUSE_USER_GSIPROXY" = "x" ]] && export XrdSecSSSKT=$EOS_FUSE_SSS_KEYTAB
        [[ "x$EOS_FUSE_STREAMERRORWINDOW" != "x" ]] && export XRD_STREAMERRORWINDOW=$EOS_FUSE_STREAMERRORWINDOW
        # make sure that FUSE_OPT keeps the same default value
        export FUSE_OPT=${FUSE_OPT-"${FUSE_OPT_SAVE}"}

        if [ "x$EOS_FUSE_BIGWRITES" = "x1" ]; then
            FUSE_OPT="big_writes,"${FUSE_OPT-""}
        else
            test -n "${FUSE_OPT}" && FUSE_OPT=${FUSE_OPT}","
        fi

	if [ ${EOSD} == "eosd3" ]; then
	    # add write_back cache option
	    FUSE_OPT=${FUSE_OPT}"writeback_cache,"
	fi

        if [ "$eosdstatus" -eq "1" ]; then
            echo unmounting and cleaning mountpoint for dead but subsys locked instance $i
            echo_warning
            echo
            umount -f ${EOS_FUSE_MOUNTDIR} > /dev/null 2>&1
            nmounts=$( mount | grep -w fuse | awk '{ print $3 }' | grep ^${EOS_FUSE_MOUNTDIR%/}$ | wc -l )
            if [ "$nmounts" -ne "0" ]; then
                kill_mountpoint_users ${EOS_FUSE_MOUNTDIR%/}
                [ "$?" != "0" ] || sleep 5 && kill_mountpoint_users ${EOS_FUSE_MOUNTDIR%/} -9 || sleep 5 && kill_mountpoint_users ${EOS_FUSE_MOUNTDIR%/} -9
                if [ "$?" != "0" ]; then
                    echo cannot kill processes using instance $i at mount point ${EOS_FUSE_MOUNTDIR} 
                    echo_failure
                    echo
                    RETVAL=1;
                    continue
                fi
                umount -f ${EOS_FUSE_MOUNTDIR} > /dev/null 2>&1
                nmounts=$( mount | grep -w fuse | awk '{ print $3 }' | grep ^${EOS_FUSE_MOUNTDIR%/}$ | wc -l )
                if [ "$nmounts" -ne "0" ]; then
                    echo cannot unmount dead but subsys locked instance $i at mount point ${EOS_FUSE_MOUNTDIR} 
                    echo_failure
                    echo
                    RETVAL=1;
                    continue
                fi
            fi
            rmdir ${EOS_FUSE_MOUNTDIR%/} # > /dev/null 2>&1
            if [ -d ${EOS_FUSE_MOUNTDIR} ]; then
                echo mount point ${EOS_FUSE_MOUNTDIR} for instance $i cannot be removed
                echo_failure
                echo
                RETVAL=1;
                continue
            fi
            rm -f /var/lock/subsys/$prog.$i > /dev/null 2>&1
            rm -f /var/run/$prog.$i.pid > /dev/null 2>&1
            getstatus $i
            eosdstatus="$?"
        fi
        if [ "$eosdstatus" -eq "2" ]; then
            echo -n "Starting $prog for instance: $i"
            mkdir -p /var/run/eosd/
            cd /var/run/eosd/
            mkdir -p /var/run/eosd/credentials/store
            chmod 1777 /var/run/eosd/credentials
            chmod 1777 /var/run/eosd/credentials/store
            mkdir -p ${EOS_FUSE_MOUNTDIR}
            chmod 700 ${EOS_FUSE_MOUNTDIR}
            unset KRB5CCNAME
            unset X509_USER_CERT
            unset X509_USER_KEY
            ulimit -S -c ${DAEMON_COREFILE_LIMIT:-0}
            ulimit -n 65000
            test -c /dev/fuse || modprobe fuse
            ${EOS_ROOT}/bin/${EOSD} ${EOS_FUSE_MOUNTDIR} -o${FUSE_OPT-""}max_readahead=131072,max_write=4194304,fsname=eos$i,allow_other,url=root://${EOS_FUSE_MGM_ALIAS-localhost}/${EOS_FUSE_REMOTEDIR}  >& /dev/null 
            pid=`pgrep -f "${EOS_ROOT}/bin/${EOSD} ${EOS_FUSE_MOUNTDIR}"`
            SRETVAL=$?
            if [ $SRETVAL -eq 0 ]; then
                touch /var/lock/subsys/$prog.$i
                echo $pid > /var/run/$prog.$i.pid
                echo_success;
            fi
            if [ $SRETVAL -gt 0 ]; then
                RETVAL=$SRETVAL;
            fi
            echo

            echo "EOS_FUSE_PING_TIMEOUT            : ${EOS_FUSE_PING_TIMEOUT}"
            echo "EOS_FUSE_DEBUG                   : ${EOS_FUSE_DEBUG}"
            echo "EOS_FUSE_LOWLEVEL_DEBUG          : ${EOS_FUSE_DEBUG}"
            echo "EOS_FUSE_NOACCESS                : ${EOS_FUSE_NOACCESS}"
            echo "EOS_FUSE_SYNC                    : ${EOS_FUSE_SYNC}"
            echo "EOS_FUSE_KERNELCACHE             : ${EOS_FUSE_KERNELCACHE}"
            echo "EOS_FUSE_DIRECTIO                : ${EOS_FUSE_DIRECTIO}"
            echo "EOS_FUSE_CACHE                   : ${EOS_FUSE_CACHE}"
            echo "EOS_FUSE_CACHE_SIZE              : ${EOS_FUSE_CACHE_SIZE}"
            echo "EOS_FUSE_CACHE_PAGE_SIZE         : ${EOS_FUSE_CACHE_PAGE_SIZE}"
            echo "EOS_FUSE_BIGWRITES               : ${EOS_FUSE_BIGWRITES}"
            echo "EOS_FUSE_EXEC                    : ${EOS_FUSE_EXEC}"
            echo "EOS_FUSE_NO_MT                   : ${EOS_FUSE_NO_MT}"
            echo "EOS_FUSE_SSS_KEYTAB              : ${EOS_FUSE_SSS_KEYTAB}"
            echo "EOS_FUSE_USER_KRB5CC             : ${EOS_FUSE_USER_KRB5CC}"
            echo "EOS_FUSE_USER_GSIPROXY           : ${EOS_FUSE_USER_GSIPROXY}"
            echo "EOS_FUSE_USER_KRB5FIRST          : ${EOS_FUSE_USER_KRB5FIRST}"
            echo "EOS_FUSE_PIDMAP                  : ${EOS_FUSE_PIDMAP}"
            echo "EOS_FUSE_RMLVL_PROTECT           : ${EOS_FUSE_RMLVL_PROTECT}"
            echo "EOS_FUSE_RDAHEAD                 : ${EOS_FUSE_RDAHEAD}"
            echo "EOS_FUSE_RDAHEAD_WINDOW          : ${EOS_FUSE_RDAHEAD_WINDOW}"
            echo "EOS_FUSE_LAZYOPENRO              : ${EOS_FUSE_LAZYOPENRO}"
            echo "EOS_FUSE_LAZYOPENRW              : ${EOS_FUSE_LAZYOPENRW}"
            echo "EOS_FUSE_ASYNC_OPEN              : ${EOS_FUSE_ASYNC_OPEN}"
            echo "EOS_FUSE_SHOW_SPECIAL_FILES      : ${EOS_FUSE_SHOW_SPECIAL_FILES}"
            echo "EOS_FUSE_SHOW_EOS_ATTRIBUTES     : ${EOS_FUSE_SHOW_EOS_ATTRIBUTES}"
            echo "EOS_FUSE_INLINE_REPAIR           : ${EOS_FUSE_INLINE_REPAIR}"
            echo "EOS_FUSE_MAX_INLINE_REPAIR_SIZE  : ${EOS_FUSE_MAX_INLINE_REPAIR_SIZE}"
            echo "EOS_FUSE_ATTR_CACHE_TIME         : ${EOS_FUSE_ATTR_CACHE_TIME}"
            echo "EOS_FUSE_ENTRY_CACHE_TIME        : ${EOS_FUSE_ENTRY_CACHE_TIME}"
            echo "EOS_FUSE_NEG_ENTRY_CACHE_TIME    : ${EOS_FUSE_NEG_ENTRY_CACHE_TIME}"
            echo "EOS_FUSE_CREATOR_CAP_LIFETIME    : ${EOS_FUSE_CREATOR_CAP_LIFETIME}"
            echo "EOS_FUSE_FILE_WB_CACHE_SIZE      : ${EOS_FUSE_FILE_WB_CACHE_SIZE}"
            echo "EOS_FUSE_MAX_WB_INMEMORY_SIZE    : ${EOS_FUSE_MAX_WB_INMEMORY_SIZE}"
            echo "EOS_FUSE_XRDBUGNULLRESPONSE_RETRYCOUNT    : ${EOS_FUSE_XRDBUGNULLRESPONSE_RETRYCOUNT}"
            echo "EOS_FUSE_XRDBUGNULLRESPONSE_RETRYSLEEPMS  : ${EOS_FUSE_XRDBUGNULLRESPONSE_RETRYSLEEPMS}"
	    echo "EOS_FUSE_RETRY_SOCKET_ERROR      : ${EOS_FUSE_RETRY_SOCKET_ERROR}"
            echo "EOS_FUSE_RETRY_CONNECTION_ERROR  : ${EOS_FUSE_RETRY_CONNECTION_ERROR}"
            echo "EOS_FUSE_LOG_PREFIX              : ${EOS_FUSE_LOG_PREFIX}"
            echo "EOS_FUSE_MOUNTDIR                : ${EOS_FUSE_MOUNTDIR}"
            echo "EOS_FUSE_REMOTEDIR               : ${EOS_FUSE_REMOTEDIR}"

            [[ "x$XRD_STREAMERRORWINDOW" != "x" ]] && echo "XRD_STREAMERRORWINDOW        : ${XRD_STREAMERRORWINDOW}"
        fi
        if [ "$eosdstatus" -eq "0" ]; then 
            echo eosd already running for instance $i. Pid is $eosdpid 
            echo Stop it first with 'service eosd stop'
            echo and try again or use directly 'service eosd restart'.
            RETVAL=1
            echo_warning
            echo
        fi
        )
    done
}

kill_eosd() {
    umdir="$1"
    pgrep -f "${EOS_ROOT}/bin/${EOSD} $umdir"    >& /dev/null
    existed=$?
    umount -f -l $umdir >& /dev/null
    pkill -f "${EOS_ROOT}/bin/${EOSD} $umdir"
    pgrep -f "${EOS_ROOT}/bin/${EOSD} $umdir"    >& /dev/null
    killed=$?
    while [ $killed -eq 0 ]; 
    do
        pkill -9 -f "${EOS_ROOT}/bin/${EOSD} $umdir"
        usleep 100000
        pgrep -f "${EOS_ROOT}/bin/${EOSD} $umdir" >& /dev/null
        killed=$?
    done
}

stop() {
    if [ -n "$1" ]; then
        EOS_FUSE_MOUNTS="$1";
    fi  
    for i in ${EOS_FUSE_MOUNTS}; do
        if [ "$i" = "main" ]; then
            [ -f /etc/sysconfig/eos ] && . /etc/sysconfig/eos
        else 
            if [ -f /etc/sysconfig/eos.$i ]; then
                . /etc/sysconfig/eos.$i
            else
                echo -n "Skipping fuse mount for instance $i - no /etc/sysconfig/eos.$i configuration file"
                echo 
                echo_warning
                echo 
                continue;
            fi
        fi
        echo -n "Stopping $prog for instance: $i"
        umdir="${EOS_FUSE_MOUNTDIR}";
        kill_eosd "$umdir"
        echo
        if [ $existed -eq 0 ]; then
            # we cleanup only if a clean shutdown can be done
            rm -f /var/lock/subsys/$prog.$i
            rm -f /var/run/$prog.$i.pid
            echo_success
        else
            echo_failure
        fi    
        echo
        RETVAL=0;
    done
}

stop_force() {
        PIDS=$( pgrep -f "^${EOS_ROOT}/bin/${EOSD} " )
        [ "A$PIDS" = "A" ] && return
        for p in $PIDS; do 
            cat /proc/$p/cmdline | tr '\0' '$' | xargs echo | { IFS="\$" read dumpit umdir dumpit ; echo -n "Force stopping $prog for mount point $umdir"; echo_warning;  echo; kill_eosd $umdir; } 
        done
        rm -rf /var/lock/subsys/$prog.* > /dev/null 2>&1
        rm -f /var/run/$prog.*.pid > /dev/null 2>&1
}


getstatus() {
    if [ -n "$1" ]; then
        EOS_FUSE_MOUNTS="$1";
    fi
    local i=""
    # Loop over xrootd roles
    for i in ${EOS_FUSE_MOUNTS}; do
        pid=`pidofproc $prog.$i`
        type=""
        if [ -n "$pid" ]; then
            [ -z ${_NODISP_STATUS_} ] && echo $"$prog for instance: $i (pid $pid) is running $type ..."
            continue
        else
            # See if /var/lock/subsys/$prog.$i exists
            if [ -f /var/lock/subsys/$prog.$i ]; then
                [ -z ${_NODISP_STATUS_} ] && echo $"$prog for instance: $i dead but subsys locked"
                RETVAL=1
            else
                pid=$(pgrep -f "^/usr/bin/${EOSD}.*fsname=eos$i")
                if [ -n "$pid" ]; then
                    [ -z ${_NODISP_STATUS_} ] && echo $"$prog for instance: $i is starting (pid $pid) "
                    RETVAL=0
                else
                    [ -z ${_NODISP_STATUS_} ] && echo $"$prog for instance: $i  is stopped"
                    RETVAL=2
                fi
            fi
        fi                       
    done
     
    return $RETVAL
}

restart() {
    stop $1
    start $1
}       

reload() {
    restart $1
}

case "$1" in
    start)
    export _NODISP_STATUS_=1
    start $2
    ;;
    stop)
    stop $2
    ;;
    stop_force)
    stop_force
    ;;
    killall)
    stop
    stop_force
    ;;
    reload|restart)
    export _NODISP_STATUS_=1
    restart $2
    ;;
    condrestart)   
    export _NODISP_STATUS_=1 
    for i in ${2-${EOS_FUSE_MOUNTS}}; do
        getstatus $i
        if [[ $? < 2 ]]; then
            stop $i
            start $i
        fi
    done
    ;;
    status)
    
    getstatus $2
    RETVAL=$?
    ;;
    *)
    
    echo $"Usage: $0 {start|stop|restart|reload|condrestart|status}"
    RETVAL=1
esac

exit $RETVAL
