[ceph.git] / ceph / src / spdk / test / lvol / thin_provisioning.sh

#!/usr/bin/env bash

testdir=$(readlink -f $(dirname $0))
rootdir=$(readlink -f $testdir/../..)
source $rootdir/test/common/autotest_common.sh
source $rootdir/test/lvol/common.sh
source $rootdir/test/bdev/nbd_common.sh

# Check if number of free clusters on lvol store decreases
# if we write to created thin provisioned lvol bdev
function test_thin_lvol_check_space() {
	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 thin provision lvol bdev with size equals to lvol store space
	lvol_size_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB)))
	lvol_uuid=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test "$lvol_size_mb" -t)

	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	free_clusters_create_lvol="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	[ $free_clusters_start == $free_clusters_create_lvol ]

	# Write data (lvs cluster size) to created lvol bdev starting from offset 0.
	size=$LVS_DEFAULT_CLUSTER_SIZE
	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
	run_fio_test /dev/nbd0 0 $size "write" "0xcc"
	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	free_clusters_first_fio="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	[ $((free_clusters_first_fio + 1)) == $free_clusters_start ]

	# Write data (lvs cluster size) to lvol bdev with offset set to one and half of cluster size
	offset=$((LVS_DEFAULT_CLUSTER_SIZE * 3 / 2))
	size=$LVS_DEFAULT_CLUSTER_SIZE
	run_fio_test /dev/nbd0 $offset $size "write" "0xcc"
	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	free_clusters_second_fio="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	[ $((free_clusters_second_fio + 3)) == $free_clusters_start ]

	# write data to lvol bdev to the end of its size
	size=$((LVS_DEFAULT_CLUSTER_SIZE * free_clusters_first_fio))
	offset=$((3 * LVS_DEFAULT_CLUSTER_SIZE))
	run_fio_test /dev/nbd0 $offset $size "write" "0xcc"
	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	# Check that lvol store free clusters number equals to 0
	free_clusters_third_fio="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	[ $((free_clusters_third_fio)) == 0 ]

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
	rpc_cmd bdev_lvol_delete "$lvol_uuid"
	rpc_cmd bdev_get_bdevs -b "$lvol_uuid" && false
	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	free_clusters_end="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	[ $((free_clusters_end)) == $free_clusters_start ]

	# Clean up
	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 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"
}

# Check if data written to thin provisioned lvol bdev
# were properly written (fio test with verification)
function test_thin_lvol_check_integrity() {
	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 thin provisioned lvol bdev with size equals to lvol store space
	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_uuid=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test "$lvol_size_mb" -t)

	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
	run_fio_test /dev/nbd0 0 $lvol_size "write" "0xcc"

	# Clean up
	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
	rpc_cmd bdev_lvol_delete "$lvol_uuid"
	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
	rpc_cmd bdev_malloc_delete "$malloc_name"
}

# Check thin provisioned bdev resize
function test_thin_lvol_resize() {
	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)
	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)

	# Construct thin provisioned lvol bdevs on created lvol store
	# with size equal to 50% of lvol store
	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)

	# Fill all free space of lvol bdev with data
	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
	run_fio_test /dev/nbd0 0 $lvol_size "write" "0xcc"
	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0

	# Save number of free clusters for lvs
	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	# Resize bdev to full size of lvs
	lvol_size_full_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB)))
	lvol_size_full=$((lvol_size_full_mb * 1024 * 1024))
	rpc_cmd bdev_lvol_resize $lvol_uuid $lvol_size_full_mb

	# Check if bdev size changed (total_data_clusters*cluster_size
	# equals to num_blocks*block_size)
	lvol=$(rpc_cmd bdev_get_bdevs -b "$lvol_uuid")
	[ "$(jq -r '.[0].block_size' <<< "$lvol")" = "$MALLOC_BS" ]
	[ "$(jq -r '.[0].num_blocks' <<< "$lvol")" = $((lvol_size_full / MALLOC_BS)) ]

	# Check if free_clusters on lvs remain unaffected
	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	free_clusters_resize="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	[ $free_clusters_start == $free_clusters_resize ]

	# Perform write operation with verification
	# to newly created free space of lvol bdev
	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
	run_fio_test /dev/nbd0 0 $lvol_size_full "write" "0xcc"
	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0

	# Check if free clusters on lvs equals to zero
	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	[ $free_clusters_start == 0 ]

	# Resize bdev to 25% of lvs and check if it ended with success
	lvol_size_quarter_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB / 4)))
	rpc_cmd bdev_lvol_resize $lvol_uuid $lvol_size_quarter_mb

	# Check free clusters on lvs
	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	free_clusters_resize_quarter="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	free_clusters_expected=$(((lvol_size_full_mb - lvol_size_quarter_mb) / LVS_DEFAULT_CLUSTER_SIZE_MB))
	[ $free_clusters_resize_quarter == $free_clusters_expected ]

	rpc_cmd bdev_lvol_delete "$lvol_uuid"
	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
	rpc_cmd bdev_malloc_delete "$malloc_name"
}

