#!/bin/ksh -p
#*******************************************************************************
#
# NAME:         rdac_disks
# SUMMARY:      %description%
# COMPONENT:    solsysd
# VERSION:      %version: 12_6 %
# UPDATE DATE:  %date_modified: Mon Aug 28 09:31:33 2000 %
# 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.
#
#
# SYNTAX:
# rdac_disks [ -v ] [ -r directory  ]  
# 
# -v - turn on shell trace (-x)
#
# NOTES:
#
# RETURNS:
# 0 - successful termination
#
# 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;
}


#*******************************************************************************
# 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 vr: $* 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=$2; shift 2;;
	--) shift; break;;
        esac
done

if [ "${VERBOSE}" = "TRUE" ]
then
	set -x
fi


`grep -v "^#" $RMPARAMS_FILE | grep "Rdac_RdacDisksDisable.*=.*TRUE" >/dev/null 2>&1`
if [ $? -eq 0  ]       
then
	if [ -d /usr/lib/devfsadm/linkmod ]
	then
		`ls /usr/lib/devfsadm/linkmod | grep RAIDarray >/dev/null 2>$1`
		if [ $? -eq 0  ]
		then
			exit 0
		fi
	fi
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

RDAC_LOADED=`modinfo | grep rdriver`

# See, he's checking for the parameter, and looking at the exit status of the 'grep'
# Be glad this is the only place in the script this happens.
grep -v "^#" $RMPARAMS_FILE | grep "Rdac_SupportDisabled.*=.*TRUE" >/dev/null 2>&1

if [ $? != 0  ] && [ -n "${RDAC_LOADED}" ]
then
	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
fi

# List the two directories, including just the file name

cd /tmp/dev.$$/dsk
ls -1 >/tmp/new_list.$$
cd $TARGET_DIRECTORY/dev/dsk
ls -1 >/tmp/target_list.$$

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

/usr/bin/join -v 2 /tmp/new_list.$$ /tmp/target_list.$$ >/tmp/rm_list.$$

cd $TARGET_DIRECTORY/dev/dsk
cat /tmp/rm_list.$$ | /usr/bin/xargs rm 2>/dev/null
cd $TARGET_DIRECTORY/dev/rdsk
cat /tmp/rm_list.$$ | /usr/bin/xargs rm 2>/dev/null

# List the two directories, including file name and symbolic link pointer

cd /tmp/dev.$$/dsk
ls -l | tr -s " " | cut -d " " -f9,11 >/tmp/new_list.$$
cd $TARGET_DIRECTORY/dev/dsk
ls -l | tr -s " " | cut -d " " -f9,11 >/tmp/target_list.$$

#
# Remove everything that is entirely equal in both lists from the new
# /tmp/dev.$$/[r]dsk directories
#
# Note: This compares both the file name and the symbolic link pointer. There
# should be no "$" delimiter in any of the lines.
#

/usr/bin/join -t"$" /tmp/new_list.$$ /tmp/target_list.$$ | cut -d" " -f1 >/tmp/rm_list.$$

cd /tmp/dev.$$/dsk
cat /tmp/rm_list.$$ | /usr/bin/xargs rm 2>/dev/null
cd /tmp/dev.$$/rdsk
cat /tmp/rm_list.$$ | /usr/bin/xargs rm 2>/dev/null

#
# Remove everything that is in the target list but not the same in the new list
# from the target directories
#
# Note: This compares both the file name and the symbolic link pointer. There
# should be no "$" delimiter in any of the lines.
#

/usr/bin/join -t"$" -v 2 /tmp/target_list.$$ /tmp/new_list.$$ | cut -d" " -f1 >/tmp/rm_list.$$

cd $TARGET_DIRECTORY/dev/dsk
cat /tmp/rm_list.$$ | /usr/bin/xargs rm 2>/dev/null
cd $TARGET_DIRECTORY/dev/rdsk
cat /tmp/rm_list.$$ | /usr/bin/xargs rm 2>/dev/null

rm /tmp/new_list.$$ 2>/dev/null
rm /tmp/target_list.$$ 2>/dev/null
rm /tmp/rm_list.$$ 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
