#!/bin/ksh
#*******************************************************************************
#
# NAME:         rdac_disks
# SUMMARY:      %description%
# COMPONENT:    solsysd
# VERSION:      2
# UPDATE DATE:  %date_modified: Tue Nov 10 12:13:16 1998 %
# PROGRAMMER:   %created_by:    mgallagh %
#
#               Copyright 1996, 1997, 1998 by Symbios Logic Inc.
#
# DESCRIPTION:
# rdac_disks is a shell script whose function is to replace the Solaris "disks" program.
# It Hides the RDAC device and expose the Native drivers table entries and executes
# the Solaris "disks -r /dev/[osa|symsm]" command. It then uses cpio to copy the
# /dev/[osa|symsm]/dev/[r]dsk directories to the directories specified by the
# script invocation. It then links the array symlink names to the RDAC nodes.
#
# NOTES:
#
# REFERENCE:
#
# CODING STANDARD WAIVERS:
#
#*******************************************************************************

#*******************************************************************************
# PROCEDURE:    CleanRd
# SUMMARY:      Remove rdriver nodes from device directories.
#
# DESCRIPTION:
# CleanRd removes all node referring to the RDAC driver from a set of device
# directories (both dsk and rdsk).  The  directory to be cleaned is given by
# "$1".
#
# SYNTAX:
# CleanRd <dev dir path>
# <dev dir path> - the path to the device directory from which the nodes are to
#                  be removed (e.g., /dev/SYMsm, or just "/")
#
# NOTES:
#
# RETURNS:
# Nothing
#
CleanRd()

{
	RDAC_DRIVER_NAME=rdriver
        DELETE_LIST=`ls -l  $1/dev/rdsk | grep $RDAC_DRIVER_NAME | tr -s " " | cut -d" " -f9`
        ( if [ -d $1/dev/rdsk ]
        then
                cd $1/dev/rdsk
                rm $DELETE_LIST 2>/dev/null
        fi ) &
        ( if [ -d $1/dev/dsk ]
        then
                cd $1/dev/dsk
                rm $DELETE_LIST 2>/dev/null
        fi ) &
        wait;
}

#
# SYNTAX:
# rdac_disks [ -v ] [ -r directory  ]  
# 
# -v - turn on shell trace (-x)
#
# NOTES:
#
# RETURNS:
# 0 - successful termination

#*******************************************************************************
# PROCEDURE:	MutexAcquire
# SUMMARY:	get exclusive ownership of mutex file
#
# DESCRIPTION:
# MutexAcquire will try repeatedly to acquire a "mutex file" - success means
# the thread has been admitted to a "critical region"
#
# SYNTAX:
# MutexAcquire <mutex file>
# <mutex file> - name of the mutex guarding the critical region
#
# NOTES:
# MutexAcquire and the program it calls, rm_mutex_acquire, rely on O_CREAT
# semantics
#
# RETURNS:
# Nothing

MutexAcquire()
{
	while true
	do
		$RM_BOOT_HOME/rm_mutex_acquire $1
		if [ $? = 0 ]
		then
			break;
		fi
		sleep 1
	done;
}

#*******************************************************************************
# PROCEDURE:	MutexRelease
# SUMMARY:	relenquish mutex file ownership
#
# DESCRIPTION:
# MutexRelease releases mutex file ownership, so another thread can enter the
# critical region
#
# SYNTAX:
# MutexRelease <mutex file>
# <mutex file> - name of the mutex guarding the critical region
#
# NOTES:
#
# RETURNS:
# Nothing

MutexRelease()
{
	/bin/rm $1;
}

#*******************************************************************************
# PROCEDURE:	AddRdacAdrsFile
# SUMMARY:	Add to the /etc/raid/rdac_address file
#
# RETURNS:
# Nothing