function test_thin_overprovisioning() {
	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)
	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)

	# Construct two thin provisioned lvol bdevs on created lvol store
	# with size equal to free lvol store size
	lvol_size_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB)))
	lvol_size=$((lvol_size_mb * 1024 * 1024))
	lvol_uuid1=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test1 "$lvol_size_mb" -t)
	lvol_uuid2=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test2 "$lvol_size_mb" -t)

	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid1" /dev/nbd0
	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid2" /dev/nbd1
	# Fill first bdev to 50% of its space with specific pattern
	fill_size=$((lvol_size_mb * 5 / 10 / LVS_DEFAULT_CLUSTER_SIZE_MB * LVS_DEFAULT_CLUSTER_SIZE_MB))
	fill_size=$((fill_size * 1024 * 1024))
	run_fio_test /dev/nbd0 0 $fill_size "write" "0xcc"

	# Fill second bdev up to 50% of its space
	run_fio_test /dev/nbd1 0 $fill_size "write" "0xcc"

	# Fill rest of second bdev
	# Check that error message occured while filling second bdev with data
	offset=$fill_size
	fill_size_rest=$((lvol_size - fill_size))
	run_fio_test /dev/nbd1 "$offset" "$fill_size_rest" "write" "0xcc" && false

	# Check if data on first disk stayed unchanged
	run_fio_test /dev/nbd0 0 $fill_size "read" "0xcc"
	run_fio_test /dev/nbd0 $offset $fill_size_rest "read" "0x00"

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd1

	rpc_cmd bdev_lvol_delete "$lvol_uuid2"
	rpc_cmd bdev_lvol_delete "$lvol_uuid1"
	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
	rpc_cmd bdev_malloc_delete "$malloc_name"
}

$SPDK_BIN_DIR/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
run_test "test_thin_lvol_check_integrity" test_thin_lvol_check_integrity
run_test "test_thin_lvol_resize" test_thin_lvol_resize
run_test "test_thin_overprovisioning" test_thin_overprovisioning

trap - SIGINT SIGTERM EXIT
killprocess $spdk_pid
Commit	Line	Data
f67539c2 TL	1	#!/usr/bin/env bash
	2
	3	testdir=$(readlink -f $(dirname $0))
	4	rootdir=$(readlink -f $testdir/../..)
	5	source $rootdir/test/common/autotest_common.sh
	6	source $rootdir/test/lvol/common.sh
	7	source $rootdir/test/bdev/nbd_common.sh
	8
	9	# Check if number of free clusters on lvol store decreases
	10	# if we write to created thin provisioned lvol bdev
	11	function test_thin_lvol_check_space() {
	12	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)
	13	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)
	14	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	15	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	16
	17	# Create thin provision lvol bdev with size equals to lvol store space
	18	lvol_size_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB)))
	19	lvol_uuid=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test "$lvol_size_mb" -t)
	20
	21	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	22	free_clusters_create_lvol="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	23	[ $free_clusters_start == $free_clusters_create_lvol ]
	24
	25	# Write data (lvs cluster size) to created lvol bdev starting from offset 0.
	26	size=$LVS_DEFAULT_CLUSTER_SIZE
	27	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
	28	run_fio_test /dev/nbd0 0 $size "write" "0xcc"
	29	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	30	free_clusters_first_fio="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	31	[ $((free_clusters_first_fio + 1)) == $free_clusters_start ]
	32
	33	# Write data (lvs cluster size) to lvol bdev with offset set to one and half of cluster size
	34	offset=$((LVS_DEFAULT_CLUSTER_SIZE * 3 / 2))
	35	size=$LVS_DEFAULT_CLUSTER_SIZE
	36	run_fio_test /dev/nbd0 $offset $size "write" "0xcc"
	37	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	38	free_clusters_second_fio="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	39	[ $((free_clusters_second_fio + 3)) == $free_clusters_start ]
	40
	41	# write data to lvol bdev to the end of its size
	42	size=$((LVS_DEFAULT_CLUSTER_SIZE * free_clusters_first_fio))
	43	offset=$((3 * LVS_DEFAULT_CLUSTER_SIZE))
	44	run_fio_test /dev/nbd0 $offset $size "write" "0xcc"
	45	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	46	# Check that lvol store free clusters number equals to 0
	47	free_clusters_third_fio="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	48	[ $((free_clusters_third_fio)) == 0 ]
	49
	50	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
	51	rpc_cmd bdev_lvol_delete "$lvol_uuid"
	52	rpc_cmd bdev_get_bdevs -b "$lvol_uuid" && false
	53	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
	54	free_clusters_end="$(jq -r '.[0].free_clusters' <<< "$lvs")"
	55	[ $((free_clusters_end)) == $free_clusters_start ]
	56
	57	# Clean up
	58	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
	59	rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid" && false
	60	rpc_cmd bdev_malloc_delete "$malloc_name"
	61	}
	62
	63	# Check if we can create thin provisioned bdev on empty lvol store
	64	# and check if we can read from this device and it returns zeroes.
