[ceph.git] / ceph / qa / workunits / rbd / rbd-nbd.sh

#!/usr/bin/env bash
set -ex

. $(dirname $0)/../../standalone/ceph-helpers.sh

POOL=rbd
ANOTHER_POOL=new_default_pool$$
NS=ns
IMAGE=testrbdnbd$$
SIZE=64
DATA=
DEV=

_sudo()
{
    local cmd

    if [ `id -u` -eq 0 ]
    then
	"$@"
	return $?
    fi

    # Look for the command in the user path. If it fails run it as is,
    # supposing it is in sudo path.
    cmd=`which $1 2>/dev/null` || cmd=$1
    shift
    sudo -nE "${cmd}" "$@"
}

setup()
{
    local ns x

    if [ -e CMakeCache.txt ]; then
	# running under cmake build dir

	CEPH_SRC=$(readlink -f $(dirname $0)/../../../src)
	CEPH_ROOT=${PWD}
	CEPH_BIN=${CEPH_ROOT}/bin

	export LD_LIBRARY_PATH=${CEPH_ROOT}/lib:${LD_LIBRARY_PATH}
	export PYTHONPATH=${PYTHONPATH}:${CEPH_SRC}/pybind:${CEPH_ROOT}/lib/cython_modules/lib.3
	PATH=${CEPH_BIN}:${PATH}
    fi

    _sudo echo test sudo

    trap cleanup INT TERM EXIT
    TEMPDIR=`mktemp -d`
    DATA=${TEMPDIR}/data
    dd if=/dev/urandom of=${DATA} bs=1M count=${SIZE}

    rbd namespace create ${POOL}/${NS}

    for ns in '' ${NS}; do
        rbd --dest-pool ${POOL} --dest-namespace "${ns}" --no-progress import \
            ${DATA} ${IMAGE}
    done

    # create another pool
    ceph osd pool create ${ANOTHER_POOL} 8
    rbd pool init ${ANOTHER_POOL}
}

function cleanup()
{
    local ns s

    set +e

    mount | fgrep ${TEMPDIR}/mnt && _sudo umount -f ${TEMPDIR}/mnt

    rm -Rf ${TEMPDIR}
    if [ -n "${DEV}" ]
    then
	_sudo rbd device --device-type nbd unmap ${DEV}
    fi

    for ns in '' ${NS}; do
        if rbd -p ${POOL} --namespace "${ns}" status ${IMAGE} 2>/dev/null; then
	    for s in 0.5 1 2 4 8 16 32; do
	        sleep $s
	        rbd -p ${POOL} --namespace "${ns}" status ${IMAGE} |
                    grep 'Watchers: none' && break
	    done
	    rbd -p ${POOL} --namespace "${ns}" snap purge ${IMAGE}
	    rbd -p ${POOL} --namespace "${ns}" remove ${IMAGE}
        fi
    done
    rbd namespace remove ${POOL}/${NS}

    # cleanup/reset default pool
    rbd config global rm global rbd_default_pool
    ceph osd pool delete ${ANOTHER_POOL} ${ANOTHER_POOL} --yes-i-really-really-mean-it
}

function expect_false()
{
  if "$@"; then return 1; else return 0; fi
}

function get_pid()
{
    local pool=$1
    local ns=$2

    PID=$(rbd device --device-type nbd --format xml list | $XMLSTARLET sel -t -v \
      "//devices/device[pool='${pool}'][namespace='${ns}'][image='${IMAGE}'][device='${DEV}']/id")
    test -n "${PID}" || return 1
    ps -p ${PID} -C rbd-nbd
}

unmap_device()
{
    local dev=$1
    local pid=$2

    _sudo rbd device --device-type nbd unmap ${dev}
    rbd device --device-type nbd list | expect_false grep "^${pid}\\b" || return 1
    ps -C rbd-nbd | expect_false grep "^ *${pid}\\b" || return 1

    # workaround possible race between unmap and following map
    sleep 0.5
}

#
# main
#

setup

# exit status test
expect_false rbd-nbd
expect_false rbd-nbd INVALIDCMD
if [ `id -u` -ne 0 ]
then
    expect_false rbd device --device-type nbd map ${IMAGE}
fi
expect_false _sudo rbd device --device-type nbd map INVALIDIMAGE
expect_false _sudo rbd-nbd --device INVALIDDEV map ${IMAGE}