AddRdacAdrsFile()
{
ADRS_MODULE_NAME=$1
ADRS_FIRST_NEXUS_PATH=$2
ADRS_SECOND_NEXUS_PATH=$3
RM_BOOT_HOME=`grep -v "^#" $RMPARAMS_FILE | grep System_RmBootHomeDirectory | cut -d= -f2`
STORUTIL=$RM_BOOT_HOME/storutil
RDACUTIL=$RM_BOOT_HOME/rdacutil

if [ "${ADRS_FIRST_NEXUS_PATH}" = "VOID" ]  
then
	ADRS_FIRST_NEXUS_PATH=""
fi

if [ -z "${ADRS_FIRST_NEXUS_PATH}" ]  &&  [ -z "${ADRS_SECOND_NEXUS_PATH}" ]
then
	return 0
fi

if [ -z "${ADRS_FIRST_NEXUS_PATH}" ]  
then
	echo "$ADRS_MODULE_NAME:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:" >>$RDAC_ADRS_FILE
	if [ $? -ne 0 ]
	then
		echo "Error adding Array Module $ADRS_MODULE_NAME to the RDAC address file"
		return 2
	fi
	return 0
fi

if [ -z "${ADRS_SECOND_NEXUS_PATH}" ]  
then
	echo "$ADRS_MODULE_NAME:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:" >>$RDAC_ADRS_FILE
	if [ $? -ne 0 ]
	then
		echo "Error adding Array Module $ADRS_MODULE_NAME to the RDAC address file"
		return 3
	fi
	return 0
fi

	
PATH_A_LUNS=`$STORUTIL -Z -c $ADRS_FIRST_NEXUS_PATH 2>/dev/null | grep ContALunMask | cut -d: -f2`
if [ $? -eq 0 ]
then
	PATH_B_LUNS=`$STORUTIL -Z -c $ADRS_FIRST_NEXUS_PATH 2>/dev/null | grep ContBLunMask | cut -d: -f2`
fi

if [ -z "${PATH_A_LUNS}" ] && [ -z "${PATH_B_LUNS}" ]
then
	PATH_A_LUNS=`$STORUTIL -Z -c $ADRS_SECOND_NEXUS_PATH 2>/dev/null | grep ContALunMask | cut -d: -f2`
	if [ $? -eq 0 ]
	then
		PATH_B_LUNS=`$STORUTIL -Z -c $ADRS_SECOND_NEXUS_PATH 2>/dev/null | grep ContBLunMask | cut -d: -f2`
	fi
fi

if [ -z "${PATH_A_LUNS}" ] && [ -z "${PATH_B_LUNS}" ]
then
	ACTIVE_PATH=`$RDACUTIL -i -c $ADRS_FIRST_NEXUS_PATH 2>/dev/null`

	if [ -z "${ACTIVE_PATH}" ]
	then
		ACTIVE_PATH=`$RDACUTIL -i -c $ADRS_SECOND_NEXUS_PATH 2>/dev/null`
	fi

	if [ -z "${ACTIVE_PATH}" ]
	then
		return 0
	fi

	ACTIVE_CONTROLLER=`echo "$ACTIVE_PATH" | grep "controller a"`

	if [ -z "${ACTIVE_PATH}" ]
	then
		echo "$ADRS_MODULE_NAME:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:B:" >>$RDAC_ADRS_FILE
		if [ $? -ne 0 ]
		then
			echo "Error adding Array Module $ADRS_MODULE_NAME to the RDAC address file"
			return 4
		fi
	else
		echo "$ADRS_MODULE_NAME:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:A:" >>$RDAC_ADRS_FILE
		if [ $? -ne 0 ]
		then
			echo "Error adding Array Module $ADRS_MODULE_NAME to the RDAC address file"
			return 5
			fi
 		fi
	return 0
fi

MODULE_ADRS=$ADRS_MODULE_NAME:

for i in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
do
	A_CNTRL=`echo $ADRS_FIRST_NEXUS_PATH | cut -dd -f1`
	B_CNTRL=`echo $ADRS_SECOND_NEXUS_PATH | cut -dd -f1`
	A_PATH_EXISTS=`ls -l /dev/rdsk/$A_CNTRL"d$i""s0" 2>/dev/null | grep rdnexus`
	B_PATH_EXISTS=`ls -l /dev/rdsk/$B_CNTRL"d$i""s0" 2>/dev/null | grep rdnexus`

	if [ -n "${B_PATH_EXISTS}" ] && [ -z "${A_PATH_EXISTS}" ]
	then
		MODULE_ADRS="${MODULE_ADRS}"B:
		continue
	fi

	if [ -n "${A_PATH_EXISTS}" ] && [ -z "${B_PATH_EXISTS}" ]
	then
		MODULE_ADRS="${MODULE_ADRS}"A:
		continue
	fi

	B_CREATE=""

	for BLUN in $PATH_B_LUNS
	do

		if [ "${BLUN}" = "${i}" ]
		then
			MODULE_ADRS="${MODULE_ADRS}"B:
			B_CREATE="YES"
			break
		fi
	done

	if [ -z "${B_CREATE}" ]
	then
		MODULE_ADRS="${MODULE_ADRS}"A:
	fi
done

echo $MODULE_ADRS  >>$RDAC_ADRS_FILE
if [ $? -ne 0 ]
then
	echo "Error adding Array Module $ADRS_MODULE_NAME to the RDAC address file"
	return 6
fi

return 0

}


