jfs.subr

if [ ! "$_CBSD_JFS_SUBR" ]; then
_CBSD_JFS_SUBR=1
###

. ${zfstool}

# movedata $1-from $2-to
mvdata()
{
	local _src _dst
	[ -z "$1" -o -z "$2" ] && err 1 "mvdata: empty arguments"

	_src=$1
	_dst=$2

	[ -d "${_dst}" ] && err 1 "${_dst} directory exist. Please remove them first"

	if [ "${zfsfeat}" = "0" ]; then
		/bin/mv ${_src} ${_dst}
		return 0
	fi

	zfsmnt "${_src}"
	_res=$?

	readconf zfs.conf

	case $_res in
		0)
			echo "Switch to ZFS pool"
			zfsmnt ${workdir}
			/sbin/zfs create ${zfs_create_flags} -o mountpoint=${_dst} "${ZPOOL}${_dst}"
			/sbin/zfs mount "${ZPOOL}${_dst}"
			/bin/mkdir ${_dst}
			cd ${_src} && /bin/pax -p eme -rw . ${_dst} && ${CHFLAGS_CMD} -R noschg ${_src} && /bin/rm -rf ${_src}
		;;
		1)
			/sbin/zfs umount -f ${_src} > /dev/null 2>&1
			/sbin/zfs set mountpoint=${_dst} ${ZPOOL}
			/sbin/zfs mount ${ZPOOL}
			/bin/rmdir ${_src}
		;;
		2)
			/sbin/zfs set mountpoint=${_dst} ${ZPOOL}
			/sbin/zfs mount ${ZPOOL}
			/bin/rmdir ${_src}
		;;
	esac

	return 0
}