# list format test
expect_false rbd device --device-type nbd --format INVALID list
rbd device --device-type nbd --format json --pretty-format list
rbd device --device-type nbd --format xml list

# map test using the first unused device
DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}`
get_pid ${POOL}
# map test specifying the device
expect_false _sudo rbd-nbd --device ${DEV} map ${POOL}/${IMAGE}
dev1=${DEV}
unmap_device ${DEV} ${PID}
DEV=
# XXX: race possible when the device is reused by other process
DEV=`_sudo rbd-nbd --device ${dev1} map ${POOL}/${IMAGE}`
[ "${DEV}" = "${dev1}" ]
rbd device --device-type nbd list | grep "${IMAGE}"
get_pid ${POOL}

# read test
[ "`dd if=${DATA} bs=1M | md5sum`" = "`_sudo dd if=${DEV} bs=1M | md5sum`" ]

# write test
dd if=/dev/urandom of=${DATA} bs=1M count=${SIZE}
_sudo dd if=${DATA} of=${DEV} bs=1M oflag=direct
[ "`dd if=${DATA} bs=1M | md5sum`" = "`rbd -p ${POOL} --no-progress export ${IMAGE} - | md5sum`" ]

# trim test
provisioned=`rbd -p ${POOL} --format xml du ${IMAGE} |
  $XMLSTARLET sel -t -m "//stats/images/image/provisioned_size" -v .`
used=`rbd -p ${POOL} --format xml du ${IMAGE} |
  $XMLSTARLET sel -t -m "//stats/images/image/used_size" -v .`
[ "${used}" -eq "${provisioned}" ]
_sudo mkfs.ext4 -E discard ${DEV} # better idea?
sync
provisioned=`rbd -p ${POOL} --format xml du ${IMAGE} |
  $XMLSTARLET sel -t -m "//stats/images/image/provisioned_size" -v .`
used=`rbd -p ${POOL} --format xml du ${IMAGE} |
  $XMLSTARLET sel -t -m "//stats/images/image/used_size" -v .`
[ "${used}" -lt "${provisioned}" ]

# resize test
devname=$(basename ${DEV})
blocks=$(awk -v dev=${devname} '$4 == dev {print $3}' /proc/partitions)
test -n "${blocks}"
rbd resize ${POOL}/${IMAGE} --size $((SIZE * 2))M
rbd info ${POOL}/${IMAGE}
blocks2=$(awk -v dev=${devname} '$4 == dev {print $3}' /proc/partitions)
test -n "${blocks2}"
test ${blocks2} -eq $((blocks * 2))
rbd resize ${POOL}/${IMAGE} --allow-shrink --size ${SIZE}M
blocks2=$(awk -v dev=${devname} '$4 == dev {print $3}' /proc/partitions)
test -n "${blocks2}"
test ${blocks2} -eq ${blocks}

# read-only option test
unmap_device ${DEV} ${PID}
DEV=`_sudo rbd --device-type nbd map --read-only ${POOL}/${IMAGE}`
PID=$(rbd device --device-type nbd list | awk -v pool=${POOL} -v img=${IMAGE} -v dev=${DEV} \
    '$2 == pool && $3 == img && $5 == dev {print $1}')
test -n "${PID}"
ps -p ${PID} -C rbd-nbd

_sudo dd if=${DEV} of=/dev/null bs=1M
expect_false _sudo dd if=${DATA} of=${DEV} bs=1M oflag=direct
unmap_device ${DEV} ${PID}

# exclusive option test
DEV=`_sudo rbd --device-type nbd map --exclusive ${POOL}/${IMAGE}`
get_pid ${POOL}

_sudo dd if=${DATA} of=${DEV} bs=1M oflag=direct
expect_false timeout 10 \
	rbd bench ${IMAGE} --io-type write --io-size=1024 --io-total=1024
unmap_device ${DEV} ${PID}
DEV=
rbd bench ${IMAGE} --io-type write --io-size=1024 --io-total=1024

# unmap by image name test
DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}`
get_pid ${POOL}
unmap_device ${IMAGE} ${PID}
DEV=