#*******************************************************************************
# PROCEDURE:	CreateRdacAdrsFile
# SUMMARY:	Create the /etc/raid/rdac_address file
#
# RETURNS:
# Nothing

CreateRdacAdrsFile()
{
cat /tmp/disksmnf.$$ |
while read CTRL_INFO
do
	if [ $? -ne 0 ]
	then
		echo "Error while creating RDAC Address File: Unable to read /tmp/disksmnf.$$"
		return 1
	fi

	ADRS_MODULE_NAME=`echo $CTRL_INFO | cut -d~ -f1`

	ADRS_FIRST_NEXUS_PATH=`echo $CTRL_INFO | cut -d~ -f9`

	SLICE0="s0"
	PATH_SLICE=`echo $ADRS_FIRST_NEXUS_PATH | grep s`
	if [ -n "${ADRS_FIRST_NEXUS_PATH}" ] && [ -z "${PATH_SLICE}" ]
	then
		ADRS_FIRST_NEXUS_PATH="$ADRS_FIRST_NEXUS_PATH""$SLICE0"
	fi

	ADRS_SECOND_NEXUS_PATH=`echo $CTRL_INFO | cut -d~ -f10`

	PATH_SLICE=`echo $ADRS_SECOND_NEXUS_PATH | grep s`
	if [ -n "${ADRS_SECOND_NEXUS_PATH}" ] && [ -z "${PATH_SLICE}" ]
	then
		ADRS_SECOND_NEXUS_PATH="$ADRS_SECOND_NEXUS_PATH""$SLICE0"
	fi

	if [ -z "${ADRS_FIRST_NEXUS_PATH}" ]
	then
		AddRdacAdrsFile "$ADRS_MODULE_NAME"  "VOID"  $ADRS_SECOND_NEXUS_PATH
	else
		AddRdacAdrsFile "$ADRS_MODULE_NAME"  $ADRS_FIRST_NEXUS_PATH  $ADRS_SECOND_NEXUS_PATH
	fi

	if [ $? -ne 0 ]
	then
		return 2
	fi
done
return 0
}

# D I S K S   M A I N   P R O C E D U R E

RMPARAMS_FILE=/etc/raid/rmparams

MAXLUNS=`grep -v "^#" $RMPARAMS_FILE | grep System_MaxLunsPerController | cut -d= -f2`
MAXIDS=`grep -v "^#" $RMPARAMS_FILE | grep System_MaxSCSIid | cut -d= -f2`

RM_HOME=`grep -v "^#" $RMPARAMS_FILE | grep System_RmHomeDirectory | cut -d= -f2`
MAXLUNS=`grep -v "^#" $RMPARAMS_FILE | grep System_MaxLunsPerController | cut -d= -f2`

