Commit 12ded5af authored by Michal Berger's avatar Michal Berger Committed by Tomasz Zawadzki
Browse files

test/lvol: Rewrite destroy_resize_logical_volume_positive to Bash 



This test covers several instances of bdev resizing (test case
no. 254).

Change-Id: I31cd2d807a19e0452801ffe4721b8c154daa204b
Signed-off-by: default avatarMichal Berger <michalx.berger@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/779


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Community-CI: Broadcom CI
Reviewed-by: default avatarDarek Stojaczyk <dariusz.stojaczyk@intel.com>
Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
parent d3f661cf

test/lvol/lvol.sh

+0 −1
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ function usage() { 
    echo "    --block-size          Block size for this bdev"

    echo "-x                        set -x for script debug"

    echo "    --test-cases=         List test cases which will be run:

                                    254: 'destroy_after_bdev_lvol_resize_positive',

                                    255: 'delete_lvol_store_persistent_positive',

                                    350: 'nested_destroy_logical_volume_negative',

                                    400: 'nested_construct_logical_volume_positive',

test/lvol/resize.sh

+51 −0
Original line number Diff line number Diff line
@@ -154,6 +154,56 @@ function test_resize_lvol_with_io_traffic() { 
	rpc_cmd bdev_malloc_delete "$malloc_name"

}



# Positive test for destroying a logical_volume after resizing.

# Call bdev_lvol_delete_lvstore with correct logical_volumes name.

function test_destroy_after_bdev_lvol_resize_positive() {

	local malloc_dev

	local lvstore_name=lvs_test lvstore_uuid

	local lbd_name=lbd_test bdev_uuid bdev_size



	malloc_dev=$(rpc_cmd bdev_malloc_create 256 "$MALLOC_BS")

	lvstore_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_dev" "$lvstore_name")



	get_lvs_jq bdev_lvol_get_lvstores -u "$lvstore_uuid"

	[[ ${jq_out["uuid"]} == "$lvstore_uuid" ]]

	[[ ${jq_out["name"]} == "$lvstore_name" ]]



	bdev_size=$(round_down $(( LVS_DEFAULT_CAPACITY_MB / 4 )))

	bdev_uuid=$(rpc_cmd bdev_lvol_create -u "$lvstore_uuid" "$lbd_name" "$bdev_size")



	# start resizing in the following fashion:

	# - size is equal to one quarter of size malloc bdev plus 4 MB

	# - size is equal half of size malloc bdev

	# - size is equal to three quarters of size malloc bdev

	# - size is equal to size if malloc bdev minus 4 MB

	# - size is equal 0 MiB

	local resize

	for resize in \

	  "$bdev_size" \

	  $(( bdev_size + 4 )) \

	  $(( bdev_size * 2 )) \

	  $(( bdev_size * 3 )) \

	  $(( bdev_size * 4 - 4 )) \

	  0; do

		resize=$(round_down $(( resize / 4 )))

		rpc_cmd bdev_lvol_resize "$bdev_uuid" "$resize"



		get_bdev_jq bdev_get_bdevs -b "$bdev_uuid"

		[[ ${jq_out["name"]} == "$bdev_uuid" ]]

		[[ ${jq_out["name"]} == "${jq_out["uuid"]}" ]]

		(( jq_out["block_size"] == MALLOC_BS ))

		(( jq_out["num_blocks"] * jq_out["block_size"] == resize * 1024**2 ))

	done



	# cleanup

	rpc_cmd bdev_lvol_delete "$bdev_uuid"

	rpc_cmd bdev_lvol_delete_lvstore -u "$lvstore_uuid"

	rpc_cmd bdev_get_bdevs -b "$bdev_uuid" && false

	rpc_cmd bdev_lvol_get_lvstores -u "$lvstore_uuid" && false

	rpc_cmd bdev_malloc_delete "$malloc_dev"

	check_leftover_devices

}



modprobe nbd

$rootdir/app/spdk_tgt/spdk_tgt &

spdk_pid=$!
@@ -163,6 +213,7 @@ waitforlisten $spdk_pid 
run_test "test_resize_lvol" test_resize_lvol

run_test "test_resize_lvol_negative" test_resize_lvol_negative

run_test "test_resize_lvol_with_io_traffic" test_resize_lvol_with_io_traffic

run_test "test_destroy_after_bdev_lvol_resize_positive" test_destroy_after_bdev_lvol_resize_positive



trap - SIGINT SIGTERM EXIT

killprocess $spdk_pid

test/lvol/test_cases.py

+0 −69
Original line number Diff line number Diff line
@@ -112,7 +112,6 @@ def case_message(func): 
    def inner(*args, **kwargs):

        test_name = {

            # bdev_lvol_delete_lvstore - positive tests

            254: 'destroy_after_bdev_lvol_resize_positive',

            255: 'delete_lvol_store_persistent_positive',

            551: 'delete_lvol_bdev',

            552: 'bdev_lvol_delete_lvstore_with_clones',
@@ -252,74 +251,6 @@ class TestCases(object): 
        lvs = self.c.bdev_lvol_get_lvstores(lvs_name)[0]

        return int(int(lvs['cluster_size']) / MEGABYTE)



    @case_message

    def test_case254(self):

        """

        destroy_resize_logical_volume_positive



        Positive test for destroying a logical_volume after resizing.

        Call bdev_lvol_delete_lvstore with correct logical_volumes name.

        """

        # Create malloc bdev

        base_name = self.c.bdev_malloc_create(self.total_size,

                                              self.block_size)

        # Construct lvol store on create malloc bdev

        uuid_store = self.c.bdev_lvol_create_lvstore(base_name,

                                                     self.lvs_name)

        # Check correct uuid values in response bdev_lvol_get_lvstores command

        fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,

                                                         self.cluster_size)

        size = self.get_lvs_divided_size(4)

        # bdev_lvol_create on correct lvs_uuid and size is

        # equal to one quarter of size malloc bdev

        uuid_bdev = self.c.bdev_lvol_create(uuid_store,

                                            self.lbd_name,

                                            size)

        # check size of the lvol bdev

        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, size)

        sz = size + 4

        # Resize_lvol_bdev on correct lvs_uuid and size is

        # equal to one quarter of size malloc bdev plus 4 MB

        self.c.bdev_lvol_resize(uuid_bdev, sz)

        # check size of the lvol bdev by command RPC : bdev_get_bdevs

        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)

        # Resize_lvol_bdev on correct lvs_uuid and size is

        # equal half of size malloc bdev

        sz = size * 2

        self.c.bdev_lvol_resize(uuid_bdev, sz)

        # check size of the lvol bdev by command RPC : bdev_get_bdevs

        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)

        # Resize_lvol_bdev on correct lvs_uuid and size is

        # equal to three quarters of size malloc bdev

        sz = size * 3

        self.c.bdev_lvol_resize(uuid_bdev, sz)

        # check size of the lvol bdev by command RPC : bdev_get_bdevs

        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)

        # Resize_lvol_bdev on correct lvs_uuid and size is

        # equal to size if malloc bdev minus 4 MB

        sz = (size * 4) - 4

        self.c.bdev_lvol_resize(uuid_bdev, sz)

        # check size of the lvol bdev by command RPC : bdev_get_bdevs

        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)

        # Resize_lvol_bdev on the correct lvs_uuid and size is equal 0 MiB

        sz = 0

        self.c.bdev_lvol_resize(uuid_bdev, sz)

        # check size of the lvol bdev by command RPC : bdev_get_bdevs

        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)



        # Destroy lvol store

        self.c.bdev_lvol_delete_lvstore(uuid_store)

        if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:

            fail_count += 1

        self.c.bdev_malloc_delete(base_name)



        # Expected result:

        # - lvol bdev should change size after resize operations

        # - calls successful, return code = 0

        # - no other operation fails

        # - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store

        return fail_count



    @case_message

    def test_case255(self):

        """