# map/unmap snap test
rbd snap create ${POOL}/${IMAGE}@snap
DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}@snap`
get_pid ${POOL}
unmap_device "${IMAGE}@snap" ${PID}
DEV=

# map/unmap namespace test
rbd snap create ${POOL}/${NS}/${IMAGE}@snap
DEV=`_sudo rbd device --device-type nbd map ${POOL}/${NS}/${IMAGE}@snap`
get_pid ${POOL} ${NS}
unmap_device "${POOL}/${NS}/${IMAGE}@snap" ${PID}
DEV=

# unmap by image name test 2
DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}`
get_pid ${POOL}
pid=$PID
DEV=`_sudo rbd device --device-type nbd map ${POOL}/${NS}/${IMAGE}`
get_pid ${POOL} ${NS}
unmap_device ${POOL}/${NS}/${IMAGE} ${PID}
DEV=
unmap_device ${POOL}/${IMAGE} ${pid}

# map/unmap test with just image name and expect image to come from default pool
if [ "${POOL}" = "rbd" ];then
    DEV=`_sudo rbd device --device-type nbd map ${IMAGE}`
    get_pid ${POOL}
    unmap_device ${IMAGE} ${PID}
    DEV=
fi

# map/unmap test with just image name after changing default pool
rbd config global set global rbd_default_pool ${ANOTHER_POOL}
rbd create --size 10M ${IMAGE}
DEV=`_sudo rbd device --device-type nbd map ${IMAGE}`
get_pid ${ANOTHER_POOL}
unmap_device ${IMAGE} ${PID}
DEV=

# reset
rbd config global rm global rbd_default_pool