RM_BOOT_HOME=`grep -v "^#" $RMPARAMS_FILE | grep System_RmBootHomeDirectory | cut -d= -f2`
RM_NAME_FILE=`grep -v "^#" $RMPARAMS_FILE | grep System_NamefileDirPath | cut -d= -f2`
RMDEVROOT=`grep -v "^#" $RMPARAMS_FILE | grep "System_AltDevDirRoot" | cut -d= -f2 | awk -F/ '{ ORS = "/"; for (i = NF; i > 1; --i) print $i; ORS = "\n"; print $1 }' | cut -d"/" -f3-32 |  awk -F/ '{ ORS = "/"; for (i = NF; i > 1; --i) print $i; ORS = "\n"; print $1 }'`
TARGET_DIRECTORY=""

LAD=$RM_BOOT_HOME/lad
STORUTIL=$RM_BOOT_HOME/storutil
RDACUTIL=$RM_BOOT_HOME/rdacutil
RDACCONFIG=$RM_BOOT_HOME/rdacconfig
RDAC_ADRS_FILE=/etc/raid/rdac_address 

USAGE="Usage:  $0 [ -v ] [ -r directory  ] "
VERBOSE=FALSE


set -- `getopt v:r $* 2>/dev/null`
if [ $? != 0 ]
then
	echo $USAGE
	exit 1
fi
for i in $*
do
	case $i in
	-v) VERBOSE=TRUE; shift;;
	-r) TARGET_DIRECTORY=$3; shift 2;;
	--) shift; break;;
        esac
done

if [ "${VERBOSE}" = "TRUE" ]
then
	set -x
fi
MutexAcquire /tmp/mutex.disksh	# Begin critical region

# First run Solaris disks into the SYMsm directory with native devices exposed

RDAC_LOADED=`modinfo | grep rdriver`
if [ -n "${RDAC_LOADED}" ] && [ -c $RMDEVROOT/dev/rdsk/rdac ]
then
	$RM_BOOT_HOME/hide_sd off 1>/dev/null 2>/dev/null
fi

/usr/sbin/disks -r $RMDEVROOT
if [ $? != 0 ]
then
	echo "ERROR: The Solaris disks program failed"
	RDAC_LOADED=`modinfo | grep rdriver`
	if [ -n "${RDAC_LOADED}" ] && [ -c $RMDEVROOT/dev/rdsk/rdac ]
	then
		$RM_BOOT_HOME/hide_sd on 1>/dev/null 2>/dev/null
	fi
	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 2
fi

RDAC_LOADED=`modinfo | grep rdriver`
if [ -n "${RDAC_LOADED}" ] && [ -c $RMDEVROOT/dev/rdsk/rdac ]
then
	$RM_BOOT_HOME/hide_sd on 1>/dev/null 2>/dev/null
fi

CleanRd $RMDEVROOT

if [ "${TARGET_DIRECTORY}" = "${RMDEVROOT}" ]
then
	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 0
fi

# Create temporary holding directories

mkdir /tmp/dev.$$ 2>/dev/null
mkdir /tmp/dev.$$/dsk 2>/dev/null
mkdir /tmp/dev.$$/rdsk 2>/dev/null

# Copy the results to /dev/[r]dsk

if [ -n  "${TARGET_DIRECTORY}" ]
then
	mkdir $TARGET_DIRECTORY/dev 2>/dev/null
	mkdir $TARGET_DIRECTORY/dev/dsk 2>/dev/null
	mkdir $TARGET_DIRECTORY/dev/rdsk 2>/dev/null
fi

cd $RMDEVROOT/dev/dsk

find . -name "c*t*d*s*" -print | cpio -pu /tmp/dev.$$/dsk 2>/dev/null
if [ $? != 0 ]
then
	echo "ERROR: The copy of Symbolic Links to /tmp/dev.$$/dsk failed"
	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 3
fi

cd $RMDEVROOT/dev/rdsk

find . -name "c*t*d*s*" -print | cpio -pu /tmp/dev.$$/rdsk 2>/dev/null
if [ $? != 0 ]
then
	echo "ERROR: The copy of Symbolic Links to /tmp/dev.$$/rdsk failed"
	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 4
fi

if grep -v "^#" $RMPARAMS_FILE | grep "Rdac_SupportDisabled.*=.*TRUE" >/dev/null 2>&1
then

	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 0
fi

RDAC_LOADED=`modinfo | grep rdriver`
if [ -z "${RDAC_LOADED}" ]
then
	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 0
