#===============================================================================
# SSS Firmware
#===============================================================================
# File 			:	lib_vol
# Who			:	JWB
# Descripttion	:	raid ,volume, bay control
#
# Copyright		:	LG ELECTRONICS INC.
# history 		:	2008.11.21 separated from lib_sss
#===============================================================================
. /etc/sss_script/event/lib_io

#guaranteed 1MB/Sec	
#200MB/Sec (250GB:13hours)
MD_SPEEDLIMIT_RAID5=200000
#200MB/Sec
MD_SPEEDLIMIT_RAID1=200000
#===============================================================================
# Description	:
# input 		:	1(sda,sdb,sdc,sdd)
# output 		:   1(host0, host1)
#===============================================================================
DevToHostNumWithFile()
{
	HostNum=`cat ${DIF_SCSI_LIST} | grep ${1%%[0-9]} |awk '{print $2}'`
	return 0
}
#===============================================================================
# Description	:
# input 		:	1(host0, host1)
# output 		:   1(sda,sdb,sdc,sdd)
#===============================================================================
DevFromHostNumWithFile()
{
	DevName=`cat ${DIF_SCSI_LIST} | grep ${1} |awk '{print $1}'`
	return 0
}
#===============================================================================
# Description	:
# input 		:	1(sda,sdb,sdc,sdd)
# output 		:   1(host0, host1)
#===============================================================================
DevToHostNumWithSystem()
{
	HostNum=`find /sys/block/ -name device |xargs ls -l |awk '{print $9 $11}'|awk -F'/' '{print $4" "$10}' | grep ${1%%[0-9]} |awk '{print $2}'`
	return 0
}
#===============================================================================
# Description	:
# input 		:	1(host0, host1)
# output 		:   1(sda,sdb,sdc,sdd)
#===============================================================================
DevFromHostNumWithSystem()
{
	DevName=`find /sys/block/ -name device |xargs ls -l |awk '{print $9 $11}'|awk -F'/' '{print $4" "$10}' | grep ${1} |awk '{print $1}'`
	if [ ! -z "$DevName" ]; then
		echo $DevName
		return 0
	else
		return 1
	fi
}
#===============================================================================
# Description	:
# input 		:	1()
# output 		:   1()
#===============================================================================
#mk_mdadm_conf()
#{
#	echo "DEVICE partitions" > /etc/mdadm.conf
#	mdadm -D -s >> /etc/mdadm.conf
#}

#===============================================================================
# Description	:
# input 		:	1()
# output 		:   1()
#===============================================================================
SSS_PartitionMake()
{
	echo "SSS_PartitionMake($*)"
	for dev in ${1}1 ${1}2 ${1}3 ${1}4 ${1}
	do
    grep $dev /proc/partitions
		[ $? -eq 0 ] && dd if=/dev/zero of=/dev/"$dev" count=100 > /dev/null 2>&1
	done
	echo -e 'd\n 1\n d\n 2\n d\n 3\n d\n n\n p\n 1\n \n +2G\n n\n p\n 2\n \n +256M\n n\n p\n 3\n \n \n 	t\n 1\n fd\n t\n 2\n fd\n t\n 3\n fd\n w\n'| fdisk /dev/"$1"
}
#===============================================================================
# Description	:
# input 		:	1()
# output 		:   1()
#===============================================================================
cp_partition()
{
	#echo "cp_partition($*)"
	sfdisk -d /dev/"$1" | sfdisk /dev/"$2"
}

#===============================================================================
# Description	:
# input 		:	1()
# output 		:   1()
#===============================================================================
RaidDeleteSuperBlock()
{
	echo "RaidDeleteSuperBlock($*)"
	for dev in ${1}1 ${1}2 ${1}3 ${1}4 ${1}
	do
		dd if=/dev/zero of=/dev/"$dev" count=100 > /dev/null 2>&1
	done
	#cat /proc/mdstat
}
#===============================================================================
# Description	:
# input 		:	1()
# output 		:   1()
#===============================================================================
RaidAddDevDefault()
{
	echo "RaidAddDevDefault($*)"

	DevToHostNumWithFile $1
	case "$HostNum" in
	host[0123])
		nice -5 mdadm /dev/md0 --add /dev/"$1"1
		nice -5 mdadm /dev/md1 --add /dev/"$1"2
		;;
	esac
	#mdadm /dev/md4 --add /dev/"$1"2
	#RaidWaitSync
}

#===============================================================================
# Description	:
# input 		:	1(sda, sdb, sdc, sdd)
# output 		:   1()
#===============================================================================
RaidAddDevUserMd2()
{
	echo "RaidAddDevUserMd2($*)"
	mdadm --zero-superblock /dev/"$1"3
	nice -5 mdadm /dev/md2 --add /dev/"$1"3
	#mdadm -R /dev/md[0123]
}

#===============================================================================
# Description	:
# input 		:	1()
# output 		:   1()
#===============================================================================
RaidAddDevUserMd3()
{
	echo "RaidAddDevUserMd3($*)"
	mdadm --zero-superblock /dev/"$1"3
	nice -5 mdadm /dev/md3 --add /dev/"$1"3
	#mdadm -R /dev/md[0123]
}

#===============================================================================
# Description	:
# input 		:	1()
# output 		:   1()
#===============================================================================
RaidWaitSync()
{
	while :
	do
		echo "wait for finish resync.."
		sleep 5
		grep faulty /proc/mdstat > /dev/null 2>&1
		sRetFaulty=$?
		if [ "$sRetFaulty" = 0 ] ; then
			echo "found faulty"
		fi
		grep "]  resync =" /proc/mdstat > /dev/null 2>&1
		sRet1=$?
		grep "]  recovery =" /proc/mdstat > /dev/null 2>&1
		sRet2=$?
		if [ "$sRet1" != 0 ] && [ "$sRet2" != 0 ] ; then
			return
		fi
	done
}
#===============================================================================
# Description	:
# input 		:	1(md node: /dev/md2, /dev/md3)
# input 		:	1(disk node : /dev/sda3 /dev/sdb3 ...)
# output 		:   1()
#===============================================================================
RaidErase()
{
	echo [`date`]"RaidErase($*)" >> ${SSS_LOG_SYS_NOTICE}
	MD="$1"
	DEVICES="$2 $3 $4 $5"
	/etc/init.d/samba stop
	umount -l $MD
	usleep 10000

	nice -n -10 mdadm -S $MD
	# erase super block
	if [ $? = 0 ]; then
		mdadm --zero-superblock --force $DEVICES
	fi
	sync
}
# $1: level
# $2: mddevice
# $3: device list