# auto unmap test
DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}`
get_pid ${POOL}
_sudo kill ${PID}
for i in `seq 10`; do
  rbd device --device-type nbd list | expect_false grep "^${PID} *${POOL} *${IMAGE}" && break
  sleep 1
done
rbd device --device-type nbd list | expect_false grep "^${PID} *${POOL} *${IMAGE}"

# quiesce test
QUIESCE_HOOK=${TEMPDIR}/quiesce.sh
DEV=`_sudo rbd device --device-type nbd map --quiesce --quiesce-hook ${QUIESCE_HOOK} ${POOL}/${IMAGE}`
get_pid ${POOL}

# test it fails if the hook does not exists
test ! -e ${QUIESCE_HOOK}
expect_false rbd snap create ${POOL}/${IMAGE}@quiesce1
_sudo dd if=${DATA} of=${DEV} bs=1M count=1 oflag=direct

# test the hook is executed
touch ${QUIESCE_HOOK}
chmod +x ${QUIESCE_HOOK}
cat > ${QUIESCE_HOOK} <<EOF
#/bin/sh
echo "test the hook is executed" >&2
echo \$1 > ${TEMPDIR}/\$2
EOF
rbd snap create ${POOL}/${IMAGE}@quiesce1
_sudo dd if=${DATA} of=${DEV} bs=1M count=1 oflag=direct
test "$(cat ${TEMPDIR}/quiesce)" = ${DEV}
test "$(cat ${TEMPDIR}/unquiesce)" = ${DEV}

# test snap create fails if the hook fails
touch ${QUIESCE_HOOK}
chmod +x ${QUIESCE_HOOK}
cat > ${QUIESCE_HOOK} <<EOF
#/bin/sh
echo "test snap create fails if the hook fails" >&2
exit 22
EOF
expect_false rbd snap create ${POOL}/${IMAGE}@quiesce2
_sudo dd if=${DATA} of=${DEV} bs=1M count=1 oflag=direct

# test the hook is slow
cat > ${QUIESCE_HOOK} <<EOF
#/bin/sh
echo "test the hook is slow" >&2
sleep 7
EOF
rbd snap create ${POOL}/${IMAGE}@quiesce2
_sudo dd if=${DATA} of=${DEV} bs=1M count=1 oflag=direct

# test rbd-nbd_quiesce hook that comes with distribution
unmap_device ${DEV} ${PID}
LOG_FILE=${TEMPDIR}/rbd-nbd.log
if [ -n "${CEPH_SRC}" ]; then
    QUIESCE_HOOK=${CEPH_SRC}/tools/rbd_nbd/rbd-nbd_quiesce
    DEV=`_sudo rbd device --device-type nbd map --quiesce --quiesce-hook ${QUIESCE_HOOK} \
               ${POOL}/${IMAGE} --log-file=${LOG_FILE}`
else
    DEV=`_sudo rbd device --device-type nbd map --quiesce ${POOL}/${IMAGE} --log-file=${LOG_FILE}`
fi
get_pid ${POOL}
_sudo mkfs ${DEV}
mkdir ${TEMPDIR}/mnt
_sudo mount ${DEV} ${TEMPDIR}/mnt
rbd snap create ${POOL}/${IMAGE}@quiesce3
_sudo dd if=${DATA} of=${TEMPDIR}/mnt/test bs=1M count=1 oflag=direct
_sudo umount ${TEMPDIR}/mnt
unmap_device ${DEV} ${PID}
DEV=
cat ${LOG_FILE}
expect_false grep 'quiesce failed' ${LOG_FILE}

# test detach/attach
DEV=`_sudo rbd device --device-type nbd --options try-netlink map ${POOL}/${IMAGE}`
get_pid ${POOL}
_sudo mount ${DEV} ${TEMPDIR}/mnt
_sudo rbd-nbd detach ${POOL}/${IMAGE}
expect_false get_pid ${POOL}
_sudo rbd-nbd attach --device ${DEV} ${POOL}/${IMAGE}
get_pid ${POOL}
_sudo rbd-nbd detach ${DEV}
expect_false get_pid ${POOL}
_sudo rbd-nbd attach --device ${DEV} ${POOL}/${IMAGE}
get_pid ${POOL}
ls ${TEMPDIR}/mnt/
dd if=${TEMPDIR}/mnt/test of=/dev/null bs=1M count=1
_sudo dd if=${DATA} of=${TEMPDIR}/mnt/test1 bs=1M count=1 oflag=direct
_sudo umount ${TEMPDIR}/mnt
unmap_device ${DEV} ${PID}

echo OK
Commit	Line	Data
11fdf7f2 TL	1	#!/usr/bin/env bash
11fdf7f2 TL	2	set -ex
7c673cae	3
c07f9fc5	4	. $(dirname $0)/../../standalone/ceph-helpers.sh
7c673cae FG	5
7c673cae FG	6	POOL=rbd
522d829b	7	ANOTHER_POOL=new_default_pool$$
11fdf7f2	8	NS=ns
7c673cae FG	9	IMAGE=testrbdnbd$$
	10	SIZE=64
	11	DATA=
	12	DEV=
	13
	14	_sudo()
	15	{
	16	local cmd
	17
	18	if [ `id -u` -eq 0 ]
	19	then
	20	"$@"
	21	return $?
	22	fi
	23
	24	# Look for the command in the user path. If it fails run it as is,
	25	# supposing it is in sudo path.
	26	cmd=`which $1 2>/dev/null` \|\| cmd=$1
	27	shift
	28	sudo -nE "${cmd}" "$@"
	29	}
	30
	31	setup()
	32	{
11fdf7f2 TL	33	local ns x
11fdf7f2 TL	34
7c673cae FG	35	if [ -e CMakeCache.txt ]; then
	36	# running under cmake build dir
	37
	38	CEPH_SRC=$(readlink -f $(dirname $0)/../../../src)
	39	CEPH_ROOT=${PWD}
	40	CEPH_BIN=${CEPH_ROOT}/bin
	41
	42	export LD_LIBRARY_PATH=${CEPH_ROOT}/lib:${LD_LIBRARY_PATH}
9f95a23c	43	export PYTHONPATH=${PYTHONPATH}:${CEPH_SRC}/pybind:${CEPH_ROOT}/lib/cython_modules/lib.3
7c673cae FG	44	PATH=${CEPH_BIN}:${PATH}
	45	fi
	46
	47	_sudo echo test sudo
	48
	49	trap cleanup INT TERM EXIT
	50	TEMPDIR=`mktemp -d`
	51	DATA=${TEMPDIR}/data
	52	dd if=/dev/urandom of=${DATA} bs=1M count=${SIZE}
11fdf7f2 TL	53
	54	rbd namespace create ${POOL}/${NS}
	55
	56	for ns in '' ${NS}; do
	57	rbd --dest-pool ${POOL} --dest-namespace "${ns}" --no-progress import \
	58	${DATA} ${IMAGE}
	59	done
522d829b TL	60
	61	# create another pool
	62	ceph osd pool create ${ANOTHER_POOL} 8
	63	rbd pool init ${ANOTHER_POOL}
7c673cae FG	64	}
	65
	66	function cleanup()
	67	{
11fdf7f2 TL	68	local ns s
11fdf7f2 TL	69
7c673cae	70	set +e
f67539c2 TL	71
	72	mount \| fgrep ${TEMPDIR}/mnt && _sudo umount -f ${TEMPDIR}/mnt
	73
11fdf7f2	74	rm -Rf ${TEMPDIR}
7c673cae FG	75	if [ -n "${DEV}" ]
7c673cae FG	76	then
522d829b	77	_sudo rbd device --device-type nbd unmap ${DEV}
7c673cae	78	fi
11fdf7f2 TL	79
	80	for ns in '' ${NS}; do
	81	if rbd -p ${POOL} --namespace "${ns}" status ${IMAGE} 2>/dev/null; then
	82	for s in 0.5 1 2 4 8 16 32; do
	83	sleep $s
	84	rbd -p ${POOL} --namespace "${ns}" status ${IMAGE} \|
	85	grep 'Watchers: none' && break
	86	done
	87	rbd -p ${POOL} --namespace "${ns}" snap purge ${IMAGE}
	88	rbd -p ${POOL} --namespace "${ns}" remove ${IMAGE}
	89	fi
	90	done
	91	rbd namespace remove ${POOL}/${NS}
522d829b TL	92
	93	# cleanup/reset default pool
	94	rbd config global rm global rbd_default_pool
	95	ceph osd pool delete ${ANOTHER_POOL} ${ANOTHER_POOL} --yes-i-really-really-mean-it
7c673cae FG	96	}
	97
	98	function expect_false()
	99	{
	100	if "$@"; then return 1; else return 0; fi
	101	}
	102
11fdf7f2 TL	103	function get_pid()
11fdf7f2 TL	104	{
522d829b TL	105	local pool=$1
522d829b TL	106	local ns=$2
11fdf7f2	107
522d829b TL	108	PID=$(rbd device --device-type nbd --format xml list \| $XMLSTARLET sel -t -v \
522d829b TL	109	"//devices/device[pool='${pool}'][namespace='${ns}'][image='${IMAGE}'][device='${DEV}']/id")
f67539c2	110	test -n "${PID}" \|\| return 1
f91f0fd5	111	ps -p ${PID} -C rbd-nbd
11fdf7f2 TL	112	}
11fdf7f2 TL	113
81eedcae TL	114	unmap_device()
81eedcae TL	115	{
f91f0fd5 TL	116	local dev=$1
f91f0fd5 TL	117	local pid=$2
f67539c2	118
522d829b TL	119	_sudo rbd device --device-type nbd unmap ${dev}
522d829b TL	120	rbd device --device-type nbd list \| expect_false grep "^${pid}\\b" \|\| return 1
f67539c2	121	ps -C rbd-nbd \| expect_false grep "^ *${pid}\\b" \|\| return 1
81eedcae	122
f67539c2 TL	123	# workaround possible race between unmap and following map
f67539c2 TL	124	sleep 0.5
81eedcae TL	125	}
81eedcae TL	126
7c673cae FG	127	#
	128	# main
	129	#
	130
	131	setup
	132
	133	# exit status test
	134	expect_false rbd-nbd
	135	expect_false rbd-nbd INVALIDCMD
	136	if [ `id -u` -ne 0 ]
	137	then
522d829b	138	expect_false rbd device --device-type nbd map ${IMAGE}
7c673cae	139	fi
522d829b	140	expect_false _sudo rbd device --device-type nbd map INVALIDIMAGE
7c673cae FG	141	expect_false _sudo rbd-nbd --device INVALIDDEV map ${IMAGE}
7c673cae FG	142
11fdf7f2	143	# list format test
522d829b TL	144	expect_false rbd device --device-type nbd --format INVALID list
	145	rbd device --device-type nbd --format json --pretty-format list
	146	rbd device --device-type nbd --format xml list
11fdf7f2	147
7c673cae	148	# map test using the first unused device
522d829b TL	149	DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}`
522d829b TL	150	get_pid ${POOL}
7c673cae FG	151	# map test specifying the device
	152	expect_false _sudo rbd-nbd --device ${DEV} map ${POOL}/${IMAGE}
	153	dev1=${DEV}