fi

if grep -v "^#" $RMPARAMS_FILE | grep "Rdac_SinglePathSupportDisabled.*=.*TRUE" >/dev/null 2>&1
then
	RDAC_NO_SINGLE="TRUE"
fi

if grep -v "^#" $RMPARAMS_FILE | grep "Rdac_ExposeDualPath.*=.*TRUE" >/dev/null 2>&1
then
	RDAC_DUAL_PATH="TRUE"
fi

$LAD >/dev/null



cat $RM_NAME_FILE >/tmp/disksmnf.$$ 2>/dev/null
if [ $? -ne 0 ]
then
	echo "Error while creating disks RDAC Symbolic Links: Unable to read $RM_NAME_FILE or create /tmp/disksmnf.$$"
	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 5
fi

if [ -s /etc/raid/rdac_address ]
then
 	continue
else
	CreateRdacAdrsFile
fi

cat /tmp/disksmnf.$$ |
while read CTRL_INFO
do
	if [ $? -ne 0 ]
	then
		echo "Error while creating RDAC Symbolic Links: Unable to read /tmp/disksmnf.$$"
		MutexRelease /tmp/mutex.disksh	# End of critical region
		exit 6
	fi

	MODULE_NAME=`echo $CTRL_INFO | cut -d~ -f1`

	FIRST_NEXUS_PATH=`echo $CTRL_INFO | cut -d~ -f9`

	SLICE0="s0"
	PATH_SLICE=`echo $FIRST_NEXUS_PATH | grep s`
	if [ -n "${FIRST_NEXUS_PATH}" ] &&  [ -z "${PATH_SLICE}" ]
	then
		FIRST_NEXUS_PATH="$FIRST_NEXUS_PATH""$SLICE0"
	fi

	SECOND_NEXUS_PATH=`echo $CTRL_INFO | cut -d~ -f10`

	PATH_SLICE=`echo $SECOND_NEXUS_PATH | grep s`
	if [ -n "${SECOND_NEXUS_PATH}" ] &&  [ -z "${PATH_SLICE}" ]
	then
		SECOND_NEXUS_PATH="$SECOND_NEXUS_PATH""$SLICE0"
	fi

	MODULE_ADRS_ENTRY=`cat $RDAC_ADRS_FILE | grep "$MODULE_NAME"`

	if [ -z "${MODULE_ADRS_ENTRY}" ]
	then
		if [ -z "${FIRST_NEXUS_PATH}" ]
		then
			AddRdacAdrsFile "$MODULE_NAME"  "VOID"  $SECOND_NEXUS_PATH
		else
			AddRdacAdrsFile "$MODULE_NAME"  $FIRST_NEXUS_PATH  $SECOND_NEXUS_PATH
		fi
	fi

	MODULE_ADRS_ENTRY=`cat $RDAC_ADRS_FILE | grep "$MODULE_NAME"`

	if [ -z "${MODULE_ADRS_ENTRY}" ]
	then
		echo "Error unable to add $MODULE_NAME to RDAC Address file"
		MutexRelease /tmp/mutex.disksh	# End of critical region
		exit 7
	fi

	if [ -n "${RDAC_NO_SINGLE}" ]
	then
		if [ -z "${FIRST_NEXUS_PATH}" ] || [ -z "${SECOND_NEXUS_PATH}" ]
		then
			continue
		fi
	fi

	if [ -z "${FIRST_NEXUS_PATH}" ]  &&  [ -z "${SECOND_NEXUS_PATH}" ]
	then
		continue
	fi

	A_CT=`echo $FIRST_NEXUS_PATH | cut -dd -f1`
	if  [ -n "${FIRST_NEXUS_PATH}" ]
	then
		LUN=`echo $FIRST_NEXUS_PATH | cut -dd -f2`
	else
		LUN=`echo $SECOND_NEXUS_PATH | cut -dd -f2`
	fi

	LUN_SLICE=`echo $LUN | grep s`
	if [ -n "${LUN_SLICE}" ]
	then
		LUN=`echo $LUN | cut -ds -f1`
	fi

	B_CT=`echo $SECOND_NEXUS_PATH | cut -dd -f1`

	

	if [ -z "${A_CT}" ] && [ -z "${B_CT}" ]
	then
		continue
	fi

	A_NEXUS_BUS=`echo $A_CT | cut -dc -f2 | cut -dt -f1`
	B_NEXUS_BUS=`echo $B_CT | cut -dc -f2 | cut -dt -f1`

	A_NEXUS_TARGET=`echo $A_CT | cut -dt -f2`
	B_NEXUS_TARGET=`echo $B_CT | cut -dt -f2`

	for LUN in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
	do
		if [ $MAXLUNS = $LUN ]
		then
			break
		fi

		LUN_FIELD=`expr $LUN + 2`
		LUN_OWNER=`echo $MODULE_ADRS_ENTRY | cut -d: -f$LUN_FIELD`
		UNIT_HEX=`echo ${LUN} | awk '{printf("%x", $0)}'`
		A_TARG_HEX=`echo ${A_NEXUS_TARGET} | awk '{printf("%x", $0)}'`
		B_TARG_HEX=`echo ${B_NEXUS_TARGET} | awk '{printf("%x", $0)}'`

		A_PHYS_NAME=../../devices/pseudo/rdnexus@${A_NEXUS_BUS}/rdriver@${A_TARG_HEX},${UNIT_HEX}:
		B_PHYS_NAME=../../devices/pseudo/rdnexus@${B_NEXUS_BUS}/rdriver@${B_TARG_HEX},${UNIT_HEX}:

		if [ -n "${FIRST_NEXUS_PATH}" ]
		then
			if [ "${LUN_OWNER}" = "A" ] || [ -n "${RDAC_DUAL_PATH}"  ]
			then
				LINK_SLICE=0
				for SLICE in a b c d e f g h
				do
					if [ $LINK_SLICE == 0 ] 
					then
						if [ -h /tmp/dev.$$/rdsk/${A_CT}d${LUN}s${LINK_SLICE} ]
						then
							rm /tmp/dev.$$/dsk/${A_CT}d${LUN}s*  2>/dev/null
  							rm /tmp/dev.$$/rdsk/${A_CT}d${LUN}s* 2>/dev/null
							if [ -n "${B_CT}" ] && [ -z "${RDAC_DUAL_PATH}"  ]
							then
								rm /tmp/dev.$$/dsk/${B_CT}d${LUN}s*  2>/dev/null
  								rm /tmp/dev.$$/rdsk/${B_CT}d${LUN}s* 2>/dev/null
							fi
						else
							break
						fi
					fi
					ln -s ${A_PHYS_NAME}${SLICE} /tmp/dev.$$/dsk/${A_CT}d${LUN}s${LINK_SLICE} >/dev/null 2>&1
					if [ $? -ne 0 ]
					then
						echo "Error creating RDAC Node Link /tmp/dev.$$/dsk/${A_CT}d${LUN}s${LINK_SLICE}"
					fi
					
					ln -s ${A_PHYS_NAME}${SLICE},raw /tmp/dev.$$/rdsk/${A_CT}d${LUN}s${LINK_SLICE} >/dev/null 2>&1
					if [ $? -ne 0 ]
					then
						echo "Error creating RDAC Node Link /tmp/dev.$$/rdsk/${A_CT}d${LUN}s${LINK_SLICE}"
					fi
					
					LINK_SLICE=`expr $LINK_SLICE + 1`
				done
			fi

		fi

		if [ -n "${SECOND_NEXUS_PATH}" ]
		then
			if [ "${LUN_OWNER}" = "B" ] || [ -n "${RDAC_DUAL_PATH}"  ]
			then
				LINK_SLICE=0
				for SLICE in a b c d e f g h
				do
					if [ $LINK_SLICE == 0 ] 
					then 
						if [ -h /tmp/dev.$$/rdsk/${B_CT}d${LUN}s${LINK_SLICE} ]
						then
					
 							rm /tmp/dev.$$/dsk/${B_CT}d${LUN}s*  2>/dev/null
  							rm /tmp/dev.$$/rdsk/${B_CT}d${LUN}s* 2>/dev/null
							if [ -n "${A_CT}" ] && [ -z "${RDAC_DUAL_PATH}"  ]
			       				then
			       					rm /tmp/dev.$$/dsk/${A_CT}d${LUN}s*  2>/dev/null
  			       					rm /tmp/dev.$$/rdsk/${A_CT}d${LUN}s* 2>/dev/null
			       				fi
						else
							break
						fi
			       		fi
			       		ln -s ${B_PHYS_NAME}${SLICE} /tmp/dev.$$/dsk/${B_CT}d${LUN}s${LINK_SLICE} >/dev/null 2>&1
			       		if [ $? -ne 0 ]
			       		then
			       			echo "Error creating RDAC Node Link /tmp/dev.$$/dsk/${B_CT}d${LUN}s${LINK_SLICE}"
			       		fi
					
			       		ln -s ${B_PHYS_NAME}${SLICE},raw /tmp/dev.$$/rdsk/${B_CT}d${LUN}s${LINK_SLICE} >/dev/null 2>&1
			       		if [ $? -ne 0 ]
			       		then
			       			echo "Error creating RDAC Node Link /tmp/dev.$$/rdsk/${B_CT}d${LUN}s${LINK_SLICE}"
			       		fi
			       							
			       		LINK_SLICE=`expr $LINK_SLICE + 1`
			       done
			fi

		fi
	done
	
