#!/bin/bash
#
# Init file for kvdisk daemon in kernel
#
# chkconfig: 2345 90 90
# description: kvdisk daemon
#

PATH=/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin:.

#ha=$(hintget ha)
#if [ "$ha" = "enable" ]; then
#	count=200
#else
#	count=$(hintget max_client)
#fi
#HKVER=$(cat /proc/version |awk '{print $3}'|cut -c1)
count=10
HKVER=$(cat /proc/version |grep -q "2.6.18"&& echo 2 ||echo 3)
#count=$(hintget max_now)
[ -z "$count" ] && count=$(hintget max)
caches_list=$(hintget writeback_list)
all_iface_list=$(hintget vdisk_ethlist)
unset iface_list

        if [[ $[ $(cat /proc/uptime |cut -d. -f1) ] -ge $[10*60] ]]
        then
                for iface_net in $(echo $all_iface_list | tr ',' ' ')
                 do
                        if [ -z $iface_list ]
                        then
                                ethtool $iface_net |grep -q yes&&iface_list=$iface_net
                        else
                                ethtool $iface_net |grep -q yes&&iface_list=${iface_list},${iface_net}
                        fi
                done
        else
                iface_list=$(echo $all_iface_list)
        fi
iface=$(hintget vdisk_ethlist | cut -d, -f1)
iface_count=$(echo $(echo  $iface_list)| tr "," "\n" | wc -l)
rawno=$(echo $(hintget data_list), system_list | tr "," "\n" | wc -l)
wr_off=32
rawno=$[$rawno*2];
#exec >/var/log/kvdisk.log 2>&1
kvdisk_log=/usr/local/bin/kvdisk_log_app
[ -f $kvdisk_log ] || kvdisk_log = "echo "
srv_stat=/var/lock/kvdisk_stat
ev_path=/usr/local/bin/events_up_ex
refresh_path=/usr/local/bin/refresh
# $ev_path "kvdisk" "740000" "4.0"  "0" "740011" "$?" "disk not found" & 1>/dev/null
checkloop()
{
	while [ ! -b $1 ]
	do
		sleep 1
	done
}

vdisk_op()
{
#	if [  -f $srv_stat ]
#	then
#		$kvdisk_log "error: wait kvdisk .. $1 $2 $3 $4 $5"
#		exit 2
#	else
#		echo $1 $2 $3 $4 $5
		echo $1 $2 $3 $4 $5 >/proc/vDisk	
#	fi
}

vdisk_reset()
{
	if [ -n "$4" ]
	then
		local VDISK_FPATH="$1"
		local VDISK_MAJOR="$2"
		local VDISK_MINOR="$3"
		local VDISK_ETHER="$4"
		echo reset $1 $2 $3 $4  >/proc/vDisk    2>/dev/null
                local vRet=$?
            if [ "$vRet"  != "0" -o "$HKVER" == "2" ]
            then
            	local disk_status=$(get_vdisk_status $VDISK_MAJOR  $VDISK_MINOR)
                if [ -z  "$disk_status" ]
    	        then 
            	        vdisk_op add $VDISK_FPATH  $VDISK_MAJOR $VDISK_MINOR $VDISK_ETHER
				elif [ "$disk_status" == "on" ]
				then
	                    vdisk_op set $VDISK_FPATH $VDISK_MAJOR $VDISK_MINOR $VDISK_ETHER
		                vdisk_op set $VDISK_FPATH $VDISK_MAJOR $VDISK_MINOR $VDISK_ETHER
				elif [ "$disk_status" = "off" ]
				then
		                vdisk_op set $VDISK_FPATH $VDISK_MAJOR $VDISK_MINOR $VDISK_ETHER
				else
	                    $kvdisk_log "error: get_vdisk_status $VDISK_MAJOR          $VDISK_MINOR = $disk_status"
	            fi
			fi
	fi
}

remove_all_rwsepdev()
{
	if [ "$HKVER" == "2" ]
        then
	cowcount=0
	for cow_dev in $(cowdev -l |grep "/dev/rwsep/"|awk '{ print$1 }')
	do
        	cowcount=$[$cowcount+1]
        	cow_dev_[cowcount]=$cow_dev
	done
	for (( no = $cowcount; no >= 1; no-- )); do
        	cowdev -d ${cow_dev_[$no]}
	done
	fi

}

get_data_dev()
{
	if [ -n "$1"  ]	
	then
		dev=$(hintget ${1}_dev)
		if [ -b "$dev" ]
		then
			echo $dev
		else
			
			image_dir=$(hintget ${dev}_dir)
			if [ -n "$image_dir" ]
			then
				image_path=$image_dir/${1}/image
				if [ -f "$image_path" ]
				then
					echo $image_path
				fi
			fi
		fi
	fi
}

get_dev_size()
{
	if [ -n "$1"  ]	
	then
		if [ -b "$1" ]
		then
				disk_size=$(fdisk -l $1 2>/dev/null|grep ^Disk.*bytes | cut -d, -f2|awk '{ print$1 }')
				echo $disk_size
		else
				if [ -f "$1" ]
				then
        				disk_size=$(ls $1 -l|awk '{print $5}')
					echo $disk_size
				fi
				
		fi
	fi
}