f91f0fd5	154	unmap_device ${DEV} ${PID}
7c673cae FG	155	DEV=
	156	# XXX: race possible when the device is reused by other process
	157	DEV=`_sudo rbd-nbd --device ${dev1} map ${POOL}/${IMAGE}`
	158	[ "${DEV}" = "${dev1}" ]
522d829b TL	159	rbd device --device-type nbd list \| grep "${IMAGE}"
522d829b TL	160	get_pid ${POOL}
7c673cae FG	161
	162	# read test
	163	[ "`dd if=${DATA} bs=1M \| md5sum`" = "`_sudo dd if=${DEV} bs=1M \| md5sum`" ]
	164
	165	# write test
	166	dd if=/dev/urandom of=${DATA} bs=1M count=${SIZE}
	167	_sudo dd if=${DATA} of=${DEV} bs=1M oflag=direct
	168	[ "`dd if=${DATA} bs=1M \| md5sum`" = "`rbd -p ${POOL} --no-progress export ${IMAGE} - \| md5sum`" ]
	169
	170	# trim test
	171	provisioned=`rbd -p ${POOL} --format xml du ${IMAGE} \|
	172	$XMLSTARLET sel -t -m "//stats/images/image/provisioned_size" -v .`
	173	used=`rbd -p ${POOL} --format xml du ${IMAGE} \|
	174	$XMLSTARLET sel -t -m "//stats/images/image/used_size" -v .`
	175	[ "${used}" -eq "${provisioned}" ]
	176	_sudo mkfs.ext4 -E discard ${DEV} # better idea?
	177	sync
	178	provisioned=`rbd -p ${POOL} --format xml du ${IMAGE} \|
	179	$XMLSTARLET sel -t -m "//stats/images/image/provisioned_size" -v .`
	180	used=`rbd -p ${POOL} --format xml du ${IMAGE} \|
	181	$XMLSTARLET sel -t -m "//stats/images/image/used_size" -v .`
	182	[ "${used}" -lt "${provisioned}" ]
	183
	184	# resize test
	185	devname=$(basename ${DEV})
	186	blocks=$(awk -v dev=${devname} '$4 == dev {print $3}' /proc/partitions)
	187	test -n "${blocks}"
	188	rbd resize ${POOL}/${IMAGE} --size $((SIZE * 2))M
	189	rbd info ${POOL}/${IMAGE}
	190	blocks2=$(awk -v dev=${devname} '$4 == dev {print $3}' /proc/partitions)
	191	test -n "${blocks2}"
	192	test ${blocks2} -eq $((blocks * 2))
	193	rbd resize ${POOL}/${IMAGE} --allow-shrink --size ${SIZE}M
	194	blocks2=$(awk -v dev=${devname} '$4 == dev {print $3}' /proc/partitions)
	195	test -n "${blocks2}"
	196	test ${blocks2} -eq ${blocks}
	197
	198	# read-only option test