65	function test_thin_lvol_check_zeroes() {
66	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)
67	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)
68	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
69	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"
70
71	# Create thick and thin provisioned lvol bdevs with size equals to lvol store space
72	lbd_name0=lvol_test0
73	lbd_name1=lvol_test1
74	lvol_size_mb=$((LVS_DEFAULT_CAPACITY_MB))
75	# Round down lvol size to the nearest cluster size boundary
76	lvol_size_mb=$((lvol_size_mb / LVS_DEFAULT_CLUSTER_SIZE_MB * LVS_DEFAULT_CLUSTER_SIZE_MB))
77	lvol_size=$((lvol_size_mb * 1024 * 1024))
78	lvol_uuid0=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" $lbd_name0 "$lvol_size_mb")
79	lvol_uuid1=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" $lbd_name1 "$lvol_size_mb" -t)
80
81	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid0" /dev/nbd0
82	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid1" /dev/nbd1
83
84	# Fill the whole thick provisioned lvol bdev
85	run_fio_test /dev/nbd0 0 $lvol_size "write" "0xcc"
86
87	# Perform read operations on thin provisioned lvol bdev
88	# and check if they return zeroes
89	run_fio_test /dev/nbd1 0 $lvol_size "read" "0x00"
90
91	# Clean up
92	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd1
93	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
94	rpc_cmd bdev_lvol_delete "$lvol_uuid1"
95	rpc_cmd bdev_lvol_delete "$lvol_uuid0"
96	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
97	rpc_cmd bdev_malloc_delete "$malloc_name"
98	}
99
100	# Check if data written to thin provisioned lvol bdev
101	# were properly written (fio test with verification)
102	function test_thin_lvol_check_integrity() {
103	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)
104	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)
105
106	# Create thin provisioned lvol bdev with size equals to lvol store space
107	lvol_size_mb=$((LVS_DEFAULT_CAPACITY_MB))
108	# Round down lvol size to the nearest cluster size boundary
109	lvol_size_mb=$((lvol_size_mb / LVS_DEFAULT_CLUSTER_SIZE_MB * LVS_DEFAULT_CLUSTER_SIZE_MB))
110	lvol_size=$((lvol_size_mb * 1024 * 1024))
111	lvol_uuid=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test "$lvol_size_mb" -t)
112
113	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
114	run_fio_test /dev/nbd0 0 $lvol_size "write" "0xcc"
115
116	# Clean up
117	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
118	rpc_cmd bdev_lvol_delete "$lvol_uuid"
119	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
120	rpc_cmd bdev_malloc_delete "$malloc_name"
121	}
122
123	# Check thin provisioned bdev resize
124	function test_thin_lvol_resize() {
125	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)
126	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)
127
128	# Construct thin provisioned lvol bdevs on created lvol store
129	# with size equal to 50% of lvol store
130	lvol_size_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB / 2)))
131	lvol_size=$((lvol_size_mb * 1024 * 1024))
132	lvol_uuid=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test "$lvol_size_mb" -t)
133
134	# Fill all free space of lvol bdev with data
135	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
136	run_fio_test /dev/nbd0 0 $lvol_size "write" "0xcc"
137	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
138
139	# Save number of free clusters for lvs
140	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
141	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"
142	# Resize bdev to full size of lvs
143	lvol_size_full_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB)))
144	lvol_size_full=$((lvol_size_full_mb * 1024 * 1024))
145	rpc_cmd bdev_lvol_resize $lvol_uuid $lvol_size_full_mb
146
147	# Check if bdev size changed (total_data_clusters*cluster_size
148	# equals to num_blocks*block_size)
149	lvol=$(rpc_cmd bdev_get_bdevs -b "$lvol_uuid")
150	[ "$(jq -r '.[0].block_size' <<< "$lvol")" = "$MALLOC_BS" ]
151	[ "$(jq -r '.[0].num_blocks' <<< "$lvol")" = $((lvol_size_full / MALLOC_BS)) ]
152
153	# Check if free_clusters on lvs remain unaffected
154	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
155	free_clusters_resize="$(jq -r '.[0].free_clusters' <<< "$lvs")"
156	[ $free_clusters_start == $free_clusters_resize ]
157
158	# Perform write operation with verification
159	# to newly created free space of lvol bdev
160	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0
161	run_fio_test /dev/nbd0 0 $lvol_size_full "write" "0xcc"
162	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
163
164	# Check if free clusters on lvs equals to zero
165	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
166	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"
167	[ $free_clusters_start == 0 ]
168
169	# Resize bdev to 25% of lvs and check if it ended with success
170	lvol_size_quarter_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB / 4)))
171	rpc_cmd bdev_lvol_resize $lvol_uuid $lvol_size_quarter_mb
172
173	# Check free clusters on lvs
174	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")
175	free_clusters_resize_quarter="$(jq -r '.[0].free_clusters' <<< "$lvs")"
176	free_clusters_expected=$(((lvol_size_full_mb - lvol_size_quarter_mb) / LVS_DEFAULT_CLUSTER_SIZE_MB))
177	[ $free_clusters_resize_quarter == $free_clusters_expected ]
178
179	rpc_cmd bdev_lvol_delete "$lvol_uuid"
180	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
181	rpc_cmd bdev_malloc_delete "$malloc_name"
182	}
183
184	function test_thin_overprovisioning() {
185	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)
186	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)
187
188	# Construct two thin provisioned lvol bdevs on created lvol store
189	# with size equal to free lvol store size
190	lvol_size_mb=$(round_down $((LVS_DEFAULT_CAPACITY_MB)))
191	lvol_size=$((lvol_size_mb * 1024 * 1024))
192	lvol_uuid1=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test1 "$lvol_size_mb" -t)
193	lvol_uuid2=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test2 "$lvol_size_mb" -t)
194
195	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid1" /dev/nbd0
196	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid2" /dev/nbd1
197	# Fill first bdev to 50% of its space with specific pattern
198	fill_size=$((lvol_size_mb * 5 / 10 / LVS_DEFAULT_CLUSTER_SIZE_MB * LVS_DEFAULT_CLUSTER_SIZE_MB))
199	fill_size=$((fill_size * 1024 * 1024))
200	run_fio_test /dev/nbd0 0 $fill_size "write" "0xcc"
201
202	# Fill second bdev up to 50% of its space
203	run_fio_test /dev/nbd1 0 $fill_size "write" "0xcc"
204
205	# Fill rest of second bdev
206	# Check that error message occured while filling second bdev with data
207	offset=$fill_size
208	fill_size_rest=$((lvol_size - fill_size))
209	run_fio_test /dev/nbd1 "$offset" "$fill_size_rest" "write" "0xcc" && false
210
211	# Check if data on first disk stayed unchanged
212	run_fio_test /dev/nbd0 0 $fill_size "read" "0xcc"
213	run_fio_test /dev/nbd0 $offset $fill_size_rest "read" "0x00"
214
215	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0
216	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd1
217
218	rpc_cmd bdev_lvol_delete "$lvol_uuid2"
219	rpc_cmd bdev_lvol_delete "$lvol_uuid1"
220	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"
221	rpc_cmd bdev_malloc_delete "$malloc_name"
222	}
223
224	$SPDK_BIN_DIR/spdk_tgt &
225	spdk_pid=$!
226	trap 'killprocess "$spdk_pid"; exit 1' SIGINT SIGTERM EXIT
227	waitforlisten $spdk_pid
228
229	run_test "test_thin_lvol_check_space" test_thin_lvol_check_space
230	run_test "test_thin_lvol_check_zeroes" test_thin_lvol_check_zeroes
231	run_test "test_thin_lvol_check_integrity" test_thin_lvol_check_integrity
232	run_test "test_thin_lvol_resize" test_thin_lvol_resize
233	run_test "test_thin_overprovisioning" test_thin_overprovisioning
234
235	trap - SIGINT SIGTERM EXIT
236	killprocess $spdk_pid