Commit 7d0cd374 authored by Pawel Kaminski's avatar Pawel Kaminski Committed by Tomasz Zawadzki
Browse files

test/lvol: rewrite thin_provisioning_read_empty_bdev to bash 



Change-Id: Id4609dbd3ac196dca13395007831b11e01af70b9
Signed-off-by: default avatarPawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/704


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarDarek Stojaczyk <dariusz.stojaczyk@intel.com>
Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: default avatarMichal Berger <michalx.berger@intel.com>
parent 9f133b1b

test/lvol/lvol.sh

+0 −1
Original line number Diff line number Diff line
@@ -29,7 +29,6 @@ function usage() { 
                                    552: 'bdev_lvol_delete_lvstore_with_clones',

                                    553: 'unregister_lvol_bdev',

                                    602: 'bdev_lvol_create_lvstore_with_all_clear_methods',

                                    651: 'thin_provisioning_read_empty_bdev',

                                    652: 'thin_provisioning_data_integrity_test',

                                    653: 'thin_provisioning_resize',

                                    654: 'thin_overprovisioning',

test/lvol/test_cases.py

+0 −59
Original line number Diff line number Diff line
@@ -119,7 +119,6 @@ def case_message(func): 
            553: 'unregister_lvol_bdev',

            602: 'bdev_lvol_create_lvstore_with_all_clear_methods',

            # Provisioning

            651: 'thin_provisioning_read_empty_bdev',

            652: 'thin_provisioning_data_integrity_test',

            653: 'thin_provisioning_resize',

            654: 'thin_overprovisioning',
@@ -582,64 +581,6 @@ class TestCases(object): 
        # - Error code response printed to stdout

        return fail_count



    def test_case651(self):

        """

        thin_provisioning_read_empty_bdev



        Check if we can create thin provisioned bdev on empty lvol store

        and check if we can read from this device and it returns zeroes.

        """

        # create malloc bdev

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

                                              self.block_size)

        # construct lvol store on malloc bdev

        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)

        lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]

        free_clusters_start = int(lvs['free_clusters'])

        lbd_name0 = self.lbd_name + str("0")

        lbd_name1 = self.lbd_name + str("1")

        # calculate bdev size in megabytes

        bdev_size = self.get_lvs_size()

        # create thick provisioned lvol bvdev with size equal to lvol store

        bdev_name0 = self.c.bdev_lvol_create(uuid_store, lbd_name0,

                                             bdev_size, thin=False)

        # create thin provisioned lvol bdev with the same size

        bdev_name1 = self.c.bdev_lvol_create(uuid_store, lbd_name1,

                                             bdev_size, thin=True)

        lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0)

        lvol_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1)

        nbd_name0 = "/dev/nbd0"

        fail_count += self.c.nbd_start_disk(lvol_bdev0['name'], nbd_name0)

        nbd_name1 = "/dev/nbd1"

        fail_count += self.c.nbd_start_disk(lvol_bdev1['name'], nbd_name1)



        size = bdev_size * MEGABYTE

        # fill the whole thick provisioned lvol bdev

        fail_count += self.run_fio_test(nbd_name0, 0, size, "write", False)



        size = bdev_size * MEGABYTE

        # perform read operations on thin provisioned lvol bdev

        # and check if they return zeroes

        fail_count += self.run_fio_test(nbd_name1, 0, size, "read", "0x00")



        fail_count += self.c.nbd_stop_disk(nbd_name0)

        fail_count += self.c.nbd_stop_disk(nbd_name1)

        # destroy thin provisioned lvol bdev

        fail_count += self.c.bdev_lvol_delete(lvol_bdev0['name'])

        fail_count += self.c.bdev_lvol_delete(lvol_bdev1['name'])

        # destroy lvol store

        fail_count += self.c.bdev_lvol_delete_lvstore(uuid_store)

        # destroy malloc bdev

        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_case652(self):

        """

        thin_provisioning_data_integrity_test

test/lvol/thin_provisioning.sh

+38 −0
Original line number Diff line number Diff line
@@ -60,12 +60,50 @@ function test_thin_lvol_check_space() { 
	rpc_cmd bdev_malloc_delete "$malloc_name"

}



# Check if we can create thin provisioned bdev on empty lvol store

# and check if we can read from this device and it returns zeroes.

function test_thin_lvol_check_zeroes() {

	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)

	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)

	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")

	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"



	# Create thick and thin provisioned lvol bdevs with size equals to lvol store space

	lbd_name0=lvol_test0

	lbd_name1=lvol_test1

	lvol_size_mb=$(( LVS_DEFAULT_CAPACITY_MB ))

	# Round down lvol size to the nearest cluster size boundary

	lvol_size_mb=$(( lvol_size_mb / LVS_DEFAULT_CLUSTER_SIZE_MB * LVS_DEFAULT_CLUSTER_SIZE_MB ))

	lvol_size=$(( lvol_size_mb * 1024 * 1024 ))

	lvol_uuid0=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" $lbd_name0 "$lvol_size_mb")

	lvol_uuid1=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" $lbd_name1 "$lvol_size_mb" -t)



	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid0" /dev/nbd0

	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid1" /dev/nbd1



	# Fill the whole thick provisioned lvol bdev

	run_fio_test /dev/nbd0 0 $lvol_size "write" "0xcc"



	# Perform read operations on thin provisioned lvol bdev

	# and check if they return zeroes

	run_fio_test /dev/nbd1 0 $lvol_size "read" "0x00"



	# Clean up

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd1

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0

	rpc_cmd bdev_lvol_delete "$lvol_uuid1"

	rpc_cmd bdev_lvol_delete "$lvol_uuid0"

	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"

	rpc_cmd bdev_malloc_delete "$malloc_name"

}



$rootdir/app/spdk_tgt/spdk_tgt &

spdk_pid=$!

trap 'killprocess "$spdk_pid"; exit 1' SIGINT SIGTERM EXIT

waitforlisten $spdk_pid



run_test "test_thin_lvol_check_space" test_thin_lvol_check_space

run_test "test_thin_lvol_check_zeroes" test_thin_lvol_check_zeroes



trap - SIGINT SIGTERM EXIT

killprocess $spdk_pid