f91f0fd5	199	unmap_device ${DEV} ${PID}
522d829b TL	200	DEV=`_sudo rbd --device-type nbd map --read-only ${POOL}/${IMAGE}`
522d829b TL	201	PID=$(rbd device --device-type nbd list \| awk -v pool=${POOL} -v img=${IMAGE} -v dev=${DEV} \
31f18b77 FG	202	'$2 == pool && $3 == img && $5 == dev {print $1}')
31f18b77 FG	203	test -n "${PID}"
f91f0fd5	204	ps -p ${PID} -C rbd-nbd
31f18b77	205
7c673cae FG	206	_sudo dd if=${DEV} of=/dev/null bs=1M
7c673cae FG	207	expect_false _sudo dd if=${DATA} of=${DEV} bs=1M oflag=direct
f91f0fd5	208	unmap_device ${DEV} ${PID}
7c673cae FG	209
7c673cae FG	210	# exclusive option test
522d829b TL	211	DEV=`_sudo rbd --device-type nbd map --exclusive ${POOL}/${IMAGE}`
522d829b TL	212	get_pid ${POOL}
31f18b77	213
7c673cae FG	214	_sudo dd if=${DATA} of=${DEV} bs=1M oflag=direct
	215	expect_false timeout 10 \
	216	rbd bench ${IMAGE} --io-type write --io-size=1024 --io-total=1024