#===============================================================================
# Description	:
# input 		:	1(level: linear, 0, 1, 10, 5)
# input 		:	1(md node: /dev/md2, /dev/md3)
# input 		:	1(disk node : /dev/sda3 /dev/sdb3 ...)
# output 		:   1()
#===============================================================================
RaidCreate()
{
	LVL=$1
	MD="$2"
	DEVCNT=`expr $# - 3`
	MINSIZE=$3
	DEVICES="$4 $5 $6 $7"

	#echo "lists=$# DEVCNT=$DEVCNT md=[$2] DEVICES=[$DEVICES]"
	#RaidErase $MD $DEVICES
	[ "$LVL" = "linear" ] && {
		echo -e "y\n"| mdadm -CfR $MD -l $LVL -c 64 -n $DEVCNT $DEVICES
	} || {
		echo -e "y\n"| mdadm -CfR $MD -l $LVL -c 64 -n $DEVCNT -z $MINSIZE $DEVICES
	}
	if [ $? != 0 ]; then
		echo "create RAID $LVL on $MD fail."
		return 1
	fi

#	TMP=`echo $MD|sed -e "s/dev//"`
	if [ -w /sys/block/${MD#/dev/}/md/sync_speed_max ]; then
		if [ $LVL = 5 ]; then
			echo ${MD_SPEEDLIMIT_RAID5} >/sys/block/${MD#/dev/}/md/sync_speed_max
		else
			echo ${MD_SPEEDLIMIT_RAID1} >/sys/block/${MD#/dev/}/md/sync_speed_max
		fi
	fi
	sync
	return 0
}

VOL_DevToBay()
{
	for sDev in $*
	do
		sNode=${sDev##*/dev/}
		sNode=${sNode//[0-9]/""}
		sHostNum=`ls -al /sys/block/${sNode}/device |awk -F'/' '{print $(NF-2)}'`
		echo `BAY_HostToBayName ${sHostNum}`
	done
}

VOL_BayToDev()
{
	for sBay in $*
	do
		sHostNum=`BAY_BayToHostName ${sBay}`
		echo `find /sys/block/ -name device |xargs ls -l |grep "${sHostNum}/" |awk -F'/' '{print $4}'`
	done
}
#===============================================================================
# Description	:	BAY_IsThereHdd()
# input 		:	Bay1 Bay2 Bay3 Bay4
# output		:   0(yes) 1(no)
#===============================================================================
BAY_IsThereHdd()
{
	#echo "BAY_IsThereHdd($*)"
	sHostNum=`BAY_BayToHostName ${1}`
	BAY_IsThereHostNum ${sHostNum}
}
#===============================================================================
# Description	:	BAY_IsThereHostNum()
# input 		:	host0 host1 host2 host3
# output		:   0(yes) 1(no)
#===============================================================================
BAY_IsThereHostNum()
{
	#echo "BAY_IsThereHostname($*)"
	sNode=`find /sys/block/ -name device |xargs ls -l |grep ${1} |awk -F'/' '{print $4}'`
	if [ "$sNode" = "" ]; then return 1; fi
	return 0
}
#===============================================================================
# Description	:	BAY_HotAdded()
# input 		:	hostnum (host0,host1,host2,host3)
# input 		:	dev node (sda,adb,sdc,sdd)
# usage			:   BAY_HotAdded
#===============================================================================
BAY_BayToHostName()
{
	sTemp="$*"
	sTemp=${sTemp//Bay1/host0}
	sTemp=${sTemp//Bay2/host1}
	sTemp=${sTemp//Bay3/host2}
	sTemp=${sTemp//Bay4/host3}
	echo $sTemp
}
BAY_HostToBayName()
{
	sTemp="$*"
	sTemp=${sTemp//host0/Bay1}
	sTemp=${sTemp//host1/Bay2}
	sTemp=${sTemp//host2/Bay3}
	sTemp=${sTemp//host3/Bay4}
	echo $sTemp
}
# input: host[0123] output BAY[1234]
BAY_HostToDisplayBayName()
{
	sTemp="$*"
	if [ "$BAY_NAME_CONVERT" = "on" ]; then
		sTemp=${sTemp//host0/BAY4}
		sTemp=${sTemp//host1/BAY3}
		sTemp=${sTemp//host2/BAY2}
		sTemp=${sTemp//host3/BAY1}
	else
		sTemp=${sTemp//host0/BAY1}
		sTemp=${sTemp//host1/BAY2}
		sTemp=${sTemp//host2/BAY3}
		sTemp=${sTemp//host3/BAY4}
	fi
	echo $sTemp
}
# input: Bay[1234] output BAY[1234]
BAY_ToDisplayBayName()
{
	sTemp="$*"
	if [ "$BAY_NAME_CONVERT" = "on" ]; then
		sTemp=${sTemp//Bay1/BAY4}
		sTemp=${sTemp//Bay2/BAY3}
		sTemp=${sTemp//Bay3/BAY2}
		sTemp=${sTemp//Bay4/BAY1}
	else
		sTemp=${sTemp//Bay1/BAY1}
		sTemp=${sTemp//Bay2/BAY2}
		sTemp=${sTemp//Bay3/BAY3}
		sTemp=${sTemp//Bay4/BAY4}
	fi
	echo $sTemp
}
BAY_HotAdded()
{
	#echo "BAY_HotAdded($*)"
	echo [`date`]"BAY_HotAdded($*)" >> ${SSS_LOG_SYS_NOTICE}
	SSS_SetDiskFailLed $1 off
	SSS_SetBuzzerBayHotAdded
	
	sBayName=`BAY_HostToBayName $1`
	sBayNameR=`BAY_HostToDisplayBayName $1`
	SSS_SetEmailNotice bay add ${sBayNameR#Bay}
	MSG_Once "${sBayNameR} ${MSG[24]}"
	
#	RaidDeleteSuperBlock $2
#	VOL_CheckPartition $2
#	SSS_PartitionMake $2
	
	#Auto Add Sys and Swap Raid
#	RaidAddDevDefault $2

	#Auto Add User Raid
#	sVolConf=(`cat ${VOLCONF} |grep ${sBayName}`)
#	if [ $? = 0 ] && [ ! -z "${sVolConf[2]}" ]; then
#		sLevel=${sVolConf[2]#raid}
#		sLevel=${sLevel#RAID}
#	fi	
	
#	if [ "$sLevel" = "1" ] || [ "$sLevel" = "5"	] || [ "$sLevel" = "10" ]; then
#		sMdQuery=(`mdadm -Q /dev/${2}3 |grep mismatch`)
#		if [ $? = 0 ] && [ ! -z ${sMdQuery[8]} ]; then
#			if [ "${sVolConf[1]}" = "md2" ] ; then
#				RaidAddDevUserMd2 $2
#			elif [ "${sVolConf[1]}" = "md3" ] ; then
#				RaidAddDevUserMd3 $2
#			else
#				echo [`date`]"Error: BAY_HotAdded() unknown mdnode ${1}" >> ${SSS_LOG_SYS_NOTICE}
#			fi
#		fi
#	fi	
}

#===============================================================================
# Description	:	BAY_HotRemoved()
# input 		:	hostnum (host0,host1,host2,host3)
# usage			:   BAY_HotRemoved
#===============================================================================
BAY_HotRemoved()
{
	#echo "BAY_HotRemoved($*)"
	echo [`date`]"BAY_HotRemoved($*)" >> ${SSS_LOG_SYS_NOTICE}
	SSS_SetBuzzerBayHotRemoved
	sBayName=`BAY_HostToBayName $1`
	sBayNode=`cat $DIF_SCSI_LIST |grep $1 | cut -d' ' -f1`
	if [ -z "$sBayNode" ]; then return 1; fi 
	
	sVolConf=(`cat ${VOLCONF} |grep ${sBayName}`)
	sBayNameR=`BAY_HostToDisplayBayName $1`
	SSS_SetEmailNotice bay remov ${sBayNameR#Bay}
	MSG_Once $sBayNameR ${MSG[23]}	
	SSS_SetDiskFailLed $1 on
	
	# System Area/Swap Area
	mdadm -f /dev/md0 /dev/${sBayNode}1
	if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>EF1"; return 1; fi 
	mdadm -f /dev/md1 /dev/${sBayNode}2
	if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>EF2"; return 1; fi 
	sleep 1
	
	
	mdadm -r /dev/md0 /dev/${sBayNode}1
	mdadm -r /dev/md0 faulty
	if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>ER2"; return 1; fi 
	mdadm -r /dev/md1 /dev/${sBayNode}2
	mdadm -r /dev/md1 faulty
	if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>ER2"; return 1; fi 
	
	sLevel=${sVolConf[2]#raid}
	sLevel=${sLevel#RAID}
	echo "sLevel>>>>>>>>>>>>>>>>> : $sLevel"
	if [ "$sLevel" = "1" ] || [ "$sLevel" = "5"	] || [ "$sLevel" = "10" ]; then
		mdadm -f "/dev/"${sVolConf[1]} /dev/${sBayNode}3
		if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>EF3"; return 1; fi 
		sleep 1
		mdadm -r "/dev/"${sVolConf[1]} /dev/${sBayNode}3
		mdadm -r "/dev/"${sVolConf[1]} faulty
		if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>ER3"; return 1; fi 
	elif [ "${sLevel}" = "NONE" ]; then
		# no raid
		umount /mnt/fs/${sVolConf[0]}
		if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>EM-NONE"; return 1; fi 
		#delete vol.conf list
		VOL_ChangeConf ${sVolConf[0]}
	elif [ "${sLevel}" = "0" ] || [ "${sLevel}" = "linear" ]; then
		# raid0 /jbod
		umount /mnt/fs/${sVolConf[0]}
		if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>EM-R0_Linear"; return 1; fi 
		sleep 1
		mdadm -S /dev/${sVolConf[1]}
		if [ $? != 0 ]; then echo ">>>>>>>>>>>>>>>>>ES"; return 1; fi 
		#delete vol.conf list
		VOL_ChangeConf ${sVolConf[0]}
	fi
	SSS_GetVolListOrg
}
#===============================================================================
# Description	:	VOL_CheckMount()
# usage			:   VOL_CheckMount Vol1(default)/Vol2/Vol3/Vol4/node(sde,sdf,sdg..) 
#===============================================================================
VOL_CheckMount()
{
	if [ "$1" = "Vol1" ] || [ -z "$1" ]; then
		sVolMount=$SSS_VOL1
	elif [ "$1" = "Vol2" ]; then
		sVolMount=$SSS_VOL2
	elif [ "$1" = "Vol3" ]; then
		sVolMount=$SSS_VOL3
	elif [ "$1" = "Vol4" ]; then
		sVolMount=$SSS_VOL4
	else
		sVolMount=$1
	fi 
	
	mount |grep $sVolMount > /dev/null 2>&1
	if [ $? != 0 ]; then
		return 1
	else
		return 0
	fi
}
#===============================================================================
# Description	:	VOL_Remain()
# usage			:   VOL_Remain Vol1(default)/Vol2/Vol3/Vol4/node(sde,sdf,sdg..) 
#===============================================================================
VOL_Remain()
{
	if [ "$1" = "Vol1" ] || [ -z "$1" ]; then
		sVolMount=$SSS_VOL1
	elif [ "$1" = "Vol2" ]; then
		sVolMount=$SSS_VOL2
	elif [ "$1" = "Vol3" ]; then
		sVolMount=$SSS_VOL3
	elif [ "$1" = "Vol4" ]; then
		sVolMount=$SSS_VOL4
	else
		sVolMount=$1
	fi 
	
	dwByteSize=`df -B1 |grep $sVolMount |awk '{print $4}'` 
	[ -z "$dwByteSize" ] && dwByteSize=0;
	echo $dwByteSize
}
#===============================================================================
# Description	:	VOL_CheckRaidSys
# input 		:	1(md0, md1, md2, md3)
# output 		:   0: active DEV=ALL
#				:   /etc/sss_script/disk/raid_check
#===============================================================================
VOL_CheckRaidSysSwap()
{
	echo "VOL_CheckRaidSysSwap($*)"
	for sHostN in 0 1 2 3
	do
		sBayNode=`DevFromHostNumWithSystem "host${sHostN}"`
		if [ -z "$sBayNode" ]; then
			continue
		else
			sMdQuerySys=(`mdadm -Q /dev/${sBayNode}1 | grep detail`)
			sMdQuerySwp=(`mdadm -Q /dev/${sBayNode}2 | grep detail`)
			if [ $? = 0 ] && [ ${sMdQuerySys[6]} = "active" ] && [ ${sMdQuerySwp[6]} = "active" ]; then
				continue
			else
				mdadm -r /dev/md0 /dev/${sBayNode}1 > /dev/null 2>&1
				mdadm -r /dev/md1 /dev/${sBayNode}2 > /dev/null 2>&1
				
				VOL_CheckPartition $sBayNode
				RaidAddDevDefault $sBayNode
			fi
			
		fi
	done
}
#===============================================================================
# Description	:	VOL_CheckNode()
# usage			:   VOL_CheckNode
#===============================================================================
VOL_CheckNode()
{
	tar -xjvf /boot/sss_node.tar.bz2 -C / > /dev/null 2>&1
}
#===============================================================================
# Description	:	Control resync priority (+5)
# usage			:   VOL_RaidPriority
#===============================================================================
VOL_RaidPriority()
{
	#echo "VOL_RaidPriority($*)"
	#ps -w | grep '\[md' | grep -v grep | awk '{ print $1 }'| xargs renice 10
	ps -w | grep 'md[0-9]_resync' | grep -v grep | awk '{ print $1 }'| xargs renice 5 > /dev/null 2>&1
}
#===============================================================================
# Description	:	Check and change vol.conf
# input 		:	1(volname	: Vol1, Vol2, Vol3, Vol4)
# input 		:	1(volnode	: md2, md3, sda3, sdb3 ...)
# input 		:	1(level		: RAID0, RAID1, RAID5, RAID10, JBOD, NONE)
# input 		:	1(baycount	: 1 ~ 4)
# input 		:	1(bay		: Bay1, Bay2, Bay3, Bay4)
# usage			:   VOL_ChangeConf Vol1 md2 RAID5 4 Bay1 Bay2 Bay3 Bay4
#===============================================================================
VOL_ChangeConf()
{
	#echo "VOL_ChangeConf($*)"
	sed -i "/${1}/c ${*}" ${VOLCONF}
}
#===============================================================================
# Description	:	Edit vol.conf at (VOL_RaidAdd,(VOL_RaidRemove ?) ==> migration only?)
# 				:	Call when Raid devices(md's devices) modified
# input 		:	1(volnode	: md2, md3)
#===============================================================================
VOL_ConfEditRaidVol()
{
	#echo "VOL_ConfEditRaidVol($*)"
	sVolConfOld=(`cat ${VOLCONF} | grep $1`)
	sMdadmQuery=(`mdadm -Q /dev/$1`)
	sMdadmDev=(`mdadm -D /dev/$1 | grep '/dev/sd[a-z]3'| awk '{print $NF}'`)
	sMdadmBay=(`VOL_DevToBay ${sMdadmDev[*]}`)
	VOL_ChangeConf ${sVolConfOld[0]} $1 ${sMdadmQuery[2]} ${sMdadmQuery[3]} ${sMdadmBay[*]}
}
#===============================================================================
# Description	:	Mount Volume in vol.conf at Booting 
# input 		:	1(volnode	: md2, md3)
#===============================================================================
VOL_ConfMount()
{
	VOL_CheckNode
	#echo "VOL_ConfMount($*)"
	VOL_CheckConf
	
	sVol=(`cat ${VOLCONF} | grep '[ms]d' | cut -d' ' -f1,2,3,4,5`)
	bVolCnt=${#sVol[*]}

	bVcnt=0
	while [ "$bVcnt" -lt "$bVolCnt" ]; do
		#VOL_Mount volname /dev/volnode
		if [ "${sVol[$(($bVcnt+1))]%%[0-9]}" = "md" ]; then
			sVolNode=${sVol[$((${bVcnt} + 1))]}
		else
			# mount As Bay name
			sBayName=${sVol[$((${bVcnt} + 4))]}
			sVolNode=`VOL_BayToDev ${sBayName}`"3"
			# fixing volnode of no raid volume
			if [ "$sVolNode" != "${sVol[$(($bVcnt+1))]%%[0-9]}" ]; then
				VOL_ChangeConf ${sVol[$bVcnt]} $sVolNode NONE 1 ${sBayName}
			fi
		fi
		VOL_Mount ${sVol[$bVcnt]} "/dev/"${sVolNode}
		if [ $? != 0 ]; then
			echo [`date`]"Error: VOL_ConfMount($*)  VOL_Mount ${sVol[$bVcnt]} /dev/${sVolNode}" >> ${SSS_LOG_SYS_NOTICE}
		fi
		bVcnt=$((${bVcnt} + 5))
    done
    
    VOL_CheckNotMountedRaid
}
#===============================================================================
# Description	:	Remove Raid is not Mounted (Call this after VOL_ConfMount)
#				:	case 1: shutdown on formatting raid volume
#				:	case 2: vol.conf diff from system volume
# input 		:	1(volnode	: md2, md3)
#===============================================================================
VOL_CheckNotMountedRaid()
{
	#echo "VOL_CheckNotMountedRaid($*)"
	sMdNotMounted=""
	mount |grep md2 > /dev/null 2>&1
	[ $? = 0 ] || sMdNotMounted="md2";
	mount |grep md3 > /dev/null 2>&1
	[ $? = 0 ] || sMdNotMounted=${sMdNotMounted}" md3";
	for sRaidNode in ${sMdNotMounted}
	do
		#Stop Raid
		mdadm -S "/dev/"$sRaidNode > /dev/null  2>&1
	done
}
#===============================================================================
# Description	:	Default Raid Volume mount
# 				:	This is Temporary function until ES2 to make valid vol.conf
# usage			:   Don't Use
#===============================================================================
VOL_DefMount()
{
	#echo "VOL_DefMount($*)"
	VOL_Mount Vol1 /dev/md2
	ret1=$?
	VOL_Mount Vol2 /dev/md3
	ret2=$?
	
	# there is no user volume
	#if [ "$ret1" != 0 -a "$ret2" != 0 ]; then
	#	MSG_Once ${MSG[11]}
	#fi
}
#===============================================================================
# Description	:	Fix vol.conf as mount information
# usage			:   VOL_FixConfAsMount
#===============================================================================
VOL_FixConfAsMount()
{
	echo "VOL_FixConfAsMount($*)"
	
	# This is Temporary code until ES2 to make valid vol.conf
	VOL_DefMount
	
	sMount=(`mount | cut -d' ' -f1,3 | grep '/mnt/fs/Vol[1-4]'`)
	# Is there mounted volume?
	if [ $? = 0 ]; then
    	bVolCnt=${#sMount[*]}
    	bVcnt=0
    	while [ "$bVcnt" -lt "$bVolCnt" ]; do
    		if [ ${sMount[$bVcnt]//[0-9]/""} = "/dev/md" ]; then
    			# Is it Raid(md)?
    			echo "this is md volume"
    			#/dev/md2: 692.31GiB raid5 4 devices, 0 spares. Use mdadm --detail for more detail.
    			sMdadmQuery=(`mdadm -Q ${sMount[$bVcnt]}`)
    			#/dev/sda3 /dev/sdb3 /dev/sdc3 /dev/sdd3
    			sMdadmDev=(`mdadm -D ${sMount[$bVcnt]}| grep '/dev/sd[a-z]3'| awk '{print $NF}'`)
    			sMdadmBay=(`VOL_DevToBay ${sMdadmDev[*]}`)
    			VOL_ChangeConf ${sMount[$(($bVcnt+1))]##*fs/} ${sMount[$bVcnt]##*dev/} ${sMdadmQuery[2]} ${sMdadmQuery[3]} ${sMdadmBay[*]}
    		else
    			echo "this is not md volume"
    			VOL_ChangeConf ${sMount[$(($bVcnt+1))]##*fs/} ${sMount[$bVcnt]##*dev/} NONE 1 `VOL_DevToBay ${sMount[$bVcnt]}`
    		fi

    		bVcnt=$((${bVcnt} + 2))
    	done
	else
		# not mounted
		echo "there is no mounted volume"
	fi
}
#===============================================================================
# Description	:	Fix System and Swap Raid
# usage			:   VOL_FixConfAsMount
#===============================================================================
VOL_FixSysSwapRaid()
{
	echo "VOL_FixSysSwapRaid($*)"
	echo ToDo
}
#===============================================================================
# Description	:	Check vol.conf has normal volume info.
#				:	Call 1. sys update 2. boot
#				: 	vol.conf file made by enclosure disk, web volume create
#				:	when update f/w 
#				:	if there is vol.conf 	: don't touch  
#				:	if there isn't vol.conf : create vol.conf and fix as mount info.
# output		:   0. have volume info. 1: don't have volume info.
# usage			:   VOL_RaidPriority
#===============================================================================
VOL_CheckConf()
{
	echo "VOL_CheckConf($*)"
	# is there vol.conf
	if [ -f ${VOLCONF} ]; then
		sVolT=(`cat ${VOLCONF} | grep '[ms]d' | cut -d' ' -f1,2`)
		if [ "${#sVolT[*]}" -ge 1 ]; then
			return 0
		fi
	else
		# there is not vol.conf 
		# this is abnormal case
		echo Vol1 > ${VOLCONF}
		echo Vol2 >> ${VOLCONF}
		echo Vol3 >> ${VOLCONF}
		echo Vol4 >> ${VOLCONF}

		VOL_FixConfAsMount
		VOL_FixSysSwapRaid
		return 1
	fi
}
#===============================================================================
# Description	:	VOL_Mount()
# input 		:	1(volname	: Vol1, Vol2, Vol3, Vol4)
# input 		:	1(volnode	: /dev/md3, /dev/md3, /dev/sda3, /dev/sdb3 ...)
# usage			:   VOL_Mount $vol_name $vol_node
#===============================================================================
VOL_Mount()
{
	if [ ! -d "${SSS_VOL1}" ]; then
		mkdir -p ${SSS_VOL1}
	fi
	if [ ! -d "${SSS_VOL2}" ]; then
		mkdir -p ${SSS_VOL2}
	fi
	if [ ! -d "${SSS_VOL3}" ]; then
		mkdir -p ${SSS_VOL3}
	fi
	if [ ! -d "${SSS_VOL4}" ]; then
		mkdir -p ${SSS_VOL4}
	fi

	if [ "$1" = "Vol1" ]; then
		mount -t ext3 ${2} ${SSS_VOL1} -o noatime,data=writeback,usrquota,grpquota && tar -xjvf /boot/home.tar.bz2 -C / > /dev/null 2>&1
		if [ -d "/mnt/fs/Vol1/.webtmp" ]; then
			rm -rf /mnt/fs/Vol1/.webtmp
		fi
		mkdir -p /mnt/fs/Vol1/.webtmp
		chown nobody:nobody /mnt/fs/Vol1/.webtmp
		chmod 700 /mnt/fs/Vol1/.webtmp
	elif [ "$1" = "Vol2" ]; then
		mount -t ext3 ${2} ${SSS_VOL2} -o noatime,data=writeback,usrquota,grpquota 
	elif [ "$1" = "Vol3" ]; then
		mount -t ext3 ${2} ${SSS_VOL3} -o noatime,data=writeback,usrquota,grpquota 
	elif [ "$1" = "Vol4" ]; then
		mount -t ext3 ${2} ${SSS_VOL4} -o noatime,data=writeback,usrquota,grpquota 
	fi
}
#===============================================================================
# Description	:	VOL_CheckPartition()
# input 		:	1(disknode	: sda, sdb, sdc, sdd)
# output 		:   1()
# usage			:   VOL_CheckPartition sda
#===============================================================================
VOL_CheckPartition()
{
	PARTSIZE=5000000	# 250GB -> 5G
	PART1SIZE=1959898  	# 2GB
	PART2SIZE=257040	# 256M
	PART3SIZE=2000000	# 250GB HDD's user area -> 2G
	PARTMAX2T=1900000000    # for 2T HDD 
	PARTMAX4T=3800000000    # for 2T HDD 
	SWAP_FILE=/extraswap
	
	temp=`sfdisk -s /dev/${1}`
	if [ "${temp}" -lt "$PARTSIZE" ]; then
		#small size hdd than 250GB
		return 1
	fi
	for PARTMAX in $PARTMAX4T $PARTMAX2T                                              
	do                                                                                
		if [ $temp -gt $PARTMAX ]; then                                           
			case $PARTMAX in                                                  
				$PARTMAX4T)                                                       
					TSIZE=512                                                 
					THRESHOLD=700000                                          
				;;                                                  
				$PARTMAX2T)                                                       
					TSIZE=256                                                 
					THRESHOLD=500000                                        
				;;                                                                      
				esac                                                                    
				swap_total=`grep SwapTotal /proc/meminfo | awk '{print $2}'`   
				[ $swap_total -lt $THRESHOLD ] && {                                               
					[ -e $SWAP_FILE ] && {                                                  
						swapon -s | grep -q $SWAP_FILE                  
						[ $? -eq 0 ] && swapoff $SWAP_FILE              
						rm $SWAP_FILE                                          
					}                                                              
					available=`df | grep rootfs | awk '{print $4}'`   
					[ $available -gt $(($TSIZE*1024)) ] && {
						dd if=/dev/zero of=$SWAP_FILE bs=1M count=$TSIZE  
					} || {   
						echo [`date`]"Cannot setup swapfile: not enough space" >> ${SSS_LOG_SYS_NOTICE}
						return 2  
					}  
					mkswap $SWAP_FILE  
					swapon $SWAP_FILE 
					}  
			fi 
	done  
	temp=`sfdisk -s /dev/${1}1`
	if [ "${temp}" != "$PART1SIZE" ]; then
		SSS_PartitionMake ${1}
	fi
	temp=`sfdisk -s /dev/${1}2`
	if [ "${temp}" != "$PART2SIZE" ]; then
		SSS_PartitionMake ${1}
	fi
#	temp=`sfdisk -s /dev/${1}3`
#	if [ $? != 0 ]; then
#		SSS_PartitionMake ${1}
#	fi
	
	temp=`sfdisk -s /dev/${1}1`
	if [ "${temp}" != "$PART1SIZE" ]; then
		return 1
	fi
	temp=`sfdisk -s /dev/${1}2`
	if [ "${temp}" != "$PART2SIZE" ]; then
		return 1
	fi
	return 0
}
#===============================================================================
# Description	:	VOL_Create()
# input 		:	1(volname	: Vol1, Vol2, Vol3, Vol4)
# input 		:	1(volnode	: md2, md3, sda3, sdb3 ...)
# input 		:	1(level		: RAID0, RAID1, RAID5, RAID10, JBOD, NONE)
# input 		:	1(disknode	: sda, sdb, sdc, sdd)
# output 		:   1()
# usage			:   VOL_Create $vol_name $vol_node $vol_level $vol_disknode
#===============================================================================
VOL_Create()
{
	#echo "VolCreate($*)"
	echo [`date`]"VOL_Create($*)" >> ${SSS_LOG_SYS_NOTICE}
	VOLDEVCNT=`expr $# - 3`
	case "$3" in
	RAID0)
		VOLLEVEL=raid0
	;;
	RAID1)
		VOLLEVEL=raid1
	;;
	RAID5)
		VOLLEVEL=raid5
	;;
	RAID10)
		VOLLEVEL=raid10
	;;
	JBOD)
		VOLLEVEL=linear
	;;
	NONE)
		VOLLEVEL=none
	;;
	*)
		echo " Unknown Raid Level"
	;;
	esac

	VOLNAME=$1
	VOLNODE="/dev/${2}"
	VOLDISKNODE=""
	
	DISK1=""
	DISK2=""
	DISK3=""
	DISK4=""
	DISKLAST=""
	# check node
	sDiskNodes=($4 $5 $6 $7)
	sBays=(`VOL_DevToBay ${sDiskNodes[*]}`)
	sBaysCnt=${#sDiskNodes[*]}
	
	# check partition and partition
	for disk in $4 $5 $6 $7
	do
		VOL_CheckPartition $disk
		if [ $? != 0 ]; then
			echo [`date`]"Error: VOL_Create Partition [node:$disk]" >> ${SSS_LOG_SYS_NOTICE}
			return
		fi
	done

	if [ "$4" != "" ]; then
		DISK1=/dev/${4}3
	fi
	if [ "$5" != "" ]; then
		DISK2=/dev/${5}3
	fi
	if [ "$6" != "" ]; then
		DISK3=/dev/${6}3
	fi
	if [ "$7" != "" ]; then
		DISK4=/dev/${7}3
	fi

	for voldisk in $DISK4 $DISK3 $DISK2 $DISK1
	do
		if [ "$voldisk" != "" ]; then
			DISKLAST=$voldisk
			break
		fi
	done
	
	MINSIZE=10000000000
	for tmpDev in $DISK4 $DISK3 $DISK2 $DISK1
	do
		tmp=`cat /proc/partitions|grep ${tmpDev##*/}` && tmp=$((`echo $tmp |cut -d' ' -f3`-1024)) 
		[ $tmp -lt $MINSIZE ] && MINSIZE=$tmp
	done

	if [ "$VOLLEVEL" = "raid5" ]; then
		for voldisk in $DISK1 $DISK2 $DISK3 $DISK4
		do
			if [ "$voldisk" = "$DISKLAST" ]; then
				VOLDISKNODE="${VOLDISKNODE}missing"
				break
			else
				VOLDISKNODE="${VOLDISKNODE}${voldisk} "
			fi
		done
	elif [ "$VOLLEVEL" = "raid1" ]; then
		for voldisk in $DISK1 $DISK2 $DISK3 $DISK4
		do
			if [ "$voldisk" = "$DISK1" ]; then
				VOLDISKNODE="${DISK1} "
			else
				VOLDISKNODE="${VOLDISKNODE}missing "
			fi
		done
	elif [ "$VOLLEVEL" = "raid10" ]; then
		VOLDISKNODE="$DISK1 missing $DISK3 missing"
	else
		VOLDISKNODE="$DISK1 $DISK2 $DISK3 $DISK4"
	fi

	echo "$VOLNAME $VOLNODE $VOLLEVEL $VOLDISKCNT $VOLDISKNODE" > /dev/ttyS0
	echo [`date`]"$VOLNAME $VOLNODE $VOLLEVEL $VOLDISKCNT $VOLDISKNODE" >> ${SSS_LOG_SYS_NOTICE}
	
	if [ "$VOLLEVEL" != "none" ]; then
		# This is Raid
		RaidCreate ${VOLLEVEL} ${VOLNODE} ${MINSIZE} ${VOLDISKNODE} 
	fi
	
	# format
	# refresh vol_list_org
	SSS_GetVolListOrg ${VOLNAME} $2 ${VOLLEVEL} ${VOLDEVCNT} $4 $5 $6 $7

	MSG_Add ${VOLNAME} ${MSG[4]}
	nice -5 mkfs.ext3 -j -O sparse_super -O dir_index $VOLNODE	
	MSG_Remove ${VOLNAME} ${MSG[4]}
	# mount VOL
	VOL_Mount ${VOLNAME} ${VOLNODE}
	if [ $? != 0 ]; then
		echo [`date`]"Error: VOL_Mount ${VOLNAME} ${VOLNODE}" >> ${SSS_LOG_SYS_NOTICE}
	else
		if [ "$VOLNAME" = "Vol1" ]; then
			SSS_SetStorageCapa
		fi
		tune2fs -m 0 ${VOLNODE}
		VOL_ChangeConf $1 $2 $3 ${sBaysCnt} ${sBays[*]}	
		
		# samba restart
		killall smbd
		killall nmbd
		/usr/local/samba/sbin/smbd -D
		/usr/local/samba/sbin/nmbd -D
		MSG_Once "${VOLNAME} ${MSG[5]}"
		
		# raid resync
		if [ $VOLLEVEL = "raid5" ]; then
			nice -5 mdadm -a ${VOLNODE} ${DISKLAST}	
		elif [ $VOLLEVEL = "raid1" ]; then
			nice -5 mdadm -a ${VOLNODE} $DISK2 $DISK3 $DISK4
		elif [ $VOLLEVEL = "raid10" ]; then
			nice -5 mdadm -a ${VOLNODE} ${DISK2} ${DISK4}
		fi
	
		sleep 1
		VOL_RaidPriority
		# refresh vol_list_org
		SSS_GetVolListOrg
		/etc/sss_script/share/query_share.sh
		[ "$VOLNAME" = "Vol1" ] && /usr/local/apache/bin/apachectl graceful &
	fi
        [ -e /extraswap ] && {                                                                            
                swapoff /extraswap                                                                      
                rm -f /extraswap                                                                         
        }   
}
#===============================================================================
# Description	:	VOL_Delete()
# input 		:	1(volname	: Vol1, Vol2, Vol3, Vol4)
# input 		:	1(volnode	: md2, md3, sda3, sdb3 ...)
# input 		:	1(disknode	: sda, sdb, sdc, sdd)
# output 		:   1()
# usage			:   VOL_Delete $vol_name $vol_node $vol_level $vol_disknode
#===============================================================================
VOL_Delete()
{
	#echo "VOL_Delete($*)"
	echo [`date`]"VOL_Delete($*)" >> ${SSS_LOG_SYS_NOTICE}
	
	# samba stop
	killall smbd
	killall nmbd

	VOLNAME=$1
	VOLNODE=/dev/$2
	VOLLEVEL=$3
	
	DISK1=""
	DISK2=""
	DISK3=""
	DISK4=""
	
	if [ "$4" != "" ]; then
		DISK1="/dev/${4}3"
	fi
	if [ "$5" != "" ]; then
		DISK2="/dev/${5}3"
	fi
	if [ "$6" != "" ]; then
		DISK3="/dev/${6}3"
	fi
	if [ "$7" != "" ]; then
		DISK4="/dev/${7}3"
	fi
	VOLDISKNODE="$DISK1 $DISK2 $DISK3 $DISK4"
	
	
	# umount VOL1
	umount -l ${VOLNODE}
	if [ $? != 0 ]; then
		echo [`date`]"Error: umount -l ${VOLNODE}" >> ${SSS_LOG_SYS_NOTICE}
	fi
	
	# kill resize2fs
	ps -w | grep resize2fs | grep $VOLNODE
	if [ $? -eq 0 ]; then
		killall resize2fs
	fi
	# kill formatting
	ps -w| grep mkfs.ext3 | grep $VOLNODE
	if [ $? -eq 0 ]; then
		killall mkfs.ext3
	fi

	BayArray=(`cat $VOLCONF|grep $1|cut -d' ' -f5,6,7,8`)        
	
	# refresh vol_list_org
	sed /$VOLNAME/d /etc/sss_script/disk/vol_list_org > /tmp/.ttt
	mv /tmp/.ttt /etc/sss_script/disk/vol_list_org
	VOL_ChangeConf $1
	sleep 2
	
	if [ ${VOLLEVEL} != "NONE" -o ${VOLLEVEL} != "none" ]; then
		if [ ${2%%[0-9]} = "md" ]; then
			vdRetry=10
			cat /proc/mdstat |grep $2		
	    	while [ $? -eq 0 ]
			do
				RaidErase ${VOLNODE} ${VOLDISKNODE}
				cat /proc/mdstat |grep $2
				vdRetry=$(($vdRetry - 1))
				[ "$vdRetry" = 0 ] && break;
			done
		fi
	fi
	
        for i in 0 1 2 3                                                        
        do                                                               
                echo ${BayArray[$i]}                                       
                tmp_bay=${BayArray[$i]}                              
                echo $tmp_bay                                                   
                if [ -z $tmp_bay ]                                                 
                then                                                            
                        continue;                                          
                else                                         
                        Host="host"$((${tmp_bay#*y}-1))      
                        echo $Host                                                 
                        SSS_SetDiskFailLed $Host off   
                fi                                     
        done             

	# samba start
	/usr/local/samba/sbin/smbd -D
	/usr/local/samba/sbin/nmbd -D
	MSG_Remove "$1"
	MSG_Once "$1 deleting"
	sleep 2
	MSG_Once "$1 deleted"
}
#===============================================================================
# Description	:	VOL_RaidAdd()
# input 		:	1(volnode	: md2, md3)
# input 		:	1(disknode	: sda, sdb, sdc, sdd)
# output 		:   1()
# usage			:   VOL_RaidAdd $volnode $disknode
#===============================================================================
VOL_RaidAdd()
{
	#echo "VOL_RaidAdd($*)"
	echo [`date`]"VOL_RaidAdd($*)" >> ${SSS_LOG_SYS_NOTICE}

	sBayName=`VOL_DevToBay $2`
	sBayNameR=`BAY_ToDisplayBayName ${sBayName}`
	MSG_Once "${sBayNameR} ${MSG[12]}"
	# disk led off
	DevToHostNumWithFile $2
	SSS_SetDiskFailLed $HostNum off
	
	#
	#RaidDeleteSuperBlock $2
	#VOL_CheckPartition $2
	#new partition force
	SSS_PartitionMake $2
	
	RaidAddDevDefault $2

	#Raid Add Dev to User md
	if [ "$1" = "md2" ] ; then
		RaidAddDevUserMd2 $2
	elif [ "$1" = "md3" ] ; then
		RaidAddDevUserMd3 $2
	else
		echo [`date`]"Error: VOL_RaidAdd() unknown mdnode ${1}" >> ${SSS_LOG_SYS_NOTICE}
	fi
	
	
	#VOL_ConfEditRaidVol $1
	#mdadm -D /dev/md[0123]
	
	sleep 1
	VOL_RaidPriority
	# refresh vol_list_org
	sleep 5
	SSS_GetVolListOrg

}
#===============================================================================
# Description	:	VOL_RaidRemove()
# input 		:	1(volnode	: md2, md3)
# input 		:	1(disknode	: sda, sdb, sdc, sdd)
# output 		:   1()
# usage			:   VOL_RaidRemove $volnode $disknode
#===============================================================================
VOL_RaidRemove()
{
	#echo "VOL_RaidRemove($*)"
	echo [`date`]"VOL_RaidRemove($*)" >> ${SSS_LOG_SYS_NOTICE}

	DevToHostNumWithFile $2
	SSS_SetDiskFailLed $HostNum on

	# System Area
	mdadm -f /dev/md0 /dev/${2}1
	# Swap Area
	mdadm -f /dev/md1 /dev/${2}2
	# User Area
	mdadm -f /dev/${1} /dev/${2}3
	
	sleep 1
	VOL_CheckNode
	
	mdadm -r /dev/md0 /dev/${2}1
	mdadm -r /dev/md1 /dev/${2}2
	mdadm -r /dev/${1} /dev/${2}3
	#mdadm -D /dev/md[0123]
	
	#VOL_ConfEditRaidVol $1
	# refresh vol_list_org
	SSS_GetVolListOrg
	sBayName=`VOL_DevToBay $2`
	sBayNameR=`BAY_ToDisplayBayName ${sBayName}`
	MSG_Once "${sBayNameR} ${MSG[23]}"
}
#===============================================================================
# Description	:	VOL_RaidExpand()
# input 		:	1(volname	: Vol1, Vol2, Vol3, Vol4)
# input 		:	1(volnode	: md2, md3)
# output 		:   1()
# usage			:   VOL_RaidExpand $volname $volnode
#===============================================================================
VOL_RaidExpand()
{
	PARTMAX=1900000000
	SWAP_FILE=/extraswap
	TSIZE=512

	#echo "VOL_RaidExpand($*)"
	echo [`date`]"VOL_RaidExpand($*)" >> ${SSS_LOG_SYS_NOTICE}
	
	MSG_Add ${1} ${MSG[17]}
	cd /

	tmp_flag=1
	tmp_slaves=$(ls /sys/block/$2/slaves/)
	for t_slave in $tmp_slaves
	do
		[ $(grep $t_slave /proc/partitions | awk '{print $3}') -gt $PARTMAX ] && {
			tmp_flag=0
		}
	done

	if [ $tmp_flag -eq 0 ] 
	then
		available=$(df | grep rootfs | awk '{print $4}')
		[ $available -gt $(($TSIZE*1024)) ] && {
			dd if=/dev/zero of=$SWAP_FILE bs=1M count=$TSIZE
		} || {
			echo [`date`]"Cannot setup swapfile: not enough space" >> ${SSS_LOG_SYS_NOTICE}
			return 2
		} 
		mkswap $SWAP_FILE
		swapon $SWAP_FILE
	fi

#	. /etc/init.d/services stop
	#?
#	fuser -km /mnt/fs/$1
#	umount -l /dev/$2
	
	mdadm --grow /dev/$2 --size=max
#	e2fsck -y /dev/$2 &&
	RAIDLevel=`cat /sys/block/${2}/md/level`
	RaidWaitLCD expand 0 $2 $RAIDLevel 
	resize2fs /dev/$2
	
	[ -e $SWAP_FILE ] && { 
		swapoff $SWAP_FILE
		rm -f $SWAP_FILE
	}
	
	#resize2fs /dev/md2 &
#	This usage causes mdadm to attempt to reconfigure a running array.
#	This is only possibly if the kernel being used supports a particular
#	reconfiguration.  This version only supports changing the number of
#	devices in a RAID1, and changing the active size of all devices in
#	a RAID1/4/5/6.y

#	Note the size of the last (raid-5 member) partition in blocks.
#	Subtract 128 from this size. (This is required for some superblock information for the RAID-5).
#	Now we can issue the command:
#	mdadm --grow --size <our_calc_blocks> /dev/md2

	# refresh vol_list_org
	SSS_GetVolListOrg
	MSG_Remove ${1} ${MSG[17]}
	MSG_Once "${1} ${MSG[19]}"
	return 0
}
#===============================================================================
# Description	:	VOL_RaidMigration()
# input 		:	1()
# output 		:   1()
#===============================================================================
VOL_RaidMigration()
{
	#echo "VOL_RaidExpand($*)"
	echo [`date`]"VOL_RaidMigration($*)" >> ${SSS_LOG_SYS_NOTICE}
}
#================================
# Display tools for es Volume page
#===============================

#====== vol_list generation 
# 1. name
# 2. node
# 3. raid state
# 4. size_total
# 5. size_used
# 6. raid level
# 7. mount state
# 8. bay number
# 9. 1st_bayname:state
#10. 2nd_bayname:state
#11. 3rd_bayname:state
#12. 4th_bayname:state  

ORG_VOL="/etc/sss_script/disk/vol_list_org"
LST_VOL="/etc/sss_script/disk/vol_list"
LST_BAY="/etc/sss_script/disk/bay_list"  

AwkKJC()
{
	shift $1
	nice -n -10 echo $1
}
Get_BayName()
{
	tmp=$1
	tmpB=${tmp%3}
	tmpA=`nice -n -10 ls /sys/block/$tmpB/device -l`
	tmpB=${tmpA##*host}
	tmpA=${tmpB%%/*}
	nice -n -10 echo "Bay"$(($tmpA+1)) 
}
Get_VolName()
{ 
	grep -q Vol$1 $2
	if [ $? != 0 ]
	then
		nice -n -10 echo "none"
	else
		nice -n -10 echo "Vol"$1
	fi 
}
Get_VolNameOrg()
{ 
	grep -q /mnt/fs/Vol$1 $2
	if [ $? != 0 ]
	then
		nice -n -10 echo "none"
	else
		nice -n -10 echo "Vol"$1
	fi 
}
Get_VolNode(){
	tmp=`nice -n -10 grep /mnt/fs/Vol$1 /proc/mounts`
	tmpA=`AwkKJC 1 $tmp`
	tmpNodeMnt=${tmpA##*/}
	tmp=`nice -n -10 grep /mnt/fs/Vol$1 $ORG_VOL`
	tmpNodeOrg=`AwkKJC 2 $tmp`
	if [ -z $tmpNodeMnt ]
	then
		volMntStat="off"
		nice -n -10 echo $tmpNodeOrg" "$volMntStat	# return volNode from $ORG_VOL
		# to do : if md?
			# YES : if mdstat? => raid construction check routine
				# Yes -> next
				# No -> HOWTO?
			# No : next
		# to do : if format? 
			# YES : next
			# NO : formatting & system dir making
		# to do : mount routine
		# to do : if mount?
			# YES : return
			# No : HOWTO?
	else 
		if [ $tmpNodeMnt = $tmpNodeOrg ]
		then
			volMntStat="on"
			volNodeStat="on"
			nice -n -10 echo $tmpNodeMnt" "$volMntStat
		else
			volMntStat="on"
			volNodeStat="off"
			# to do : fix process
			nice -n -10 echo $tmpNodeMnt" "$volMntStat	 
		fi
	fi
}
Get_RaidLevel()
{
	case $1 in
	s)
		nice -n -10 echo "none"
	;;
	m)
		nice -n -10 cat /sys/block/$2/md/level
	;;
	esac
}
Get_NumRaidDev()
{
	case $1 in
	s)
		nice -n -10 echo "1"
	;;
	m)
		tmp=`nice -n -10 cat /sys/block/$2/md/raid_disks`
		AwkKJC 1 $tmp
	;;
	esac
}
Get_RaidInfo()
{
	case $1 in
	s) 
		volState="none"
		tmp=`Get_BayName $2`
		volBays=$tmp":active"
	;;
	m)
		raid_disks_occ=`ls /sys/block/$2/md/|grep -c dev-` 
		if [ "$3" != "linear" -a "$3" != "raid0" ] 
		then
			sync_action=`nice -n -10 cat /sys/block/$2/md/sync_action`
			sync_completed=`cat /sys/block/$2/md/sync_completed`
			tmpA=`AwkKJC 1 $sync_completed`
			tmpB=`AwkKJC 3 $sync_completed`
			sync_ratio=$(($((tmpA*100))/$tmpB))
		fi 
		slaves=`nice -n -10 ls /sys/block/$2/slaves/`
		k=0
		volState=""
		volBays=""
		tmpFflag=0 
		while [ $k -lt $4 ]
		do 
			j=$(($k+1))
			tmp=`AwkKJC $j $slaves`
			if [ -z $tmp ]
			then 
				volBays=$volBays"removed "
				tmpFflag=$(($tmpFflag+1))				
			else
				slave=`Get_BayName $tmp` 
				tmpState=`nice -n -10 cat /sys/block/$2/md/dev-$tmp/state`
				if [ $tmpState = "in_sync" ]
				then
					slave_stat="active"
					volBays=$volBays$slave":"$slave_stat" "
				elif [ $tmpState = "spare" ]
				then
					case $sync_action in
					"recover")
						slave_stat="synching"
					;;
					*)
						slave_stat="spare"
						tmpFflag=$(($tmpFflag+1))	
					;;
					esac 
					volBays=$volBays$slave":"$slave_stat" "
				elif [ $tmpState = "faulty" ]
				then
					slave_stat=$tmpState
					tmpFflag=$(($tmpFflag+1))
					volBays=$volBays$slave":"$slave_stat" "
				else
					slave_stat="wrong"
					volBays=$volBays"removed "
					tmpFflag=$(($tmpFflag+1))
				fi 
			fi
			k=$((k+1))
		done 
		
		case $3 in
		linear|raid0)
			if [ $tmpFflag != 0 ]
			then
				volState="destroyed"
			else
#				ps -w|grep resize2fs|grep $2
#				case $? in
#				0)
#					volState="resizing"
#				;;
#				1)
					volState="active"
#				;;
#				esac
			fi
			
		;;		
		raid1|raid10)
			if [ $sync_action != "idle" ]
			then
				volState="synching_"$sync_ratio
			elif [ $tmpFflag != 0 ]
			then
				volState="degraded"
			elif [ $raid_disks_occ -lt $4 ]
			then
				volState="degraded"
			else
#				ps -w|grep resize2fs|grep $2
#				case $? in
#				0)
#					volState="resizing"
#				;;
#				1)
					volState="active"
#				;;
#				esac
			fi
		;;	
		raid5)
			if [ $sync_action != "idle" ]
			then
				volState="synching_"$sync_ratio
			elif [ $tmpFflag -gt 1 ]
			then
				volState="destroyed"
			elif [ $tmpFflag -eq 1 ]
			then
				volState="degraded"
			else
#				ps -w|grep resize2fs|grep $2
#				case $? in
#				0)
#					volState="resizing"
#				;;
#				1)
					volState="active"
#				;;
#				esac
			fi
		;;
		esac
	;;
	esac
	nice -n -10 echo $volState" "$volBays
}
Get_Bays()
{
	nice -n -10 echo $2" "$3" "$4" "$5
}
SSS_GetVolListOrg()
{  	
  TEMP_ORG_VOL=/tmp/.tmp_vol_list_org

	if [ -z $1 ]
	then
		cat /dev/null > $TEMP_ORG_VOL
		for i in 1 2 3 4
		do
			unset VolInfo
			declare -a VolInfo
			volName=`Get_VolNameOrg $i /proc/mounts` 
			if [ $volName = "none" ]
			then   
				continue
			else 
				VolInfo[0]=$volName 
				volNode=`grep /mnt/fs/Vol$i /proc/mounts` 
				tmp=`AwkKJC 1 $volNode`
				VolInfo[1]=${tmp##*/}
				tmp=`df -B1 /dev/${VolInfo[1]}| grep /mnt/fs/Vol$i`
				VolInfo[3]=`AwkKJC 2 $tmp`
				VolInfo[4]=`AwkKJC 3 $tmp`
				tmp=${VolInfo[1]}
				nodeInit=${tmp%%d*}
				VolInfo[5]=`Get_RaidLevel $nodeInit ${VolInfo[1]}`
				VolInfo[6]="on"
				VolInfo[7]=`Get_NumRaidDev $nodeInit ${VolInfo[1]}` 
				tmpInfo=`Get_RaidInfo $nodeInit ${VolInfo[1]} ${VolInfo[5]} ${VolInfo[7]}` 
				VolInfo[2]=`AwkKJC 1 $tmpInfo`
				VolInfo[8]=`Get_Bays $tmpInfo`
				nice -n -10 echo ${VolInfo[*]} >> $TEMP_ORG_VOL
			fi
		done
	else 
		for i in 1 2 3 4
		do
			tmpVol="Vol"$i
			mtmpVol="mVol"$i
			case $1 in 
			$tmpVol)
				cnt=1 
				ArrEle=""
				tmpEle=$5" "$6" "$7" "$8 
				while [ $cnt -le $4 ]
				do	  
					tNode=`AwkKJC $cnt $tmpEle` 
					tBay=`Get_BayName $tNode`
					ArrEle=${ArrEle}$tBay":formatting "
					cnt=$(($cnt+1))
				done
				nice -n -10 sed /$tmpVol/d $ORG_VOL > $TEMP_ORG_VOL
				nice -n -10 mv $TEMP_ORG_VOL $ORG_VOL
				nice -n -10 echo $1" "$2" formatting - - "$3" off "$4" "$ArrEle >> $ORG_VOL 
			;; 
			$mtmpVol)
				cnt=1 
				ArrEle=""
				tmpEle=$5" "$6" "$7" "$8 
				while [ $cnt -le $4 ]
				do	  
					tNode=`AwkKJC $cnt $tmpEle` 
					tBay=`Get_BayName $tNode`
					ArrEle=${ArrEle}$tBay":migrating "
					cnt=$(($cnt+1))
				done
				nice -n -10 sed /$tmpVol/d $ORG_VOL > $TEMP_ORG_VOL
				nice -n -10 mv $TEMP_ORG_VOL $ORG_VOL
				nice -n -10 echo $tmpVol" "$2" migrating - - "$3" on "$4" "$ArrEle >> $ORG_VOL 				
			;; 
			*) 
				continue 
			;;
			esac
		done
	fi		
	nice -n -10 sort $ORG_VOL > $TEMP_ORG_VOL
	nice -n -10 mv $TEMP_ORG_VOL $ORG_VOL 
}


SSS_GetVolList(){  
	#Initialize file 
	if [ ! -f "$ORG_VOL" ]; then
		nice -n -10 /etc/sss_script/disk/vollistorg.sh
	fi
	cat /dev/null > $LST_VOL
	
	for i in 1 2 3 4
	do
		volName=`Get_VolName $i $ORG_VOL` 
		if [ $volName = "none" ]
		then   
			continue
		else
			unset VolInfo
			declare -a VolInfo
			VolInfo[0]=$volName
			tmp=`grep ${VolInfo[0]} $ORG_VOL`
			tmpStatus=`AwkKJC 3 $tmp`
			volNode=`AwkKJC 2 $tmp`
			if [ $tmpStatus = "formatting" ] 
			then
				ps -w|grep mkfs|grep $volNode
				if [ $? != 0 ]
				then
					tmpInfo=`Get_VolNode $i`
					VolInfo[1]=`AwkKJC 1 $tmpInfo`
					VolInfo[6]=`AwkKJC 2 $tmpInfo`
					tmp=`df -B1 /dev/${VolInfo[1]}| grep /mnt/fs/Vol$i`
					VolInfo[3]=`AwkKJC 2 $tmp`
					VolInfo[4]=`AwkKJC 3 $tmp`
					tmp=${VolInfo[1]}
					nodeInit=${tmp%%d*}
					case $nodeInit in
					"s"|"m")
						VolInfo[5]=`Get_RaidLevel $nodeInit ${VolInfo[1]}`
						VolInfo[7]=`Get_NumRaidDev $nodeInit ${VolInfo[1]}` 
						tmpInfo=`Get_RaidInfo $nodeInit ${VolInfo[1]} ${VolInfo[5]} ${VolInfo[7]}` 
						VolInfo[2]=`AwkKJC 1 $tmpInfo`
						ps -w|grep resize2fs|grep ${VolInfo[1]}
						if [ $? = 0 ]
						then
							VolInfo[2]="resizing"
						fi
						VolInfo[8]=`Get_Bays $tmpInfo`
						echo ${VolInfo[*]} >> $LST_VOL
					;;	
					*)
						mount /dev/$volNode /mnt/fs/$volName
						if [ $? !=0 ]
						then
							mdadm -S /dev/$volNode
						fi
					;;
					esac
				else
					nice -n -10 echo $tmp >> $LST_VOL
				fi
			elif [ $tmpStatus = "migrating" ]
			then
				tmpMgrStat=`nice -n -10 cat /sys/block/$volNode/md/sync_action`
				tmpMgrLevel=`nice -n -10 cat /sys/block/$volNode/md/level`
				if [ -z $tmpMgrStat ]
				then
					case $tmpMgrLevel in
					"linear")
						tmpInfo=`Get_VolNode $i`
						VolInfo[1]=`AwkKJC 1 $tmpInfo`
						VolInfo[6]=`AwkKJC 2 $tmpInfo`
						tmp=`df -B1 /dev/${VolInfo[1]}| grep /mnt/fs/Vol$i`
						VolInfo[3]=`AwkKJC 2 $tmp`
						VolInfo[4]=`AwkKJC 3 $tmp`
						tmp=${VolInfo[1]}
						nodeInit=${tmp%%d*}
						VolInfo[5]=`Get_RaidLevel $nodeInit ${VolInfo[1]}`
						VolInfo[7]=`Get_NumRaidDev $nodeInit ${VolInfo[1]}` 
						tmpInfo=`Get_RaidInfo $nodeInit ${VolInfo[1]} ${VolInfo[5]} ${VolInfo[7]}` 
						VolInfo[2]=`AwkKJC 1 $tmpInfo`
						ps -w|grep resize2fs|grep ${VolInfo[1]}
						if [ $? = 0 ]
						then
							VolInfo[2]="resizing"
						fi
						VolInfo[8]=`Get_Bays $tmpInfo`
						nice -n -10 echo ${VolInfo[*]} >> $LST_VOL
					;;
					*)
						continue
					;;
					esac
				elif [ $tmpMgrStat = "idle" ]
				then
					tmpInfo=`Get_VolNode $i`
					VolInfo[1]=`AwkKJC 1 $tmpInfo`
					VolInfo[6]=`AwkKJC 2 $tmpInfo`
					tmp=`df -B1 /dev/${VolInfo[1]}| grep /mnt/fs/Vol$i`
					VolInfo[3]=`AwkKJC 2 $tmp`
					VolInfo[4]=`AwkKJC 3 $tmp`
					tmp=${VolInfo[1]}
					nodeInit=${tmp%%d*}
					VolInfo[5]=`Get_RaidLevel $nodeInit ${VolInfo[1]}`
					VolInfo[7]=`Get_NumRaidDev $nodeInit ${VolInfo[1]}` 
					tmpInfo=`Get_RaidInfo $nodeInit ${VolInfo[1]} ${VolInfo[5]} ${VolInfo[7]}` 
					VolInfo[2]=`AwkKJC 1 $tmpInfo`
					ps -w|grep resize2fs|grep ${VolInfo[1]}
					if [ $? = 0 ]
					then
						VolInfo[2]="resizing"
					fi
					VolInfo[8]=`Get_Bays $tmpInfo`
					nice -n -10 echo ${VolInfo[*]} >> $LST_VOL
				else
#					nice -n -10 echo $tmp >> $LST_VOL
					case $tmpMgrLevel in
					raid1)
						tmpComplete=(`cat /sys/block/$volNode/md/sync_completed |cut -d' ' -f1,2,3`)
						tmpRatio=$((${tmpComplete[0]}*100/${tmpComplete[2]}))
						nice -n -10 echo $tmp | sed 's:migrating:migrating_'$tmpRatio':' >> $LST_VOL
					;;
					raid5)
						tmpComplete=(`cat /sys/block/$volNode/md/sync_completed |cut -d' ' -f1,2,3`)
						if [ $tmpMgrStat = 'recover' ]
						then
						tmpRatio=$(((${tmpComplete[0]}*300/${tmpComplete[2]}+5)/10))
						else
							tmpRaid_disks=(`cat /sys/block/$volNode/md/raid_disks |cut -d' ' -f1,2`)
							case ${tmpRaid_disks[1]} in
							"(2)")
								tmpRatio=$(((305+${tmpComplete[0]}*700/${tmpComplete[2]})/10))
							;;
							"(3)")
							tmpRatio=$(((${tmpComplete[0]}*1000/${tmpComplete[2]}+5)/10))
							;;
							esac
						fi
						nice -n -10 echo $tmp | sed 's:migrating:migrating_'$tmpRatio':' >> $LST_VOL
					;;
					*)
						nice -n -10 echo $tmp >> $LST_VOL
					;;
					esac
				fi
			else  
				tmpInfo=`Get_VolNode $i`
				VolInfo[1]=`AwkKJC 1 $tmpInfo`
				VolInfo[6]=`AwkKJC 2 $tmpInfo`
				tmp=`df -B1 /dev/${VolInfo[1]}| grep /mnt/fs/Vol$i`
				VolInfo[3]=`AwkKJC 2 $tmp`
				VolInfo[4]=`AwkKJC 3 $tmp`
				tmp=${VolInfo[1]}
				nodeInit=${tmp%%d*}
				VolInfo[5]=`Get_RaidLevel $nodeInit ${VolInfo[1]}`
				VolInfo[7]=`Get_NumRaidDev $nodeInit ${VolInfo[1]}` 
				tmpInfo=`Get_RaidInfo $nodeInit ${VolInfo[1]} ${VolInfo[5]} ${VolInfo[7]}` 
				VolInfo[2]=`AwkKJC 1 $tmpInfo`
					ps -w|grep resize2fs|grep ${VolInfo[1]}
					if [ $? = 0 ]
					then
						VolInfo[2]="resizing"
					fi
					VolInfo[8]=`Get_Bays $tmpInfo`
				nice -n -10 echo ${VolInfo[*]} >> $LST_VOL
			fi
		fi
	done
}
SSS_GetBayList(){ 
	nice -n -10 cat /dev/null> $LST_BAY
	unset BayInfo
	declare -a BayInfo
	for i in 0 1 2 3
	do
		BayInfo[0]="Bay"$(($i+1))
		tmpP=`nice -n -10 ls /sys/devices/pci0000:01/0000:01:07.0/host$i/target$i:0:0/$i:0:0:0/block* -l`
		tmpNode=${tmpP##*/}
		if [ -z $tmpNode ]
		then
			BayInfo[1]="none"
			BayInfo[2]="none"
			BayInfo[3]=0
			BayInfo[4]=""
			BayInfo[5]=""
		else
			BayInfo[1]=$tmpNode
			nice -n -10 grep -q $tmpNode /proc/mounts
			if [ $? = 0 ]
			then				
				BayInfo[2]="active"
			else
				ps -w|grep mkfs|grep -v grep
				if [ $? -eq 0 ]
				then
					BayInfo[2]="formatting"
				else		
					tmpHolder=`nice -n -10 ls /sys/block/$tmpNode/${tmpNode}3/holders`
					if [ -z $tmpHolder ]
					then
						BayInfo[2]="free"
					else
						tmpState=`nice -n -10 cat /sys/block/$tmpHolder/md/dev-${tmpNode}3/state`
						ps -w|grep mkfs|grep $tmpNode
						if [ $? -eq 0 ]
						then
							BayInfo[2]="formatting"						
						elif [ $tmpState = "in_sync" ]
						then
							BayInfo[2]="active"
						elif [ $tmpState = "spare" ]
						then
							BayInfo[2]="synching"
						elif [ $tmpState = "faulty" ]
						then
							BayInfo[2]=$tmpState
						else
							BayInfo[2]="wrong"
						fi
					fi
				fi
			fi
			tmpP=`nice -n -10 grep -m 1 $tmpNode /proc/partitions`
			BayInfo[3]=`AwkKJC 3 $tmpP`
			BayInfo[3]=$(( ${BayInfo[3]}*1024))
			BayInfo[4]=`nice -n -10 cat /sys/block/${BayInfo[1]}/device/vendor`
			BayInfo[5]=`nice -n -10 cat /sys/block/${BayInfo[1]}/device/model`
		fi
		nice -n -10 echo ${BayInfo[*]} >> $LST_BAY
	done
}

##########################################################
#
#  Functions : add linear mode
#
#  variable : Nature-device-partition-status
#  function : Nature-action-device-detail
########################################################## 
SSS_SYS_RAID="/dev/md0"
SSS_SWP_RAID="/dev/md1"
SSS_VOL_RAID1="/dev/md2"
SSS_VOL_RAID2="/dev/md3"
SSS_SYS_SIZ="+2G"
SSS_SWP_SIZ="+256M"


# $1~: Elements to be initialized
Dev_Init_User_Superblock()
{
        mdadm --zero-superblock --force $1 $2 $3 $4
}

# $1~: Elements to be initialized
Dev_Init_User()
{
	Dev_Init_User_Superblock $1 $2 $3 $4
        echo " Initializing User done"
}

# $1 : $STR_VOL
# $2 : $STR_VOL_DEV
# $3 : $STR_VOL_LVL_TGT 	
Dev_Make_FS()
{
	if [ $3 = "raid5" ]
	then 
		mkfs.ext3 -v -j -O sparse_super -O dir_index -E stride=16 $2
	else 
		mkfs.ext3 -j $2
	fi
	echo -e 'y\n' | e2fsck -f $2
	if [ $3 != "none" ]
	then
		echo -e 'w\n' | fdisk $2
	fi
	mount $2 $1
	if [ $1 = $SSS_VOL1 ]
	then
		tar jxvf /boot/home.tar.bz2 -C /
	fi
}

# $1 : Current
# $2 : Target
# (ex) HDD1 - > RAID : $STR_VOL_DEV $SSS_VOL1
#      HDD1          : $STR_VOL_DEV ${ARR_VOL_ELE_NEW[1]}
Dev_Modify_fstab()
{
	sed 's:'$1':'$2':' /etc/fstab > /ttt.$$$
	mv /ttt.$$$ /etc/fstab
}

# $1 : $STR_VOL | $STR_VOL_DEV
Raid_Umount_User()
{
	cd /
#	fuser -km $1
	killall smbd
	killall nmbd
	umount $1
}

# $1 : $STR_VOL_DEV
# $2 : $STR_VOL_LVL_TGT (for modify,make) 
# $3 : $CNT_VOL_ELE_ALL 
# $4 : missing flag (1 -> missing element exist)
# $5~: ${ARR_VOL_ELE_NEW[*]}
Raid_Grow_User()
{
	echo $1 $2 $3 $4 $5 $6 $7
	if [ $2 = "linear" ]
	then
		mdadm -G $1 -a $5 $6 $7
		resize2fs $1 &
	else
		if [ $4 -eq 1 ]
		then
			mdadm $1 -a $5 $6 $7 
			RaidWaitLCD migrate $4 $1 $2
			mdadm -G $1 -n $3 --backup-file=/tmp/backupfile
			RaidWaitLCD migrate $4 $1 $2
			case $2 in
			raid5|linear)
				resize2fs $1 &
			;;
			esac
		else
			mdadm $1 -a $5 $6 $7 
			mdadm -G $1 -n $3 --backup-file=/tmp/backupfile
			RaidWaitLCD migrate $4 $1 $2
			resize2fs $1 &
		fi	
	fi
}
RaidWaitLCD()
{
	flg_end=1
	sleep 10
	while :
	do
#		echo "wait for finish migration.."
		sleep 5
		tmpComplete=(`cat /sys/block/${3##*/}/md/sync_completed|cut -d' ' -f1,3`) 
		case $1 in
		"migrate")
			flg_mig=1 
			if [ $4 = "raid1" ]
			then
				grep -q "recovery" /proc/mdstat 
				case $? in
				0)
					tmpRatio=$(((${tmpComplete[0]}*10000/${tmpComplete[1]}+5)/10))
					flg_mig=0
				;;
				*)
					flg_end=0
				;;
				esac
			else
				case $2 in
				1)		
					grep -q "recovery" /proc/mdstat
					if [ $? -eq 0 ]
					then
						tmpRatio=$(((${tmpComplete[0]}*3000/${tmpComplete[1]}+5)/10)) 
						flg_mig=0
					fi			
					grep -q "reshape" /proc/mdstat 
					if [ $? -eq 0 ]
					then
						tmpRatio=$(((3005+${tmpComplete[0]}*7000/${tmpComplete[1]})/10)) 
						flg_mig=0
						flg_end=0
					fi
				;;
				*)
					grep -q "reshape" /proc/mdstat 
					if [ $? -eq 0 ]
					then
						tmpStart=`cat /sys/block/${3##*/}/md/resync_start`
						tmpComplete[0]=$((${tmpComplete[0]}-$tmpStart))
						tmpComplete[1]=$((${tmpComplete[1]}-$tmpStart))
						tmpRatio=$(((${tmpComplete[0]}*10000/${tmpComplete[1]}+5)/10))
						flg_mig=0
					else
						flg_end=0
					fi	
				;;
				esac
			fi		
			if [ $flg_mig -eq 1 ] 
			then
				case $flg_end in
				0)
					MSG_Once "Migration:End"
				;;
				esac
				return 0
			else
				a=$(($tmpRatio/10))	
				b=$(($tmpRatio%10))
				MSG_Once "Migrating:$a.$b%"
			fi
		;;
		"expand")
			flg_exp=1
			grep -q "resync" /proc/mdstat 
			if [ $? -eq 0 ]
			then
				tmpRatio=$(((${tmpComplete[0]}*10000/${tmpComplete[1]}+5)/10))
				flg_exp=0
			else
				flg_end=0
			fi		
			if [ $flg_exp -eq 1 ] 
			then
				case $flg_end in
				0)
					MSG_Once "Expansion:End"
				;;
				esac
				return 0
			else
				a=$(($tmpRatio/10))	
				b=$(($tmpRatio%10))
				MSG_Once "Expanding:$a.$b%"
			fi	
		;;
		esac
	done
}

# $1 : $STR_VOL
# $2 : $STR_VOL_DEV
# $3 : $STR_VOL_LVL_CRT
# $4 : $STR_VOL_LVL_TGT
# $5 : $CNT_VOL_ELE_ACT      | $CNT_VOL_ELE_NEW
# $6 : ${ARR_VOL_ELE_ACT[1]} | ${ARR_VOL_ELE_NEW[1]
# $7 : ${ARR_VOL_ELE_ACT[2]} | NULL
Raid_Init_User()
{
	TMP_VAR=`mount | grep $1 | awk '{print $1}'`
	if [ -z TMP_VAR ]
	then
		Raid_Make_User $2 $4 2 $6 missing 
	else
		Raid_Umount_User $1
		if [ $5 -eq 2 ] && [ $3 = "raid1" ]
		then
			Raid_Delete_User $2 $7
			ARR_VOL_ELE_NEW[0]=$7 
		fi
		Raid_Make_User $2 $4 2 $6 missing 
	fi
}

# $1 : $STR_VOL_DEV
# $2 : $STR_VOL_LVL_TGT
# $3 : $CNT_VOL_ELE_NEW
# $4~ : ${ARR_VOL_ELE_NEW[*]}
Raid_Make_User()
{
	mdadm -CfR $1 -l $2 -n $3 $4 $5 $6 $7
}

# $1 : $STR_VOL_DEV
# $2~: ${ARR_VOL_ELE_ACT[*]}
Raid_Delete_User()
{
	TMP_VAR=`mount | grep $1 | awk '{print $1}'`
	if [ -z TMP_VAR ]
	then
		echo
	else
		Raid_Umount_User $1
	fi
	ps -w | grep resize2fs |grep $1
	if [ $? -eq 0 ]
	then
		killall resize2fs
	fi
	ps -w | grep mkfs.ext3 |grep $1
	if [ $? -eq 0 ]
	then
		killall mkfs.ext3
	fi
	mdadm -S $1
	Dev_Init_User_Superblock $2 $3 $4 $5
}

# $1 : $STR_VOL_DEV
# $2~ : ${ARR_VOL_ELE_NEW[*]}
Raid_Add_User()
{
	mdadm $1 -a $2 $3 $4 $5
}


Ser_Restart_Samba()
{
	/usr/local/samba/sbin/smbd -D
	/usr/local/samba/sbin/nmbd -D
}

#==============================================================================
# Make New User
#
#=============================================================================
# $1 : $STR_VOL
# $2 : $STR_VOL_DEV=${ARR_VOL_ELE_NEW[1]}
# $3 : $STR_VOL_LVL_TGT
Sub_Make_Vol_Hdd1()
{
        Dev_Make_FS $1 $2 $3 &&	Ser_Restart_Samba
}
# $1 : $STR_VOL
# $2 : $STR_VOL_DEV
# $3 : $STR_VOL_LVL_CRT
# $4 : $STR_VOL_LVL_TGT
# $5 : $CNT_VOL_ELE_NEW
# $6~ : ${ARR_VOL_ELE_NEW[*]}
Sub_Make_Vol_Raid()
{
	case $4 in
	linear|raid10|raid0)
		Raid_Make_User $2 $4 $5 $6 $7 $8 $9
		Dev_Make_FS $1 $2 $4 && Ser_Restart_Samba 
	;;
	raid1|raid5)
		Raid_Init_User $1 $2 $3 $4 $5 $6
		Dev_Make_FS $1 $2 $4 && Ser_Restart_Samba 
		Raid_Grow_User $2 $4 $5 1 $7 $9 $8
	;;
	esac
}

Sub_Make_Vol_ModFstab()
{
	cat /etc/fstab > /tmp/ttt.$$$
	tmp_ttt=$1
	tmp_xxx=$((${tmp_ttt##*l}+1))
	echo "tmp_ttt="$tmp_ttt"  tmp_xxx="$tmp_xxx
	echo -e $2"\t "$1"\t ext3\t noatime,data=writeback,usrquota,grpquota\t 0\t"$tmp_xxx >> /tmp/ttt.$$$
	mv /tmp/ttt.$$$ /etc/fstab
}

# $1 : $STR_VOL
# $2 : $STR_VOL_DEV
# $3 : $STR_VOL_LVL_CRT
# $4 : $STR_VOL_LVL_TGT
# $5 : $CNT_VOL_ELE_NEW
# $6~ : ${ARR_VOL_ELE_NEW[*]}
Main_Make_Vol()
{
        if [ $5 -eq 1 ]
        then
                Sub_Make_Vol_Hdd1 $1 $6 $4  
        else
                Sub_Make_Vol_Raid $1 $2 $3 $4 $5 $6 $7 $8 $9
        fi
	Sub_Make_Vol_ModFstab $1 $2
}
#===============================================================================
# Delete User Raid
#
#==============================================================================

# $1 : $STR_VOL_DEV
# $2 : $STR_VOL_LVL_CRT
# $3~: ${ARR_VOL_ELE_ACT[*]}
Main_Delete_Vol()
{
	if [ $2 = "none" ]
	then
		Raid_Umount_User $1
	else
		Raid_Delete_User $1 $3 $4 $5 $6
	fi
	Ser_Restart_Samba
	TmpVar1=$1
	TmpVar2=${TmpVar1##*/}
	cat /etc/fstab | sed -e "/$TmpVar2/d" > /tmp/.ttt
	mv /tmp/.ttt /etc/fstab
}

#==============================================================================
# Migrate User RAID
#
#=============================================================================

# $1 : $STR_VOL		(Volume name)
# $2 : $STR_VOL_DEV	(Volume device name)
# $3 : $STR_VOL_LVL_CRT	(Current RAID level)
# $4 : $STR_VOL_LVL_TGT	(Target RAID level)
# $5 : $CNT_VOL_ELE_ACT	(Number of active element)
# $6 : $CNT_VOL_ELE_NEW	(Number of new element)
# ~${6+$5}    : ${ARR_VOL_ELE_ACT[*]} (Names of active volume elements (ex: /dev/sda3, /dev/sdb3....))
# ~${6+$5+$6} : ${ARR_VOL_ELE_NEW[*]} (Names of new volume elements (ex: /dev/sdc3, ....))
Sub_Modify_Vol_Migrate_Raid()
{
	tSTR_VOL=`echo $1 |awk -F'/' '{print $4}'`
	tSTR_VOL_DEV=`echo $2 |awk -F'/' '{print $3}'`
	echo "$tSTR_VOL $tSTR_VOL_DEV"
	cnt=0
	CNT_ALL=$(($5 + $6))
	tmpBays=""
	while [ $cnt -lt $CNT_ALL ]
	do
		tmpBay=`AwkKJC $(($cnt+7)) $*`
		tmpT=`Get_BayName ${tmpBay##*/}`
		tmpBays=$tmpBays" "$tmpT
		cnt=$(($cnt+1))
	done 
	case $5 in
	1) 
		if [ $4 = "linear" ]
		then
			Raid_Umount_User $1
			Raid_Make_User $2 $4 $CNT_ALL $7 $8 $9 ${10} 
			mount $2 $1 
			Ser_Restart_Samba
			sleep 5
			MSG_Once "Migration:End" 
			VOL_ChangeConf $tSTR_VOL $tSTR_VOL_DEV $4 $CNT_ALL $tmpBays
			resize2fs $2 &
		else
			Raid_Init_User $1 $2 $3 $4 $5 $7
			mount $2 $1
			Ser_Restart_Samba
			MSG_Once "Migration:$tSTR_VOL" 
			VOL_ChangeConf $tSTR_VOL $tSTR_VOL_DEV $4 $CNT_ALL $tmpBays
			Raid_Grow_User $2 $4 $CNT_ALL 1 $8 ${10} $9 
		fi	
#		Dev_Modify_fstab $7 $2
		mount $2 $1
	;;
	2)
		if [ $3 = "raid1" ]
		then
			Raid_Delete_User $2 $8
			Raid_Init_User $1 $2 $3 $4 $5 $7 
			mount $2 $1
			Ser_Restart_Samba
			MSG_Once "Migration:$tSTR_VOL" 
			VOL_ChangeConf $tSTR_VOL $tSTR_VOL_DEV $4 $CNT_ALL $tmpBays
			Raid_Grow_User $2 $4 $CNT_ALL 1 $8 ${10} $9 
		elif [ $3 = "linear" ]
		then
			VOL_ChangeConf $tSTR_VOL $tSTR_VOL_DEV $4 $CNT_ALL $tmpBays
			Raid_Grow_User $2 $4 $CNT_ALL 0 $9 ${10}
		fi
	;;
	3)
		MSG_Once "Migration:$tSTR_VOL" 
		VOL_ChangeConf $tSTR_VOL $tSTR_VOL_DEV $4 $CNT_ALL $tmpBays
		Raid_Grow_User $2 $4 $CNT_ALL 0 ${10}
	;;
	esac
	SSS_GetVolListOrg
	return 0
}


# $1 : $STR_VOL		(Volume name)
# $2 : $STR_VOL_DEV	(Volume device name)
# $3 : $STR_VOL_LVL_CRT	(Current RAID level)
# $4 : $STR_VOL_LVL_TGT	(Target RAID level)
# $5 : $CNT_VOL_ELE_ACT	(Number of active element)
# $6 : $CNT_VOL_ELE_NEW	(Number of new element)
# ~${6+$5}    : ${ARR_VOL_ELE_ACT[*]} (Names of active volume elements (ex: /dev/sda3, /dev/sdb3....))
# ~${6+$5+$6} : ${ARR_VOL_ELE_NEW[*]} (Names of new volume elements (ex: /dev/sdc3, ....))
Main_Modify_Vol()
{
	tCNT=$#
	tSTR_VOL=`echo $1 |awk -F'/' '{print $4}'`
	tSTR_VOL_DEV=`echo $2 |awk -F'/' '{print $3}'`
	tCNT_VOL_ELE_ALL=$(($5+$6))
	cnt=7
	tALL_ELE=" "
	while [ $cnt -le $tCNT ]
	do
		tELE=`eval echo '$'{$cnt}|awk -F'/|3' '{print $3}'`  
		echo "$cnt ${tELE}"
		tALL_ELE=${tALL_ELE}${tELE}" "
		cnt=$(($cnt+1))
	done
	SSS_GetVolListOrg m$tSTR_VOL $tSTR_VOL_DEV $4 $tCNT_VOL_ELE_ALL $tALL_ELE
	MSG_Once "Migration Starts"
	echo "Migration Start"
	Sub_Modify_Vol_Migrate_Raid $* && MSG_Once "$tSTR_VOL Migration End : Level=$4, Number of HDDs=$tCNT_VOL_ELE_ALL"
}


#==============================================================================
# Expand User RAID
#
#=============================================================================

# $1 : $STR_VOL_DEV	(Volume device name)
# $2 : $STR_VOL_LVL_CRT	(Current RAID level)
Sub_Expand_Vol_Expand_Raid()
{
	case $2 in
	raid1|raid5)
		mdadm -G $1 -z max
	;;
	*)
		echo "Error : not supported RAID level"
	;;
	esac
}

# $1 : $STR_VOL_DEV	(Volume device name)
# $2 : $STR_VOL_LVL_CRT	(Current RAID level)
Main_Expand_Vol()
{
	Sub_Expand_Vol_Expand_Raid $*
}

#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
#
# RUN!!!
#
# $1 : $STR_MOD 	(Mode)
# $2 : $STR_VOL		(Volume name)
# $3 : $STR_VOL_DEV	(Volume device name)
# $4 : $STR_VOL_LVL_CRT	(Current RAID level)
# $5 : $STR_VOL_LVL_TGT	(Target RAID level)
# $6 : $CNT_VOL_ELE_ACT	(Number of active element)
# $7 : $CNT_VOL_ELE_NEW	(Number of new element)
# ~${7+$6}    : ${ARR_VOL_ELE_ACT[*]} (Names of active volume elements (ex: /dev/sda3, /dev/sdb3....))
# ~${7+$6+$7} : ${ARR_VOL_ELE_NEW[*]} (Names of new volume elements (ex: /dev/sdc3, ....))
# 
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
unset ARR_VOL_ELE_ACT 
unset ARR_VOL_ELE_NEW
unset ARR_VOL_ELE_ALL 
declare -a ARR_VOL_ELE_ACT	# Device names of active devices
declare -a ARR_VOL_ELE_NEW	# Device names of new devices 
declare -a ARR_VOL_ELE_ALL	# Device names of all devices : /dev/sda3 | /dev/sdb3 | /dev/sdc3 | /dev/sdd3
SSS_Web_Vol_Func()
{
	# Def_Define_Globals 
	STR_MOD=$1			# Mode status : delete | make | modify
	STR_VOL=$2			# Volume name (ex: /mnt/fs/Vol1 |  ...)
	STR_VOL_DEV=$3			# Currunt volume device name (ex: /dev/md2 | /dev/sda3 | none | ...)
	STR_VOL_LVL_CRT=$4		# Current volume level	: none | linear | raid0 | raid1 | raid5 | raid10
	STR_VOL_LVL_TGT=$5		# Target volume level	: none | linear | raid0 | raid1 | raid5 | raid10 (for make)
					#			linear | raid1  | raid5 (for modify) 
	CNT_VOL_ELE_ACT=$6		# Count of active devices consisting of the volume
	CNT_VOL_ELE_NEW=$7		# Count of new devices to be added
	CNT_VOL_ELE_ALL=$(($6 + $7))	# Count of all devices related to the volume


	OFFSET_INPUT=7
	i=1 
	while [ $i -le $CNT_VOL_ELE_ACT ]
	do
		eval HOST_TMP='$'{$(($OFFSET_INPUT + $i))}
	#	ARR_VOL_ELE_ACT[$i]="/dev/"`find /sys/block/ -name device |xargs ls -l |awk '{print $9 $11}'|awk -F'/' '{print $4" "$10}' | grep $HOST_TMP |awk '{print $1}'`"3"
		ARR_VOL_ELE_ACT[$i]=$HOST_TMP
		i=$(($i + 1))
	done 
	OFFSET_INPUT=$((7 + $CNT_VOL_ELE_ACT))
	i=1 
	while [ $i -le $CNT_VOL_ELE_NEW ]
	do
		eval HOST_TMP='$'{$(($OFFSET_INPUT + $i))}
	#	ARR_VOL_ELE_NEW[$i]="/dev/"`find /sys/block/ -name device |xargs ls -l |awk '{print $9 $11}'|awk -F'/' '{print $4" "$10}' | grep $HOST_TMP |awk '{print $1}'`"3"
		ARR_VOL_ELE_NEW[$i]=$HOST_TMP
		i=$(($i + 1))
	done 
	# slabolG_enifeD_feD 	

	#Run!!!	
	case $STR_MOD in
	delete)
		#echo ${ARR_VOL_ELE_ACT[*]}
		Main_Delete_Vol $STR_VOL_DEV $STR_VOL_LVL_CRT ${ARR_VOL_ELE_ACT[*]}
	;;
	create)
		Main_Make_Vol $STR_VOL $STR_VOL_DEV $STR_VOL_LVL_CRT $STR_VOL_LVL_TGT $CNT_VOL_ELE_NEW ${ARR_VOL_ELE_NEW[*]} &
	;;
	migrate)
		Main_Modify_Vol $STR_VOL $STR_VOL_DEV $STR_VOL_LVL_CRT $STR_VOL_LVL_TGT $CNT_VOL_ELE_ACT $CNT_VOL_ELE_NEW ${ARR_VOL_ELE_ACT[*]} ${ARR_VOL_ELE_NEW[*]} &
	;;
	expand)
		Main_Expand_Vol $STR_VOL_DEV $STR_VOL_LVL_CRT
	;;
	*)
		echo "Input error"
	;;
	esac
}