# clone data
# -d <path> - destination dir
# -f - force (no check for dir exist)
# -j - newjname
# -m <mode> - mode: cp, rsync, rsyncforce, zfs, zfspromote
# -n <new_name> - name of the clone for zfs/zfspromote method, e.g: $newjname variable
#		it was as cbsd-original-$new_name snapshot
# -p ${promote} - promote ZFS 0,1: ( 0 - promote)
# -s <path> - source dir
# e.g: clonedata -s /usr/jails/jails-data/jail1-data -d /mn -m rsync
clonedata()
{
	local _src _dst _mode _go _force _zpool _name _res _jname _orig_mode

	_force=0

	while getopts "d:fj:m:n:p:s:" opt; do
		case "$opt" in
			d) _dst="${OPTARG}" ;;
			f) force=1 ;;
			m) _mode="${OPTARG}" ;;
			n) _new_name="${OPTARG}" ;;
			p) _promote="${OPTARG}" ;;
			s) _src="${OPTARG}" ;;
		esac
		shift $(($OPTIND - 1))
	done

	[ -z "${_dst}" ] && err 1 "${MAGENTA}clonedata: empty ${GREEN}dst${NORMAL}"
	[ -z "${_mode}" ] && err 1 "${MAGENTA}clonedata: empty ${GREEN}mode${NORMAL}"
	[ -z "${_src}" ] && err 1 "${MAGENTA}clonedata: empty ${GREEN}src${NORMAL}"
	[ -z "${jname}" ] && err 1 "${MAGENTA}clonedata: no jname${NORMAL}"
	[ -z "${_new_name}" ] && _new_name="${jname}"
	[ -z "${_promote}" ] && _promote="0"

	# save original clone method
	_orig_mode="${_mode}"

	[ -d "${_dst}" -a ${_force} -eq 0 ] && err 1 "${MAGENTA}clonedata: ${GREEN}${_dst}${MAGENTA} directory exist. Please remove them${NORMAL}"

	readconf zfs.conf

	# check for ZFS clone possibility and create snapshot
	case "${_mode}" in
		zfs|zfspromote)
			[ ${zfsfeat} -ne 1 ] && err 1 "${MAGENTA}clonedata: zfs clone method but zfsfeat=0${NORMAL}"
			[ -z "${_new_name}" ] && err 1 "${MAGENTA}clonedata: empty -n new_name of the snapshot${NORMAL}"

			zfsmnt "${_src}"
			_res=$?
			case "${_res}" in
				0)
					# not valid ZFS mp, force non-zfs clone method
					${ECHO} "${MAGENTA}Force to rsync clone method, not ZFS mount point: ${GREEN}${_src}${NORMAL}"
					_mode="rsync"
					;;
				1|2)
					local _origdata=$( /sbin/zfs get -Ho value name ${_src} 2>/dev/null )
					if [ -z "${_origdata}" ]; then
						${ECHO} "${MAGENTA}${_src} is not ZFS dataset, force to rsync clone method${NORMAL}"
						_mode="rsync"
					else
						local _createtime=$( /bin/date "+%Y%m%d%H%M%S" )
						/sbin/zfs snapshot ${_origdata}@cbsd-original-${_new_name}
						/sbin/zfs set cbsdsnap:jname=${_new_name} ${_origdata}@cbsd-original-${_new_name}
						/sbin/zfs set cbsdsnap:snapname="${_origdata}" ${_origdata}@cbsd-original-${_new_name}
						create_zfs_fs -d "${_src}" -m "${_dst}" -n "${_new_name}" -p ${_promote} -z "${_origdata}@cbsd-original-${_new_name}"
					fi
					;;
				*)
					err 1 "${MAGENTA}clonedata: unknown code for: zfsmnt ${_src}${NORMAL}"
					;;
			esac
	esac

	case "${_mode}" in
		"cp")
			_go="/bin/cp -Rp "
			;;
		"rsync")
			_go="/usr/local/bin/rsync -avzz --devices --numeric-ids --delete --recursive --partial "
			;;
		"rsyncforce")
			_go="/usr/local/bin/rsync -avzz --devices --numeric-ids --delete --recursive --partial "
			_force=1
			;;
		zfs|zfspromote)
			[ -n "${_name}" ] && err 1 "${MAGENTA}clonedata: empty -n name of the snapshot${NORMAL}"
			unset _go
			;;
		*)
			err 1 "clonedata: unsupported mode: ${_mode}"
			;;
	esac

	# create directory and copy data via rsync/copy method
	if [ -n "${_go}" ]; then
		if [ ! -d "${_dst}" ]; then
			if [ ${zfsfeat} -eq 1 ]; then
				_zpool=$( /sbin/zfs list ${jaildatadir} |/usr/bin/tail +2 |/usr/bin/awk '{printf $1}' )
				/sbin/zfs create ${zfs_create_flags} -o mountpoint=${_dst} ${_zpool}/${jname}
				if ! is_mounted ${_zpool}/${jname}; then
					/sbin/zfs mount ${_zpool}/${jname}
				fi
			else
				/bin/mkdir -p ${_dst}
			fi
		fi

		${_go} ${_src}/* ${_dst}/
	fi

	# additional loop to check for symlink and zvol
	if [ ${zfsfeat} -eq 1 ]; then
		for i in $( /usr/bin/find ${_dst}/ -type l -depth 1 -maxdepth 1 ); do
			if is_getzvol ${i}; then
				imgbytes=$( /sbin/zfs get -Hp -o value volsize ${is_zvol} )
				# create_bhyvedsk ?
#				DATA=$( /sbin/zfs get -Ho value name ${jaildatadir} )
				new_zvol=$( echo ${is_zvol} |/usr/bin/sed s:${old}:${new}:g )

				case "${_orig_mode}" in
					zfs|zfspromote)
						local _createtime=$( /bin/date "+%Y%m%d%H%M%S" )
						/sbin/zfs snapshot ${is_zvol}@cbsd-original-${_new_name}
						/sbin/zfs set cbsdsnap:jname=${_new_name} ${is_zvol}@cbsd-original-${_new_name}
						/sbin/zfs set cbsdsnap:snapname="${_origdata}" ${is_zvol}@cbsd-original-${_new_name}
						/sbin/zfs clone -o volmode=dev -p ${is_zvol}@cbsd-original-${_new_name} ${new_zvol}
#						create_zfs_fs -d "${_src}" -n "${_new_name}" -p ${_promote} -z "${is_zvol}@cbsd-original-${_new_name}"
						;;
					*)
						/sbin/zfs create -V ${imgbytes} -o volmode=dev ${new_zvol}
						/bin/dd if=/dev/zvol/${is_zvol} of=/dev/zvol/${new_zvol} bs=1g
						;;
				esac

				/bin/ln -sf /dev/zvol/${new_zvol} ${i}
			fi
		done
	fi

	for i in $( /usr/bin/find ${_dst}/ -type l -or -type f -depth 1 -maxdepth 1 -name dsk\* ); do
		mydsk=$( /usr/bin/basename ${i} );
		[ -z "${mydsk}" ] && continue
		media mode=register name="hdd-${mydsk}" path="${i}" type="hdd" jname="${jname}"
	done

}

# remove data from disk
# $jname must be set
# if "$2" = "force" then force to remove non-empty dir
removedata()
{
	local _data _test _res

	[ -z "$1"  ] && err 1 "removedata: empty arguments"
	[ -z "${jname}"  ] && err 1 "removedata: jname variable must be set"

	_data=$1

	[ ! -d "${_data}" ] && return 0

	if [ "${zfsfeat}" = "1" ]; then
		case "${emulator}" in
			bhyve|xen)
				for i in $( /usr/bin/find ${data}/ -type l -depth 1 -maxdepth 1 ); do
					if is_getzvol ${i}; then
						/sbin/zfs destroy ${is_zvol}
					fi
					/bin/rm -f ${i}
				done
				;;
			*)
				;;
		esac

		# extra check for zfs still exist
		ZPOOL=$( /sbin/zfs get -Ho value name ${jaildatadir} 2>/dev/null )
		if [ -n "${ZPOOL}" ]; then
			local _jailfs="${ZPOOL}/bcbsd-${jname}-dsk1.vhd ${ZPOOL}/${jname}"
			local i
			for i in ${_jailfs}; do
				for try in 1 2 3; do
					# workaround for dataset busy, give the pause with three attempts
					/sbin/zfs list ${i} >/dev/null 2>/dev/null
					if [ $? -eq 0 ]; then
						sleep 1
						/sbin/zfs destroy ${i} > /dev/null 2>&1
					fi
				done
			done
		fi

		unmountdata ${_data}
		[ -d "${_data}" ] && /bin/rm -rf ${_data}
	elif [ "${hammerfeat}" = "1" ]; then
		destroy_hammer_fs ${jname}
	else
		if [ "$2" = "force" ]; then
			${CHFLAGS_CMD} -R noschg ${_data}
			/bin/rm -rf ${_data}
		else
			/bin/rmdir ${_data}
		fi
	fi

	[ -d "${_data}" ] && err 1 "${MAGENTA}Directory not empty or busy: ${_data}${NORMAL}"
	return 0
}


# unmount if mount
unmountdata()
{
	local _data

	[ -z "$1" ] && err 1 "unmountdata: no arguments"
	_data=$1

	[ ! -d "${_data}" ] && return 1

	zfsmnt ${_data}

	if [ $? -eq 1 ]; then
		/sbin/zfs unmount -f ${_data}
		rmdir ${_data}
	fi
}


create_fs()
{
	local data="${1}"

	[ -z "${data}" ] && return 0

	if [ "${zfsfeat}" = "1" ]; then
		create_zfs_fs -d ${data}
	elif [ "${hammerfeat}" = "1" ]; then
		create_hammer_fs ${jname}
	else
		[ ! -d ${data} ] && /bin/mkdir -p ${data}
	fi
}


# -d data
# -m mount_point, can be: none
# -n - jail_name
# -p promote fs ( 0 or 1 )
# -z zfs_snapsrc
create_zfs_fs()
{
	local _data _mount_point _name _promote _zfs_snapsrc

	while getopts "d:m:n:p:z:" opt; do
		case "$opt" in
			d) _data="${OPTARG}" ;;
			m) _mount_point="${OPTARG}" ;;
			n) _name="${OPTARG}" ;;
			p) _promote="${OPTARG}" ;;
			z) _zfs_snapsrc="${OPTARG}" ;;
		esac
		shift $(($OPTIND - 1))
	done

	local res

	[ -z "${_data}" ] && return 0
	[ -z "${_name}" ] && _name="${jname}"
	[ -n "${zfs_snapsrc}" ] && _zfs_snapsrc="${zfs_snapsrc}"
	[ -z "${_promote}" ] && _promote=0

	local ZPOOL

	ZPOOL=$( /sbin/zfs get -Ho value name ${jaildatadir} )

	if zfsroot ${_name}; then
		err 1 "create_zfs_fs: ${ZPOOL}/${_name} already in use"
	fi

	if [ -z "${_zfs_snapsrc}" ]; then
		res=$( /sbin/zfs create ${zfs_create_flags} -o mountpoint=${_data} ${ZPOOL}/${_name} 2>&1 )
		[ $? -ne 0 ] && err 1 "${MAGENTA}create_zfs_fs: zfs create failed: ${res}. No ZFS and zfsfeat=1?${NORMAL}"
	else
		# ${ECHO} "${MAGENTA}create_zfs_fs: create ${ZPOOL}${_data} from original: ${GREEN}${_zfs_snapsrc}${NORMAL}"
		/sbin/zfs clone -p ${_zfs_snapsrc} ${ZPOOL}/${_name}
		[ $? -ne 0 ] && err 1 "${MAGENTA}create_zfs_fs: zfs clone failed: ${res}${NORMAL}"

		if [ "${_mount_point}" != "none" ]; then
			if [ -n "${_mount_point}" ]; then
				/sbin/zfs set mountpoint=${_mount_point} ${ZPOOL}/${_name}
			else
				/sbin/zfs set mountpoint=${_data} ${ZPOOL}/${_name}
			fi
		fi
	fi

	if [ ${_promote} -eq 1 ]; then
		echo "zfs promote ${ZPOOL}/${_name}"
		zfs promote ${ZPOOL}/${_name}
	fi

}


#  create_hammer_fs jails
create_hammer_fs()
{
	[ -z "${1}" ] && return 1
	local dname="${1}"

	/sbin/hammer pfs-master ${jaildatadir}/${dname}-${jaildatapref}
}

#  destroy_hammer_fs jails
destroy_hammer_fs()
{
	[ -z "${1}" ] && return 1
	local dname="${1}"

	/sbin/hammer -y pfs-destroy ${jaildatadir}/${dname}-${jaildatapref}
}

###
fi