start() {

	if [ -z "$iface" ]
	then
		$kvdisk_log 'please reset the diskless server !'
	#	$ev_path "kvdisk" "0" "740000" "4.0"  "1" "740003" "$?" "" & 1>/dev/null
		exit 1
	fi
	$kvdisk_log  "info: Ver = Hintdisk-$(cat /etc/hintver)"
	$kvdisk_log "info: Start kvdisk ...."
	touch $srv_stat
################################# SYSCTRL #################################
	memsize=$(cat /proc/meminfo |grep MemTotal|awk '{print $2}')
	if [ -n "$memsize" ]
	then
		$kvdisk_log "info: memsize=$memsize"
		if [ "$memsize" -lt 6000000 ] 
		then
			echo 40960 >/proc/sys/vm/min_free_kbytes
		else
			
			echo 409600 >/proc/sys/vm/min_free_kbytes
		fi
	else
		$kvdisk_log "error: cat /proc/meminfo fail !"
		exit 1
	fi
	rm -fr /dev/fd0
	rm -fr /dev/fd1
	echo 100 >/proc/sys/vm/vfs_cache_pressure
	echo 40 >/proc/sys/vm/swappiness
	echo 1 >/proc/sys/kernel/panic  ### if panic ,then reboot
###########################################################################

	if [ -f /proc/vDisk ] 
	then
		$kvdisk_log 'info: kvdisk server is already  running !'
		ps -A|grep -q   in.tftpd  &&  /usr/bin/killall -9 in.tftpd
		/usr/local/bin/bootdisk stop
	 	ps -A|grep -q  in.tftpd  ||  /usr/sbin/in.tftpd -l -u root -s /
		/usr/local/bin/bootdisk start
		touch /var/lock/subsys/kvdisk
	 	exit 2
	fi

	ps -A|grep -q   in.tftpd  &&  /usr/bin/killall -9 in.tftpd
	ps -A|grep -q   bootio && /usr/bin/killall -9 bootio

	max_set=$(hintget max)
	[ -n "$max_set" ] && hintput max_now $max_set && count=$max_set

##############################	mount disk ##############################
	/usr/local/bin/mountdisk -a

########################## copy sysdisk to ramdisk #######################
	[ -d /mnt/system ] || mkdir -p /mnt/system
   	mount |grep -q /mnt/system
   	if [ $? == 1 ]
  	then
            mkfs.ext2 /dev/ram0
            mount /dev/ram0 /mnt/system
	fi
	[ -f /mnt/system/BOOT.COM ] ||  cp /tftpboot/BOOT.COM /mnt/system/BOOT.COM
#	[ -f /mnt/system/MAIN.COM ] || cp /tftpboot/MAIN.COM /mnt/system/MAIN.COM
	for image_disk in $(hintget image_list | tr ',' ' ')
	do
		if [ "$image_disk" == "USER_SELECT" ]
                then
               		  continue
                fi

				ramdisk=$(hintget image_${image_disk}_ramdisk)
               	 if [ "$ramdisk" == "on" ]
                 then
			[ -b /mnt/system/${image_disk} ] || mkdir -p /mnt/system/${image_disk}
                     	system_ram_path=/mnt/system/${image_disk}/image
			system_path=$(hintget $(hintget image_${image_disk}_dir)_dir)/${image_disk}/image
                       	if  [ ! -f $system_ram_path ]
			then
				$kvdisk_log "info: copy $system_path to ramdisk"
				cp -fr $system_path $system_ram_path 
			fi
                fi
	done


########################  load modules ##################################
	if [ "$HKVER" == "2" ]
	then
		if grep -q cowloop /proc/modules
		then 
		    rmmod cowloop
		fi
		modprobe cowloop
		/usr/local/bin/makecowdevs
  		modprobe loop max_loop=16
	fi
	

	if [ ! -f /proc/vDisk ]
	then
	   # [ -f /lib/modules/$(uname -r)/kernel/drivers/block/vDisk/vDisk.ko ]
	   modprobe vDisk 2>/dev/null
	   if [ ! -f /proc/vDisk ]
	   then
			depmod -a
			modprobe vDisk
	   fi
	  if  [ -f "/var/lock/subsys/kvdisk" ] 
	  then
		 $kvdisk_log 'error: find unsafe shutdown !!!'
		$ev_path "kvdisk" "0" "740000" "4.0"  "1" "740015" "$?" "" & 1>/dev/null
		  rm -fr /var/lock/subsys/kvdisk
	  fi

	   sleep 1
	fi
	
	if [ ! -f /proc/vDisk ] 
	then
		$kvdisk_log 'error: vDisk.ko modules modprobe fail ,kvdisk start fail !!'
		exit 2
	fi
	
#############################set super sser devices#############################

    image_disk=$(hintget superip|cut -d# -f3|cut -d, -f1)
    if [ -n "$image_disk" ]
	then
		if [ "$HKVER" == "2" ]
		then
			checkloop /dev/loop0
			system_dir=$(hintget $(hintget image_${image_disk}_dir)_dir)/${image_disk}
			losetup /dev/loop0 ${system_dir}/image
 	   	  	cd ${system_dir} && cowdev -a /dev/loop0 ./update 0
      			cd ${system_dir} && cowdev -a /dev/rwsep/0 ./rollback 1	
			echo add /dev/rwsep/1 0 0 $iface > /proc/vDisk
		else
			system_dir=$(hintget $(hintget image_${image_disk}_dir)_dir)/${image_disk}
			if [ -n "$system_dir" ]
			then
				echo add ${system_dir}/image 0 0 $iface > /proc/vDisk
			fi
		fi
   fi

############################ set data diskSuper user devices ##############################
	
	data_no=1
	for data_disk in $(hintget data_list | tr ',' ' ')
	do
		data_dev=$(get_data_dev "$data_disk")

		if [ "$memsize" -lt 9000000 ] 
		then
			echo  $data_dev |grep -q 'md' && hdparm -a 2048 $data_dev
		else
			hdparm -a 2048 $data_dev
		fi
		echo add  $data_dev $data_no 0 $iface > /proc/vDisk
		#echo add  $data_loop $data_no 0 $iface > /proc/vDisk
		#e.g.: echo add /dev/loop1 1 0 eth0 > /proc/vDisk	
		data_no=$[$data_no+1]
	done	
	
########################## read disk.db ####################################
#	/usr/local/bin/update_diskdb
	for client in $(diskget -a | cut -d= -f2)
	do
		index=$(echo $client | cut -d# -f1)
		disk=$(echo $client | cut -d# -f3)
		data_disk=$(echo $client | cut -d# -f4)
		cache_disk=$(echo $client | cut -d# -f5)
		if [ "$disk" == "USER_SELECT" ]
                then
               		  continue
                fi
	   	client_disks[$index]=$disk
	    	data_disks[$index]=$data_disk
		cache_disks[$index]=$cache_disk
	done
	
######################### set default Disk ###################################
	default_disk=$(hintget image_list | cut -d, -f1)
	default_data=$(hintget data_list)
	default_cache=$(hintget writeback_list | cut -d, -f1)
	
######################### begin set vDisk for pc count ###################################
	$kvdisk_log "info: begin set vDisk ..."
	for (( pc = 1; pc <= $count; pc++ )); do
        	 major=$[$[$pc/255]*8]
       		 minor=$[$[$[$pc-1]%255]+1]

		cid=$[$pc%$iface_count]
		eth=$(echo $iface_list | cut -d, -f$[$cid+1])

		#=============Caches dir----------------------
		cache_disk=${cache_disks[$pc]}
		[ -z $cache_disk ] && cache_disk=$default_cache
		caches_dir=$(hintget ${cache_disk}_dir)/Caches
		if [ -n "$caches_dir" -a "$caches_dir" != "/Caches" ]
		then
			[ -b $caches_dir ] || mkdir -p $caches_dir
		else
			unset caches_dir
			cache_disk=$(echo $caches_list | cut -d, -f$[$cid+1])
			if [ -n "$cache_disk" ]
			then
				caches_dir=$(hintget ${cache_disk}_dir)/Caches
				[ -b $caches_dir ] || mkdir -p $caches_dir
			fi
		fi

		#------------System Disk---------------------
		system_disk=${client_disks[$pc]}
		[ -z "$system_disk" ] && system_disk=$default_disk
		if  [[  "$system_disk" != "NULL" ]]
		then 
			ramdisk=$(hintget image_${system_disk}_ramdisk)
        		if [ "$ramdisk" == "on" ]
        		then
				system_path=/mnt/system/${system_disk}/image
			else
				system_path=$(hintget $(hintget image_${system_disk}_dir)_dir)/${system_disk}/image
			fi

               		if  [ ! -f "$system_path" ]
              		 then
#                  	 $kvdisk_log "error: system_image: $system_path not found !"
         	  		 continue
	    		   else
				echo add $system_path $major $minor $eth > /proc/vDisk
		
#				system_size=$(hintget ${system_disk}_size)
        			system_size=$(ls $system_path -l|awk '{print $5}')
        			system_size=$[$system_size/1024/1024]
	 
				#-----------System Caches------------------
				if [ -n "$caches_dir" ]
				then
					[ -f ${caches_dir}/systmp_$pc ] || dd if=/dev/zero of=${caches_dir}/systmp_$pc bs=1M count=1 seek=$[$system_size]
					echo add ${caches_dir}/systmp_$pc $[$major+$wr_off] $minor $eth > /proc/vDisk
					client_data_disk=${data_disks[$pc]}
					[ -z "$client_data_disk" ] && client_data_disk=$default_data
					[ "$client_data_disk" == "NULL" ] && client_data_disk=$default_data
				fi
					
	               fi
		fi
#		checkloop /dev/loop$[$pc+$rawno]
#		losetup  /dev/loop$[$pc+$rawno] $system_path
		
		#------------Data Disk-------------------
		major=$[$major+1]
		for data_disk in $(echo $client_data_disk | tr ',' ' ')
		do
			disk_dev=$(get_data_dev $data_disk)
			if [ -z "$disk_dev" ] 
			then
			#	  $kvdisk_log "error: ${data_disk} dont has data_dev !"
				 break
			fi
			disk_size=$(get_dev_size $disk_dev)
			if [ -z $disk_size ]
			then
			 #	$kvdisk_log "error: ${data_disk} dont has data_size !"
				break;		
			fi
			echo add $disk_dev $major $minor $eth > /proc/vDisk
			##disk_size=$(hintget ${data_disk}_size)
			#disk_size=$(fdisk -l /dev/loop$[$major*$count*2+$rawno+$pc] 2>/dev/null|grep ^Disk.*bytes | cut -d, -f2|awk '{ print$1 }')
			disk_size=$[$disk_size/1024/1024]
			#-----------------Data Cache Disk -----------------
			if [  -n "$caches_dir" ] 
			then
				data_tmp=${caches_dir}/datatmp_${pc}_$major
				[ -f $data_tmp ] || dd if=/dev/zero of=$data_tmp bs=1M count=1 seek=$[$disk_size]
				echo add $data_tmp $[$major+$wr_off] $minor $eth > /proc/vDisk			
		   		major=$[$major+1]
			fi
		done
		
	done
#################################set vdisk for disk.db################################

	for client in $(diskget -a | cut -d= -f2)
	do
		index=$(echo $client | cut -d# -f1)
		if [ -n "$pclist" ]
		 then
			pclist=${pclist},${index}
		else
			pclist=$index
		fi
		disk=$(echo $client | cut -d# -f3)
		data_disk=$(echo $client | cut -d# -f4)
		cache_disk=$(echo $client | cut -d# -f5)
		client_disks[$index]=$disk
		data_disks[$index]=$data_disk
		cache_disks[$index]=$cache_disk
	done
	############################## set default disk ##########################
	default_disk=$(hintget default_disk)
	default_data=$(hintget data_list)
	default_caches=$(hintget writeback_list | cut -d, -f1)
 	#############################			 ############################
	for pc in $(echo $pclist | tr ',' ' ')
	do
		
        major=$[$[$pc/255]*8]
        minor=$[$[$[$pc-1]%255]+1]
        cid=$[$pc%$iface_count]
        eth=$(echo $iface_list | cut -d, -f$[$cid+1])

	#=============Caches dir----------------------
	cache_disk=${cache_disks[$pc]}
	
	[ -z $cache_disk ] && cache_disk=$default_cache
	caches_dir=$(hintget ${cache_disk}_dir)/Caches
	if [ -n "$caches_dir" -a "$caches_dir" != "/Caches" ]
	then
		[ -b $caches_dir ] || mkdir -p $caches_dir
	else
		unset caches_dir
		cache_disk=$(echo $caches_list | cut -d, -f$[$cid+1])
		if [ -n "$cache_disk" ]
		then
			caches_dir=$(hintget ${cache_disk}_dir)/Caches
			[ -b $caches_dir ] || mkdir -p $caches_dir
		fi
	fi

	############################ System Disk #############################
	system_disk=${client_disks[$pc]}
	[ -z "$system_disk" ] && system_disk=$default_disk
	if  [[  "$system_disk" != "NULL" ]]
	then 
		ramdisk=$(hintget image_${system_disk}_ramdisk)
 		if [ "$ramdisk" == "on" ]
       		 then
			system_path=/mnt/system/${system_disk}/image
		else
			system_path=$(hintget $(hintget image_${system_disk}_dir)_dir)/${system_disk}/image
		fi

		if  [ ! -f "$system_path" ]
	        then
#       	        $kvdisk_log "error: system_image: $system_path not found !"
	               continue
		else
			## on System Disk
			disk_status=$(get_vdisk_status $major          $minor)
			if [ -z  "$disk_status" ]
			then
				echo add $system_path  $major $minor $eth > /proc/vDisk
			fi
	
	      	 	 system_size=$(ls $system_path -l|awk '{print $5}')
     	 		  system_size=$[$system_size/1024/1024]

			############################ System Cache disk #############################
			
			## on System Caches Disk
			if [ -n "$caches_dir" ]
			then
				disk_status=$(get_vdisk_status $[$major+$wr_off]          $minor)
				if [ -z "$disk_status" ]
				then
					[ -f ${caches_dir}/systmp_$pc ] || dd if=/dev/zero of=${caches_dir}/systmp_$pc bs=1M count=1 seek=$[$system_size]
					echo add  ${caches_dir}/systmp_$pc $[$major+$wr_off]   $minor $eth > /proc/vDisk
				fi
			fi

       		 fi
    fi

	client_data_disk=${data_disks[$pc]}
	[ -z "$client_data_disk" ] && client_data_disk=$default_data	
	[ "$client_data_disk" == "NULL" ] && client_data_disk=$(hintget data_list)

	############################ Data disk #############################
	major=$[$major+1]
	for data_disk in $(echo $client_data_disk | tr ',' ' ')
	do
			disk_dev=$(get_data_dev $data_disk)
			if [ -z "$disk_dev" ] 
			then
#			 $kvdisk_log "error: ${data_disk} dont has data_dev !"
				 break
			fi

			disk_size=$(get_dev_size $disk_dev)
			if [ -z $disk_size ]
                        then
#			 $kvdisk_log "error: ${data_disk} dont has data_size !"
                                break;
                        fi

			disk_status=$(get_vdisk_status $major          $minor)
			if [ -z "$disk_status" ]
			then		
				echo add $disk_dev $major $minor $eth > /proc/vDisk
			fi
			if [ -n "$caches_dir" ]
			then
				disk_size=$[$disk_size/1024/1024]
				data_tmp=${caches_dir}/datatmp_${pc}_$major	
				disk_status=$(get_vdisk_status $[$major+wr_off]          $minor)
				if [ -z "$disk_status" ]
				then
					[ -f $data_tmp ] || dd if=/dev/zero of=$data_tmp bs=1M count=1 seek=$[$disk_size]
					echo add $data_tmp $[$major+$wr_off]  $minor $eth > /proc/vDisk 
				fi
			fi
			major=$[$major+1]
		
	done
     done
#######################################################################################
############################## start bootio ###########################################
	/usr/local/bin/bootdisk start
###############################vdisk cpu taskset #######################################
	cpuinfo=$( grep "processor" /proc/cpuinfo | wc -l )
	if [ ! $cpuinfo == 1 ]
	then
		$kvdisk_log "info: taskset Starting... cpus=$cpuinfo"
		p_index=0
		for vdisk_p in $(ps -ef |grep vDisk | grep -v grep | grep "vDiskd.[0-9]:[0-9]" | awk '{print $2}')
		do
			cid=$[$p_index%$cpuinfo]
			taskset -p $cid $vdisk_p >/dev/null 2>/dev/null
			p_index=$[$p_index+1]
		done
	fi
	[ $(which setenforce 2>/dev/null) ] && setenforce 0
	 ps -A|grep -q  in.tftpd  ||  /usr/sbin/in.tftpd -l -u root -s /
	touch /var/lock/subsys/kvdisk
	sync
	rm -fr $srv_stat
	$kvdisk_log "info: services started..."
}

stop() {
			
	$kvdisk_log "info: Stop kvdisk ...."
###	 /bin/sync
	 
	if [ ! -f /proc/vDisk ] 
	then
		$kvdisk_log "info: kvdisk dnot running !"
		return 2
	fi
########################## stop bootio ############################################
	/usr/local/bin/bootdisk stop
        ps -A|grep -q   in.tftpd  &&  /usr/bin/killall -9 in.tftpd

########################## stop super user devices #################################
	if [ "$HKVER" == "2" ]
	then
		cowdev_status=$(cowdev -l)
		if [ -n "$cowdev_status" ] 
		then
			disk_status=$(get_vdisk_status 0 0)
			if [ "$disk_status" == "on" ]
			then
				echo "set /dev/rwsep/1 0 0 $iface" > /proc/vDisk
			fi
			/usr/sbin/cowsync
			remove_all_rwsepdev
			lsmod | grep -q cowloop && rmmod cowloop
		fi
	fi

############################## unload modules ########################################
	rmmod vDisk
	[ -f /proc/rcache ] && rmmod rcache
	[ -f /proc/wcache ] && rmmod wcache
	
	for f in $(losetup -a | cut -d: -f1)
	do
		losetup -d $f
	done
	

######################### save super_disk #################################
	for image_disk in $(hintget image_list | tr ',' ' ')
    	do
		ramdisk=$(hintget image_${image_disk}_ramdisk)
		system_dir=$(hintget $(hintget image_${image_disk}_dir)_dir)/${image_disk}
		[ -f ${system_dir}/super_image ] && rm -fr ${system_dir}/super_image
		if [ -f ${system_dir}/image_init ]
		then
			if [ "$ramdisk" == "on" ]
			then
				[ -f /mnt/system/${image_disk}/image ] && rm -fr /mnt/system/${image_disk}/image
			fi
#			echo  save super_disk : ${system_dir}/image
#			cp -fr ${system_dir}/image ${system_dir}/super_image && rm -fr ${system_dir}/image_init
#		else
#			if [ ! -f ${system_dir}/super_image ]
#			then
#				echo  save super_disk : ${system_dir}/image
#				cp -fr ${system_dir}/image ${system_dir}/super_image
#			fi
        fi
	done

###########################################################################	
	echo 3 > /proc/sys/vm/drop_caches
##	mount |grep -q /mnt/system && umount /mnt/system
##	mount |grep -q /mnt/Caches && umount /mnt/Caches
	rm -f /var/lock/subsys/kvdisk
	$kvdisk_log "info: services stopped ..."
}

case $1 in 
   start)
	start
	$ev_path "kvdisk" "1" "740000" "4.0"  "0" "740011" "$?" "" & 1>/dev/null
	;;
   stop)
	stop
	$ev_path "kvdisk" "0" "740000" "4.0"  "0" "740014" "$?" "" & 1>/dev/null
	;;
   restart)
	stop
	start
	$ev_path "kvdisk" "1" "740000" "4.0"  "0" "740012" "$?" "" & 1>/dev/null
	$kvdisk_log "info: kvdisk restart end.."
	;;
   refresh)

	if [ -z "$iface" ]
	then
		exit 1
	fi
	[ -z "$3"  ] && exit 2
	if [ ! -f /proc/vDisk ]
	then
		$kvdisk_log "error: kvdisk is stopped !,cont refresh $2"
		exit 2
	fi
	pc=$2
	client_ip=$3
  	major=$[$[$pc/255]*8]
   	minor=$[$[$[$pc-1]%255]+1]
	cid=$[$pc%$iface_count]
	eth=$(echo $iface_list | cut -d, -f$[$cid+1])	
	
	########################### set super user device ###########################################
	if [ "$pc" -eq 0 ]
	then
		if [ "$HKVER" == "2" ]
		then
			lsmod|grep -q cowloop || modprobe cowloop
			disk_status=$(get_vdisk_status 0 0)
			if [ "$disk_status" == "on" ]
			then
				exit 0
			fi	
			remove_all_rwsepdev
			image_disk=$(hintget superip | cut -d# -f3)
			system_dir=$(hintget $(hintget image_${image_disk}_dir)_dir)/${image_disk}
			if [ -f ${system_dir}/rollback ]
			then
				rm -fr ${system_dir}/rollback
			fi
			if [ -z $image_disk ]
			then
				$kvdisk_log "error: superip image_disk not found !"
				exit 3
			fi
			[ -f ${system_dir}/update ] && rm -fr ${system_dir}/update	
	#		if [ -f ${system_dir}/image_init ]
	#		then
	#			[ -f ${system_dir}/super_image ] && rm -fr ${system_dir}/super_${disk}
	#			cp -fr ${system_dir}/image ${system_dir}/super_image && rm -fr ${system_dir}/image_init
	#		fi
			
	#		[ -f ${system_dir}/super_image ] || cp -fr ${system_dir}/image ${system_dir}/super_image
	                losetup /dev/loop0 ${system_dir}/image
	                cd ${system_dir} && cowdev -a /dev/loop0 ./update 0
	                cd ${system_dir} && cowdev -a /dev/rwsep/0 ./rollback 1
				
			if [ "$disk_status" == "off" ]
			then
				echo set /dev/rwsep/1 0 0 $iface > /proc/vDisk
			else
				echo add /dev/rwsep/1 0 0 $iface > /proc/vDisk
			fi
			/usr/local/bin/bootio 0 0 $iface  /dev/rwsep/1 $[24*256] & 
			exit 0
		else
			disk_status=$(get_vdisk_status 0 0)
			if [ "$disk_status" == "on" ]
			then
				exit 0
			fi	

			image_disk=$(hintget superip | cut -d# -f3)
			if [ -z $image_disk ]
			then
				$kvdisk_log "error: superip image_disk not found !"
				exit 3
			fi
			system_dir=$(hintget $(hintget image_${image_disk}_dir)_dir)/${image_disk}
			if [ -z $system_dir ]
			then
				$kvdisk_log "error: superip system_dir not found !"
				exit 3
			fi
			[ -f ${system_dir}/update ] && rm -fr ${system_dir}/update	
			[ -f ${system_dir}/rollback ] && rm -fr ${system_dir}/rollback
			[ -f ${system_dir}/index ] && rm -fr ${system_dir}/index
			touch  ${system_dir}/update
			touch ${system_dir}/rollback
			touch  ${system_dir}/index
			if [ "$disk_status" == "off" ]
			then
				vdisk_op set ${system_dir}/image 0 0 $iface
			else
				vdisk_op add ${system_dir}/image 0 0 $iface
			fi
			/usr/local/bin/bootio 0 0 $iface  ${system_dir}/image $[24*256] & 


			major=1
			for data_disk in $(echo $(hintget data_list) | tr ',' ' ')
			do
				disk_status=$(get_vdisk_status $major 0)
				disk_dev=$(get_data_dev $data_disk)
				if [ -z "$disk_dev" ] 
				then
					 $kvdisk_log "error: ${data_disk} dont has data_dev !"
					 exit 3
				fi
				if [ -b "$disk_dev" ]
				then
					if [ -z "$disk_status" ] 
					then
						vdisk_op add $disk_dev  $major 0 $iface
					else
						if [ "$disk_status" == "off" ]
						then
							vdisk_op set $disk_dev $major 0 $iface 
					
						fi
					fi
				
				else
					system_dir=$(hintget $(hintget ${data_disk}_dev)_dir)/${data_disk}
					if [ -z $system_dir ]
					then
						$kvdisk_log "error: superip system_dir not found !"
						exit 3
					fi
					[ -f ${system_dir}/update ] && rm -fr ${system_dir}/update	
					[ -f ${system_dir}/rollback ] && rm -fr ${system_dir}/rollback
					[ -f ${system_dir}/index ] && rm -fr ${system_dir}/index
					touch  ${system_dir}/update
					touch ${system_dir}/rollback
					touch  ${system_dir}/index
					if [ -z "$disk_status" ]
					then
						vdisk_op add ${system_dir}/image $major 0 $iface 
					else
						if [ "$disk_status" == "off" ]
						then
							vdisk_op set ${system_dir}/image $major 0 $iface
						fi

					fi


				fi
				major=$[$major+1]
			done	
			exit 0
		fi
	fi
	
############################### read diskdb ##############################
	client=$(diskget $client_ip)
	if [ -z "$client" ]
	then
		echo $client_ip not found in disk.db
		exit 0
	fi
	index=$(echo $client | cut -d# -f1)
	disk=$(echo $client | cut -d# -f3)
	data_disk=$(echo $client | cut -d# -f4)
	cache_disk=$(echo $client | cut -d# -f5)
	if [ "$disk" == "USER_SELECT" ]
        then
		echo "disk=$disk !!!"
		exit 0
        fi

	client_disks[$index]=$disk
	data_disks[$index]=$data_disk
	cache_disks[$index]=$cache_disk
	
############################## set default disk ##########################
	default_disk=$(hintget default_disk)
	default_data=$(hintget data_list)
	default_caches=$(hintget writeback_list | cut -d, -f1)
	#=============Caches dir----------------------
	cache_disk=${cache_disks[$pc]}
	[ -z $cache_disk ] && cache_disk=$default_cache
	caches_dir=$(hintget ${cache_disk}_dir)/Caches
	if [ -n "$caches_dir" -a "$caches_dir" != "/Caches" ]
	then
		[ -b $caches_dir ] || mkdir -p $caches_dir
	else
		unset caches_dir
		cache_disk=$(echo $caches_list | cut -d, -f$[$cid+1])
		if [ -n "$cache_disk" ]
		then
			caches_dir=$(hintget ${cache_disk}_dir)/Caches
			[ -b $caches_dir ] || mkdir -p $caches_dir
		fi
	fi


############################ System Disk #############################
	system_disk=${client_disks[$pc]}
	[ -z "$system_disk" ] && system_disk=$default_disk
	if [[  "$system_disk" != "NULL" ]]

	then
		ramdisk=$(hintget image_${system_disk}_ramdisk)
 		if [ "$ramdisk" == "on" ]
	       	 then
			system_path=/mnt/system/${system_disk}/image
		else
			system_path=$(hintget $(hintget image_${system_disk}_dir)_dir)/${system_disk}/image
		fi
		if  [ ! -f "$system_path" ]
       		 then
               		 $kvdisk_log "error: system_image: $system_path not found !"
			$ev_path "0" "kvdisk" "740006" "4.0"  "0" "740012" "$?" "image: $system_path not found !" & 1>/dev/null
				exit 3
	        fi

		vdisk_reset $system_path  $major $minor $eth


		#system_size=$(hintget ${system_disk}_size)
#     		 system_size=$(ls $system_path -l|awk '{print $5}')
#	        system_size=$[$system_size/1024/1024]
	
############################ System Cache disk #############################
		## off System Caches Disk
		if [ -n "$caches_dir" ]
		then
		disk_status=$(get_vdisk_status $[$major+$wr_off]          $minor)
		if [ -z "$disk_status" ]
		then
		#	[ -f ${caches_dir}/systmp_$pc ] && rm -f ${caches_dir}/systmp_$pc
		#	dd if=/dev/zero of=${caches_dir}/systmp_$pc bs=1M count=1 seek=$[$system_size]
			$refresh_path $system_path ${caches_dir}/systmp_$pc
			vdisk_op add  ${caches_dir}/systmp_$pc $[$major+$wr_off]   $minor $eth
		else
			if [ "$disk_status" == "on" ]
			then
				vdisk_op set ${caches_dir}/systmp_$pc $[$major+$wr_off]   $minor $eth
			#	[ -f ${caches_dir}/systmp_$pc ] && rm -f ${caches_dir}/systmp_$pc
			#	dd if=/dev/zero of=${caches_dir}/systmp_$pc bs=1M count=1 seek=$[$system_size]
				$refresh_path $system_path ${caches_dir}/systmp_$pc
				vdisk_op set ${caches_dir}/systmp_$pc $[$major+$wr_off]   $minor $eth
			else
				if [ "$disk_status" == "off" ]
				then
	#				[ -f ${caches_dir}/systmp_$pc ] && rm -f ${caches_dir}/systmp_$pc
	#				dd if=/dev/zero of=${caches_dir}/systmp_$pc bs=1M count=1 seek=$[$system_size]
					$refresh_path $system_path ${caches_dir}/systmp_$pc
					vdisk_op set ${caches_dir}/systmp_$pc $[$major+$wr_off]   $minor $eth
				else
					$kvdisk_log "error: get_vdisk_status $[$major+$wr_off]          $minor = $disk_status"
				fi
			fi
	
		fi
		fi

	fi
	
	client_data_disk=${data_disks[$pc]}
	[ -z "$client_data_disk" ] && client_data_disk=$default_data	
	[ "$client_data_disk" == "NULL" ] && client_data_disk=$default_data
					
############################ Data disk #############################
	major=$[$major+1]
	for data_disk in $(echo $client_data_disk | tr ',' ' ')
	do
			## off Data Disk 
			disk_dev=$(get_data_dev $data_disk)
			if [ -z "$disk_dev" ] 
			then
				 $kvdisk_log "error: ${data_disk} dont has data_dev !"
				 exit 3
			fi

#			disk_size=$(get_dev_size $disk_dev)
#			 if [ -z $disk_size ]
#                       then
#				$kvdisk_log "error: ${data_disk}:${disk_dev} no has disksize !"
#                               exit 3;
#                        fi

			disk_status=$(get_vdisk_status $major          $minor)
	
			vdisk_reset $disk_dev $major $minor $eth


			## off Data Caches Disk
			if [ -n "$caches_dir" ]	
			then
			#disk_size=$(fdisk -l /dev/loop$[$data_addon*$count*2+$rawno+$pc] 2>/dev/null|grep ^Disk.*bytes | cut -d, -f2|awk '{ print$1 }')
#			disk_size=$[$disk_size/1024/1024]
			data_tmp=${caches_dir}/datatmp_${pc}_$major	
			disk_status=$(get_vdisk_status $[$major+$wr_off]          $minor)
			if [ -z  "$disk_status" ]		
			then
			#	[ -f $data_tmp ] && rm -f $data_tmp 
			#	dd if=/dev/zero of=$data_tmp bs=1M count=1 seek=$[$disk_size]
				$refresh_path $disk_dev $data_tmp
				vdisk_op add $data_tmp $[$major+$wr_off] $minor $eth
			else
				if [ "$disk_status" == "on" ]
				then
					
					vdisk_op set $data_tmp $[$major+$wr_off]  $minor $eth
				#	[ -f $data_tmp ] && rm -f $data_tmp 
				#	dd if=/dev/zero of=$data_tmp bs=1M count=1 seek=$[$disk_size]
					$refresh_path $disk_dev $data_tmp
					vdisk_op set $data_tmp $[$major+$wr_off]  $minor $eth
				else
					
					if [ "$disk_status" == "off" ]		
					then
						$refresh_path $disk_dev $data_tmp
					#	[ -f $data_tmp ] && rm -f $data_tmp 
					#	dd if=/dev/zero of=$data_tmp bs=1M count=1 seek=$[$disk_size]
						vdisk_op set $data_tmp $[$major+$wr_off]  $minor $eth
					else
						$kvdisk_log "error: get_vdisk_status $[$major+$wr_off]          $minor = $disk_status"
					fi

				fi

			fi
			fi
			major=$[$major+1]
		
	done
	;;
   rmcaches)
	[ -z "$2" ] && exit 2
	dir=$(pwd)
	refresh_no=$2
        FileName=$(ls -ls|sort -n|awk '{ print$10 }')
        FileSize=$(ls -ls|sort -n|awk '{ print$1 }')

        count_file=0
        for x in $FileName
        do
                 count_file=$[$count_file+1]
                file_name[$count_file]=$x
                disk_no[$count_file]=$(echo ${file_name[count_file]} |cut -d_ -f2)
        done
        count_file=-1
        for x in $FileSize
        do
                 count_file=$[$count_file+1]
                file_size[$count_file]=$x
        done

        for (( no = $count_file; no >= $[$count_file-$refresh_no+1]; no-- )); do
                _size=${file_size[no]}
                _filename=${dir}/${file_name[no]}
                echo rm $_filename,size=$_size,diskno=${disk_no[no]}
		/etc/init.d/kvdisk refresh ${disk_no[no]}
        done
	;;
   remove)
   	[ -z "$2" -o "$2" -eq 0 ] && exit 2
	pc=$2
	cid=$[$pc%2]
	major=$[$pc/255]
	minor=$[$pc%255]
	if [ $cid == 0 ]
	then
		eth=$iface
	else
		eth=$othereth
	fi
	disk_status=$(grep "\<loop$[10+$pc]\>" /proc/vDisk | awk '{ print $5 }')
	if [ "$disk_status" == "on" ]
	then
		echo set /dev/loop$[10+$pc] $major $minor $eth > /proc/vDisk 
		echo set /dev/loop$[$count+10+$pc] $[$major+2] $minor $eth > /proc/vDisk
		echo set /dev/loop$[$count*2+10+$pc] $[$major+4] $minor $eth > /proc/vDisk
		echo set /dev/loop$[$count*3+10+$pc] $[$major+6] $minor $eth > /proc/vDisk
	fi
	losetup -a | grep -q loop$[10+$pc]  && losetup -d /dev/loop$[10+$pc]
	losetup -a | grep -q loop$[$count+10+$pc]  && losetup -d /dev/loop$[$count+10+$pc]
	losetup -a | grep -q loop$[$count*2+10+$pc]  && losetup -d /dev/loop$[$count*2+10+$pc]
	losetup -a | grep -q loop$[$count*3+10+$pc]  && losetup -d /dev/loop$[$count*3+10+$pc]	

	#[ -f /mnt/Caches/systmp_$pc ] && /bin/rm -f /mnt/Caches/systmp_$pc				 #-----Delete System Caches
	#[ -f /mnt/Caches/datatmp_$pc ] && /bin/rm -f /mnt/Caches/datatmp_$pc			 #-----Delete Data Disk Caches
	;;
   *)
	echo "service kvdisk start|stop|restart|remove|refresh"
esac