f91f0fd5	217	unmap_device ${DEV} ${PID}
11fdf7f2 TL	218	DEV=
	219	rbd bench ${IMAGE} --io-type write --io-size=1024 --io-total=1024
	220
	221	# unmap by image name test
522d829b TL	222	DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}`
522d829b TL	223	get_pid ${POOL}
f91f0fd5	224	unmap_device ${IMAGE} ${PID}
11fdf7f2	225	DEV=
11fdf7f2 TL	226
	227	# map/unmap snap test
	228	rbd snap create ${POOL}/${IMAGE}@snap
522d829b TL	229	DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}@snap`
522d829b TL	230	get_pid ${POOL}
f91f0fd5	231	unmap_device "${IMAGE}@snap" ${PID}
11fdf7f2	232	DEV=
11fdf7f2 TL	233
	234	# map/unmap namespace test
	235	rbd snap create ${POOL}/${NS}/${IMAGE}@snap
522d829b TL	236	DEV=`_sudo rbd device --device-type nbd map ${POOL}/${NS}/${IMAGE}@snap`
522d829b TL	237	get_pid ${POOL} ${NS}
f91f0fd5	238	unmap_device "${POOL}/${NS}/${IMAGE}@snap" ${PID}
11fdf7f2	239	DEV=
f91f0fd5 TL	240
f91f0fd5 TL	241	# unmap by image name test 2
522d829b TL	242	DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}`
522d829b TL	243	get_pid ${POOL}
f91f0fd5	244	pid=$PID
522d829b TL	245	DEV=`_sudo rbd device --device-type nbd map ${POOL}/${NS}/${IMAGE}`
522d829b TL	246	get_pid ${POOL} ${NS}
f91f0fd5 TL	247	unmap_device ${POOL}/${NS}/${IMAGE} ${PID}
	248	DEV=
	249	unmap_device ${POOL}/${IMAGE} ${pid}
31f18b77	250
522d829b TL	251	# map/unmap test with just image name and expect image to come from default pool
	252	if [ "${POOL}" = "rbd" ];then
	253	DEV=`_sudo rbd device --device-type nbd map ${IMAGE}`
	254	get_pid ${POOL}
	255	unmap_device ${IMAGE} ${PID}
	256	DEV=
	257	fi
	258
	259	# map/unmap test with just image name after changing default pool
	260	rbd config global set global rbd_default_pool ${ANOTHER_POOL}
	261	rbd create --size 10M ${IMAGE}
	262	DEV=`_sudo rbd device --device-type nbd map ${IMAGE}`
	263	get_pid ${ANOTHER_POOL}
	264	unmap_device ${IMAGE} ${PID}
	265	DEV=
	266
	267	# reset
	268	rbd config global rm global rbd_default_pool
	269
31f18b77	270	# auto unmap test
522d829b TL	271	DEV=`_sudo rbd device --device-type nbd map ${POOL}/${IMAGE}`
522d829b TL	272	get_pid ${POOL}
31f18b77 FG	273	_sudo kill ${PID}
31f18b77 FG	274	for i in `seq 10`; do
522d829b	275	rbd device --device-type nbd list \| expect_false grep "^${PID} ${POOL} ${IMAGE}" && break
31f18b77 FG	276	sleep 1
31f18b77 FG	277	done
522d829b	278	rbd device --device-type nbd list \| expect_false grep "^${PID} ${POOL} ${IMAGE}"
31f18b77	279
f67539c2 TL	280	# quiesce test
f67539c2 TL	281	QUIESCE_HOOK=${TEMPDIR}/quiesce.sh
522d829b TL	282	DEV=`_sudo rbd device --device-type nbd map --quiesce --quiesce-hook ${QUIESCE_HOOK} ${POOL}/${IMAGE}`
522d829b TL	283	get_pid ${POOL}
f67539c2 TL	284
	285	# test it fails if the hook does not exists
	286	test ! -e ${QUIESCE_HOOK}
	287	expect_false rbd snap create ${POOL}/${IMAGE}@quiesce1
	288	_sudo dd if=${DATA} of=${DEV} bs=1M count=1 oflag=direct
	289
	290	# test the hook is executed
	291	touch ${QUIESCE_HOOK}
	292	chmod +x ${QUIESCE_HOOK}
	293	cat > ${QUIESCE_HOOK} <<EOF
	294	#/bin/sh
	295	echo "test the hook is executed" >&2
	296	echo \$1 > ${TEMPDIR}/\$2
	297	EOF
	298	rbd snap create ${POOL}/${IMAGE}@quiesce1
	299	_sudo dd if=${DATA} of=${DEV} bs=1M count=1 oflag=direct
	300	test "$(cat ${TEMPDIR}/quiesce)" = ${DEV}
	301	test "$(cat ${TEMPDIR}/unquiesce)" = ${DEV}
	302
	303	# test snap create fails if the hook fails
	304	touch ${QUIESCE_HOOK}
	305	chmod +x ${QUIESCE_HOOK}
	306	cat > ${QUIESCE_HOOK} <<EOF
	307	#/bin/sh
	308	echo "test snap create fails if the hook fails" >&2
	309	exit 22
	310	EOF
	311	expect_false rbd snap create ${POOL}/${IMAGE}@quiesce2
	312	_sudo dd if=${DATA} of=${DEV} bs=1M count=1 oflag=direct
	313
	314	# test the hook is slow
	315	cat > ${QUIESCE_HOOK} <<EOF
	316	#/bin/sh
	317	echo "test the hook is slow" >&2
	318	sleep 7
	319	EOF
	320	rbd snap create ${POOL}/${IMAGE}@quiesce2
	321	_sudo dd if=${DATA} of=${DEV} bs=1M count=1 oflag=direct
	322
	323	# test rbd-nbd_quiesce hook that comes with distribution
	324	unmap_device ${DEV} ${PID}
	325	LOG_FILE=${TEMPDIR}/rbd-nbd.log
	326	if [ -n "${CEPH_SRC}" ]; then
	327	QUIESCE_HOOK=${CEPH_SRC}/tools/rbd_nbd/rbd-nbd_quiesce
522d829b	328	DEV=`_sudo rbd device --device-type nbd map --quiesce --quiesce-hook ${QUIESCE_HOOK} \
f67539c2 TL	329	${POOL}/${IMAGE} --log-file=${LOG_FILE}`
f67539c2 TL	330	else
522d829b	331	DEV=`_sudo rbd device --device-type nbd map --quiesce ${POOL}/${IMAGE} --log-file=${LOG_FILE}`
f67539c2	332	fi
522d829b	333	get_pid ${POOL}
f67539c2 TL	334	_sudo mkfs ${DEV}
	335	mkdir ${TEMPDIR}/mnt
	336	_sudo mount ${DEV} ${TEMPDIR}/mnt
	337	rbd snap create ${POOL}/${IMAGE}@quiesce3
	338	_sudo dd if=${DATA} of=${TEMPDIR}/mnt/test bs=1M count=1 oflag=direct
	339	_sudo umount ${TEMPDIR}/mnt
	340	unmap_device ${DEV} ${PID}
	341	DEV=
	342	cat ${LOG_FILE}
	343	expect_false grep 'quiesce failed' ${LOG_FILE}
	344
	345	# test detach/attach
522d829b TL	346	DEV=`_sudo rbd device --device-type nbd --options try-netlink map ${POOL}/${IMAGE}`
522d829b TL	347	get_pid ${POOL}
f67539c2 TL	348	_sudo mount ${DEV} ${TEMPDIR}/mnt
f67539c2 TL	349	_sudo rbd-nbd detach ${POOL}/${IMAGE}
522d829b	350	expect_false get_pid ${POOL}
f67539c2	351	_sudo rbd-nbd attach --device ${DEV} ${POOL}/${IMAGE}
522d829b	352	get_pid ${POOL}
f67539c2	353	_sudo rbd-nbd detach ${DEV}
522d829b	354	expect_false get_pid ${POOL}
f67539c2	355	_sudo rbd-nbd attach --device ${DEV} ${POOL}/${IMAGE}
522d829b	356	get_pid ${POOL}
f67539c2 TL	357	ls ${TEMPDIR}/mnt/
	358	dd if=${TEMPDIR}/mnt/test of=/dev/null bs=1M count=1
	359	_sudo dd if=${DATA} of=${TEMPDIR}/mnt/test1 bs=1M count=1 oflag=direct
	360	_sudo umount ${TEMPDIR}/mnt
	361	unmap_device ${DEV} ${PID}
	362
7c673cae	363	echo OK