ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test/vhost: Move thin provisioning test plan into test implementation

Browse Source 
Change-Id: I507d670afd839aede737d553432202a33a920c06
Signed-off-by: Pawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.gerrithub.io/403036
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
This commit is contained in:
Pawel Kaminski 2018-03-07 10:43:01 -05:00 committed by Jim Harris
parent 13a05f59cc
commit bbe53581bd
2 changed files with 126 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
test/lvol/test_cases.py
View File

@ -699,8 +699,16 @@ class TestCases(object):
@case_message
def test_case650(self):
"""
thin_provisioning_check_space
Check if free clusters number on lvol store decreases
if we write to created thin provisioned lvol bdev
"""
# create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
# create lvol store on mamloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name,
self.cluster_size)
@ -709,10 +717,12 @@ class TestCases(object):
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
free_clusters_start = int(lvs['free_clusters'])
bdev_size = int(lvs['cluster_size']) * int(lvs['free_clusters']) / MEGABYTE
# create thin provisioned lvol bdev with size equals to lvol store free space
bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name,
bdev_size, thin=True)
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
free_clusters_create_lvol = int(lvs[u'free_clusters'])
# check and save number of free clusters for lvol store
if free_clusters_start != free_clusters_create_lvol:
fail_count += 1
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
@ -720,9 +730,11 @@ class TestCases(object):
fail_count += self.c.start_nbd_disk(bdev_name, nbd_name)
size = int(lvs['cluster_size'])
# write data (lvs cluster size) to created lvol bdev starting from offset 0.
fail_count += self.run_fio_test("/dev/nbd0", 0, size, "write", "0xcc")
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
free_clusters_first_fio = int(lvs[u'free_clusters'])
# check that free clusters on lvol store was decremented by 1
if free_clusters_start != free_clusters_first_fio + 1:
fail_count += 1
@ -730,34 +742,53 @@ class TestCases(object):
# calculate size of one and half cluster
offset = int((int(lvol_bdev['num_blocks']) * int(lvol_bdev['block_size']) /
free_clusters_create_lvol) * 1.5)
# write data (lvs cluster size) to lvol bdev with offset set to one and half of cluster size
fail_count += self.run_fio_test(nbd_name, offset, size, "write", "0xcc")
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
free_clusters_second_fio = int(lvs[u'free_clusters'])
# check that free clusters on lvol store was decremented by 2
if free_clusters_start != free_clusters_second_fio + 3:
fail_count += 1
size = (free_clusters_create_lvol - 3) * int(lvs['cluster_size'])
offset = int(int(lvol_bdev['num_blocks']) * int(lvol_bdev['block_size']) /
free_clusters_create_lvol * 3)
# write data to lvol bdev to the end of its size
fail_count += self.run_fio_test(nbd_name, offset, size, "write", "0xcc")
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
free_clusters_third_fio = int(lvs[u'free_clusters'])
# check that lvol store free clusters number equals to 0
if free_clusters_third_fio != 0:
fail_count += 1
fail_count += self.c.stop_nbd_disk(nbd_name)
# destroy thin provisioned lvol bdev
fail_count += self.c.delete_bdev(lvol_bdev['name'])
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
free_clusters_end = int(lvs[u'free_clusters'])
# check that saved number of free clusters equals to current free clusters
if free_clusters_start != free_clusters_end:
fail_count += 1
# destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# destroy malloc bdev
# Expected result:
# - calls successful, return code = 0
# - no other operation fails
return fail_count
@case_message
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.construct_malloc_bdev(self.total_size,
self.block_size)
# construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name,
self.cluster_size)
@ -769,8 +800,10 @@ class TestCases(object):
lbd_name1 = self.lbd_name + str("1")
# calculate bdev size in megabytes
bdev_size = int(lvs['cluster_size']) * int(lvs['free_clusters']) / MEGABYTE
# create thick provisioned lvol bvdev with size equal to lvol store
bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0,
bdev_size, thin=False)
# create thin provisioned lvol bdev with the same size
bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1,
bdev_size, thin=True)
lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0)
@ -781,22 +814,39 @@ class TestCases(object):
fail_count += self.c.start_nbd_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.stop_nbd_disk(nbd_name0)
fail_count += self.c.stop_nbd_disk(nbd_name1)
# destroy thin provisioned lvol bdev
fail_count += self.c.delete_bdev(lvol_bdev0['name'])
fail_count += self.c.delete_bdev(lvol_bdev1['name'])
# destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# destroy malloc bdev
# 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
Check if data written to thin provisioned lvol bdev
were properly written (fio test with verification).
"""
# create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
# construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name,
self.cluster_size)
@ -805,6 +855,7 @@ class TestCases(object):
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
free_clusters_start = int(lvs['free_clusters'])
bdev_size = int(lvs['cluster_size']) * int(lvs['free_clusters']) / MEGABYTE
# construct thin provisioned lvol bdev with size equal to lvol store
bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name,
bdev_size, thin=True)
@ -812,23 +863,65 @@ class TestCases(object):
nbd_name = "/dev/nbd0"
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name)
size = bdev_size * MEGABYTE
# on the whole lvol bdev perform write operation with verification
fail_count += self.run_fio_test(nbd_name, 0, size, "write", "0xcc")
fail_count += self.c.stop_nbd_disk(nbd_name)
# destroy thin provisioned lvol bdev
fail_count += self.c.delete_bdev(lvol_bdev['name'])
# destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# destroy malloc bdev
# Expected result:
# - calls successful, return code = 0
# - verification ends with success
# - no other operation fails
return fail_count
@case_message
def test_case653(self):
"""
thin_provisioning_resize
Check thin provisioned bdev resize. To be implemented.
"""
# TODO
# create malloc bdev
# construct lvol store on malloc bdev
# construct thin provisioned lvol bdevs on created lvol store
# with size equal to 50% of lvol store
# fill all free space of lvol bdev with data
# save number of free clusters for lvs
# resize bdev to full size of lvs
# check if bdev size changed (total_data_clusters*cluster_size
# equal to num_blocks*block_size)
# check if free_clusters on lvs remain unaffected
# perform write operation with verification
# to newly created free space of lvol bdev
# resize bdev to 30M and check if it ended with success
# check if free clusters on lvs equals to saved counter
# destroy thin provisioned lvol bdev
# destroy lvol store
# destroy malloc bdev
fail_count = 0
# Expected result:
# - calls successful, return code = 0
# - no other operation fails
return fail_count
@case_message
def test_case654(self):
"""
thin_overprovisioning
Create two thin provisioned lvol bdevs with max size
and check if writting more than total size of lvol store
will cause failures.
"""
# create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
# construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name,
self.cluster_size)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
@ -838,6 +931,8 @@ class TestCases(object):
lbd_name0 = self.lbd_name + str("0")
lbd_name1 = self.lbd_name + str("1")
bdev_size = int(lvs['cluster_size']) * int(lvs['free_clusters']) / MEGABYTE
# construct two thin provisioned lvol bdevs on created lvol store
# with size equals to free lvs size
bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0,
bdev_size, thin=True)
bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1,
@ -856,13 +951,17 @@ class TestCases(object):
fail_count += self.c.start_nbd_disk(lvol_bdev1['name'], nbd_name1)
size = "75%"
# fill first bdev to 75% of its space with specific pattern
fail_count += self.run_fio_test(nbd_name0, 0, size, "write", "0xcc")
size = "75%"
# fill second bdev up to 75% of its space
# check that error message occured while filling second bdev with data
fail_count += self.run_fio_test(nbd_name1, 0, size, "write", "0xee",
expected_ret_value=1)
size = "75%"
# check if data on first disk stayed unchanged
fail_count += self.run_fio_test(nbd_name0, 0, size, "read", "0xcc")
size = "25%"
@ -871,15 +970,29 @@ class TestCases(object):
fail_count += self.c.stop_nbd_disk(nbd_name0)
fail_count += self.c.stop_nbd_disk(nbd_name1)
# destroy thin provisioned lvol bdev
fail_count += self.c.delete_bdev(lvol_bdev0['name'])
fail_count += self.c.delete_bdev(lvol_bdev1['name'])
# destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# destroy malloc bdev
# Expected result:
# - calls successful, return code = 0
# - no other operation fails
return fail_count
@case_message
def test_case655(self):
"""
thin_provisioning_filling_disks_less_than_lvs_size
Check if writing to two thin provisioned lvol bdevs
less than total size of lvol store will end with success
"""
# create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
# construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name,
self.cluster_size)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
@ -890,6 +1003,8 @@ class TestCases(object):
lbd_name1 = self.lbd_name + str("1")
lvs_size = int(lvs['cluster_size']) * int(lvs['free_clusters']) / MEGABYTE
bdev_size = int(lvs_size * 0.7)
# construct two thin provisioned lvol bdevs on created lvol store
# with size equal to 70% of lvs size
bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0,
bdev_size, thin=True)
bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1,
@ -897,21 +1012,31 @@ class TestCases(object):
lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0)
lvol_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1)
# check if bdevs are available and size of every disk is equal to 70% of lvs size
nbd_name0 = "/dev/nbd0"
nbd_name1 = "/dev/nbd1"
fail_count += self.c.start_nbd_disk(lvol_bdev0['name'], nbd_name0)
fail_count += self.c.start_nbd_disk(lvol_bdev1['name'], nbd_name1)
size = int(int(lvol_bdev0['num_blocks']) * int(lvol_bdev0['block_size']) * 0.7)
# fill first disk with 70% of its size
# check if operation didn't fail
fail_count += self.run_fio_test(nbd_name0, 0, size, "write", "0xcc")
size = int(int(lvol_bdev1['num_blocks']) * int(lvol_bdev1['block_size']) * 0.7)
# fill second disk also with 70% of its size
# check if operation didn't fail
fail_count += self.run_fio_test(nbd_name1, 0, size, "write", "0xee")
fail_count += self.c.stop_nbd_disk(nbd_name0)
fail_count += self.c.stop_nbd_disk(nbd_name1)
# destroy thin provisioned lvol bdevs
fail_count += self.c.delete_bdev(lvol_bdev0['name'])
fail_count += self.c.delete_bdev(lvol_bdev1['name'])
# destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# destroy malloc bdev
# Expected result:
# - calls successful, return code = 0
# - no other operation fails
return fail_count
@case_message

108
test/lvol/test_plan.md
View File

@ -554,114 +554,6 @@ Expected result:
- construct lvol store return code != 0
- Error code response printed to stdout
### Provisioning
#### TEST CASE 650 - Name: thin_provisioning_check_space
- create malloc bdev
- construct lvol store on malloc bdev
- create thin provisioned lvol bdev with size equals to lvol store free space
- check and save number of free clusters for lvol store
- write data (less than lvs cluster size) to created lvol bdev starting from offset 0.
- check that free clusters on lvol store was decremented by 1
- write data (lvs cluster size) to lvol bdev with offset set to one and half of cluster size
- check that free clusters on lvol store was decremented by 2
- write data to lvol bdev to the end of its size
- check that lvol store free clusters number equals to 0
- destroy thin provisioned lvol bdev
- check that saved number of free clusters equals to current free clusters
- destroy lvol store
- destroy malloc bdev
Expected result:
- calls successful, return code = 0
- no other operation fails
#### TEST CASE 651 - Name: thin_provisioning_read_empty_bdev
- create malloc bdev
- construct lvol store on malloc bdev
- create thick provisioned lvol bvdev with size equal to lvol store
- create thin provisioned lvol bdev with the same size
- fill the whole thick provisioned lvol bdev
- perform read operations on thin provisioned lvol bdev
and check if they return zeroes
- destroy thin provisioned lvol bdev
- destroy lvol store
- destroy malloc bdev
Expected result:
- calls successful, return code = 0
- no other operation fails
#### TEST CASE 652 - Name: thin_provisioning_data_integrity_test
- create malloc bdev
- construct lvol store on malloc bdev
- construct thin provisioned lvol bdev with size equal to lvol store
- on the whole lvol bdev perform write operation with verification
- destroy thin provisioned lvol bdev
- destroy lvol store
- destroy malloc bdev
Expected result:
- calls successful, return code = 0
- verification ends with success
- no other operation fails
#### TEST CASE 653 - Name: thin_provisioning_resize
- create malloc bdev
- construct lvol store on malloc bdev
- construct thin provisioned lvol bdevs on created lvol store
with size equal to 50% of lvol store
- fill all free space of lvol bdev with data
- save number of free clusters for lvs
- resize bdev to full size of lvs
- check if bdev size changed (total_data_clusters*cluster_size
equal to num_blocks*block_size)
- check if free_clusters on lvs remain unaffected
- perform write operation with verification
to newly created free space of lvol bdev
- resize bdev to 30M and check if it ended with success
- check if free clusters on lvs equals to saved counter
- destroy thin provisioned lvol bdev
- destroy lvol store
- destroy malloc bdev
Expected result:
- calls successful, return code = 0
- no other operation fails
#### TEST CASE 654 - Name: thin_overprovisioning
- create malloc bdev
- construct lvol store on malloc bdev
- construct two thin provisioned lvol bdevs on created lvol store
with size equals to free lvs size
- fill first bdev to 75% of its space with specific pattern
- fill second bdev up to 75% of its space
- check that error message occured while filling second bdev with data
- check if data on first disk stayed unchanged
- destroy thin provisioned lvol bdev
- destroy lvol store
- destroy malloc bdev
Expected result:
- calls successful, return code = 0
- no other operation fails
#### TEST CASE 655 - Name: thin_provisioning_filling_disks_less_than_lvs_size
- create malloc bdev
- construct lvol store on malloc bdev
- construct two thin provisioned lvol bdevs on created lvol store
with size equal to 70% of lvs size
- check if bdevs are available and size of every disk is equal to 70% of lvs size
- fill first disk with 70% of its size and second one also with 70% of its size
- check if operation didn't fail
- destroy thin provisioned lvol bdevs
- destroy lvol store
- destroy malloc bdev
Expected result:
- calls successful, return code = 0
- no other operation fails
### logical volume tasting tests
#### TEST CASE 700 - Name: tasting_positive