done

# Delete entries from the target directory which
# are not in the new list

cd $TARGET_DIRECTORY/dev/dsk
ls >/tmp/devlist.$$
cd /tmp/dev.$$/dsk
cat /tmp/devlist.$$ |
while read SYMLINK
do
	LINK_FOUND=`ls | grep $SYMLINK`
	if [ -z "${LINK_FOUND}" ]
	then
		rm $TARGET_DIRECTORY/dev/dsk/$SYMLINK 2>/dev/null
		rm $TARGET_DIRECTORY/dev/rdsk/$SYMLINK 2>/dev/null
	fi
done

rm /tmp/devlist.$$ 2>/dev/null

cd /tmp/dev.$$/dsk
ls >/tmp/devlist.$$
cat /tmp/devlist.$$ |
while read SYMLINK
do
	cd /tmp/dev.$$/dsk
	TMP_ENTRY=`ls -l | grep $SYMLINK | cut -d">" -f2 2>/dev/null`

	cd $TARGET_DIRECTORY/dev/dsk
	TARGET_ENTRY=`ls -l | grep $SYMLINK | cut -d">" -f2 2>/dev/null`

	if [ "${TMP_ENTRY}" = "${TARGET_ENTRY}" ]
	then
		rm /tmp/dev.$$/dsk/$SYMLINK 2>/dev/null
		rm /tmp/dev.$$/rdsk/$SYMLINK 2>/dev/null
	else
		rm $TARGET_DIRECTORY/dev/dsk/$SYMLINK 2>/dev/null
		rm $TARGET_DIRECTORY/dev/rdsk/$SYMLINK 2>/dev/null
	fi
done

rm /tmp/devlist.$$ 2>/dev/null

cd /tmp/dev.$$/dsk
find . -name "c*t*d*s*" -print | cpio -pu $TARGET_DIRECTORY/dev/dsk 2>/dev/null
if [ $? != 0 ]
then
	echo "ERROR: The copy of Symbolic Links to $TARGET_DIRECTORY/dev/dsk failed"
	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 4
fi

cd /tmp/dev.$$/rdsk
find . -name "c*t*d*s*" -print | cpio -pu $TARGET_DIRECTORY/dev/rdsk 2>/dev/null
if [ $? != 0 ]
then
	echo "ERROR: The copy of Symbolic Links to $TARGET_DIRECTORY/dev/rdsk failed"
	MutexRelease /tmp/mutex.disksh	# End of critical region
	exit 4
fi

cd /
rm  /tmp/disksmnf.$$  2>/dev/null
rm  -r /tmp/dev.$$  2>/dev/null

MutexRelease /tmp/mutex.disksh	# End of critical region

exit 0
