test/lvol: rewrite snapshot_during_io_traffic to bash (67609312) · Commits · Public Repositories / spdk

test/lvol/common.sh

+17 −0

Original line number	Diff line number	Diff line
		@@ -26,3 +26,20 @@ function round_down() {
		fi
		echo $(( $1 / CLUSTER_SIZE_MB * CLUSTER_SIZE_MB ))
		}

		function run_fio_test() {
		local file=$1
		local offset=$2
		local size=$3
		local rw=$4
		local pattern=$5
		local extra_params=$6

		local pattern_template="" fio_template=""
		if [[ -n "$pattern" ]]; then
		pattern_template="--do_verify=1 --verify=pattern --verify_pattern=$pattern --verify_state_save=0"
		fi

		fio_template="fio --name=fio_test --filename=$file --offset=$offset --size=$size --rw=$rw --direct=1 $extra_params $pattern_template"
		$fio_template
		}

test/lvol/lvol.sh

+0 −1

Original line number	Diff line number	Diff line
		@@ -35,7 +35,6 @@ function usage() {
		653: 'thin_provisioning_resize',
		654: 'thin_overprovisioning',
		655: 'thin_provisioning_filling_disks_less_than_lvs_size',
		752: 'snapshot_during_io_traffic',
		753: 'snapshot_of_snapshot',
		754: 'clone_bdev_only',
		755: 'clone_writing_clone',

test/lvol/snapshot_clone.sh

+35 −0

Original line number	Diff line number	Diff line
		@@ -78,6 +78,40 @@ function test_snapshot_compare_with_lvol_bdev() {
		}


		# Check that when writing to lvol bdev
		# creating snapshot ends with success
		function test_create_snapshot_with_io() {
		malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)
		lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)

		# Create lvol bdev
		lvol_size_mb=$( round_down $(( LVS_DEFAULT_CAPACITY_MB / 2 )) )
		lvol_size=$(( lvol_size_mb * 1024 * 1024 ))

		lvol_uuid=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test "$lvol_size_mb" -t)

		# Run fio in background that writes to lvol bdev
		nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
		run_fio_test /dev/nbd0 0 $lvol_size "write" "0xcc" "--time_based --runtime=16" &
		fio_proc=$!
		sleep 4
		# Create snapshot of lvol bdev
		snapshot_uuid=$(rpc_cmd bdev_lvol_snapshot lvs_test/lvol_test lvol_snapshot)
		wait $fio_proc

		# Clean up
		nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
		rpc_cmd bdev_lvol_delete "$lvol_uuid"
		rpc_cmd bdev_get_bdevs -b "$lvol_uuid" && false
		rpc_cmd bdev_lvol_delete "$snapshot_uuid"
		rpc_cmd bdev_get_bdevs -b "$snapshot_uuid" && false
		rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
		rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid" && false
		rpc_cmd bdev_malloc_delete "$malloc_name"
		check_leftover_devices
		}


		$rootdir/app/spdk_tgt/spdk_tgt &
		spdk_pid=$!
		trap 'killprocess "$spdk_pid"; exit 1' SIGINT SIGTERM EXIT
		@@ -85,6 +119,7 @@ waitforlisten $spdk_pid
		modprobe nbd

		run_test "test_snapshot_compare_with_lvol_bdev" test_snapshot_compare_with_lvol_bdev
		run_test "test_create_snapshot_with_io" test_create_snapshot_with_io

		trap - SIGINT SIGTERM EXIT
		killprocess $spdk_pid

test/lvol/test_cases.py

+0 −58

Original line number	Diff line number	Diff line
		@@ -126,7 +126,6 @@ def case_message(func):
		654: 'thin_overprovisioning',
		655: 'thin_provisioning_filling_disks_less_than_lvs_size',
		# snapshot and clone
		752: 'snapshot_during_io_traffic',
		753: 'snapshot_of_snapshot',
		754: 'clone_bdev_only',
		755: 'clone_writing_clone',
		@@ -986,63 +985,6 @@ class TestCases(object):
		# - no other operation fails
		return fail_count

		@case_message
		def test_case752(self):
		"""
		snapshot_during_io_traffic

		Check that when writing to lvol bdev
		creating snapshot ends with success
		"""
		global current_fio_pid
		fail_count = 0
		nbd_name = "/dev/nbd0"
		snapshot_name = "snapshot"
		# Create malloc bdev
		base_name = self.c.bdev_malloc_create(self.total_size,
		self.block_size)
		# Construct lvol store
		uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
		self.lvs_name)
		fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
		self.cluster_size)
		# Create thin provisioned lvol bdev with size equal to 50% of lvs space
		size = self.get_lvs_divided_size(2)
		uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name,
		size, thin=True)

		lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)
		fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name)
		fill_size = int(size * MEGABYTE)
		# Create thread that will run fio in background
		thread = FioThread(nbd_name, 0, fill_size, "write", "0xcc", 0,
		extra_params="--time_based --runtime=8")
		# Perform write operation with verification to created lvol bdev
		thread.start()
		time.sleep(4)
		fail_count += is_process_alive(current_fio_pid)
		# During write operation create snapshot of created lvol bdev
		# and check that snapshot has been created successfully
		fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name)
		fail_count += is_process_alive(current_fio_pid)
		thread.join()
		# Check that write operation ended with success
		fail_count += thread.rv
		fail_count += self.c.nbd_stop_disk(nbd_name)
		# Destroy lvol bdev
		fail_count += self.c.bdev_lvol_delete(lvol_bdev['name'])
		# Delete snapshot
		fail_count += self.c.bdev_lvol_delete(self.lvs_name + "/" + snapshot_name)
		# Destroy lvol store
		fail_count += self.c.bdev_lvol_delete_lvstore(uuid_store)
		# Delete malloc bdevs
		fail_count += self.c.bdev_malloc_delete(base_name)

		# Expected result:
		# - calls successful, return code = 0
		# - no other operation fails
		return fail_count

		@case_message
		def test_case753(self):
		"""