cirrus: fix off-by-one in cirrus_bitblt_rop_bkwd_transp_*_16
[qemu.git] / tests / qemu-iotests / 046
1 #!/bin/bash
2 #
3 # Test concurrent cluster allocations
4 #
5 # Copyright (C) 2012 Red Hat, Inc.
6 #
7 # This program is free software; you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation; either version 2 of the License, or
10 # (at your option) any later version.
11 #
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 # GNU General Public License for more details.
16 #
17 # You should have received a copy of the GNU General Public License
18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 #
20
21 # creator
22 owner=kwolf@redhat.com
23
24 seq=`basename $0`
25 echo "QA output created by $seq"
26
27 here=`pwd`
28 status=1        # failure is the default!
29
30 _cleanup()
31 {
32         _cleanup_test_img
33 }
34 trap "_cleanup; exit \$status" 0 1 2 3 15
35
36 # get standard environment, filters and checks
37 . ./common.rc
38 . ./common.filter
39
40 _supported_fmt qcow2
41 _supported_proto file
42 _supported_os Linux
43
44 CLUSTER_SIZE=64k
45 size=128M
46
47 echo
48 echo "== creating backing file for COW tests =="
49
50 _make_test_img $size
51
52 function backing_io()
53 {
54     local offset=$1
55     local sectors=$2
56     local op=$3
57     local pattern=0
58     local cur_sec=0
59
60     for i in $(seq 0 $((sectors - 1))); do
61         cur_sec=$((offset / 65536 + i))
62         pattern=$(( ( (cur_sec % 128) + (cur_sec / 128)) % 128 ))
63
64         echo "$op -P $pattern $((cur_sec * 64))k 64k"
65     done
66 }
67
68 backing_io 0 32 write | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
69
70 mv "$TEST_IMG" "$TEST_IMG.base"
71
72 _make_test_img -b "$TEST_IMG.base" 6G
73
74 echo
75 echo "== Some concurrent requests touching the same cluster =="
76
77 function overlay_io()
78 {
79 # Allocate middle of cluster 1, then write to somewhere before and after it
80 cat  <<EOF
81 break write_aio A
82 aio_write -P 10 0x18000 0x2000
83 wait_break A
84
85 aio_write -P 11 0x12000 0x2000
86 aio_write -P 12 0x1c000 0x2000
87
88 resume A
89 aio_flush
90 EOF
91
92 # Sequential write case: Alloc middle of cluster 2, then write overlapping
93 # to next cluster
94 cat  <<EOF
95 break write_aio A
96 aio_write -P 20 0x28000 0x2000
97 wait_break A
98 aio_write -P 21 0x2a000 0x10000
99 resume A
100 aio_flush
101 EOF
102
103 # The same with a gap between both requests
104 cat  <<EOF
105 break write_aio A
106 aio_write -P 40 0x48000 0x2000
107 wait_break A
108 aio_write -P 41 0x4c000 0x10000
109 resume A
110 aio_flush
111 EOF
112
113 # Sequential write, but the next cluster is already allocated
114 cat  <<EOF
115 write -P 70 0x76000 0x8000
116 aio_flush
117 break write_aio A
118 aio_write -P 60 0x66000 0x2000
119 wait_break A
120 aio_write -P 61 0x6a000 0xe000
121 resume A
122 aio_flush
123 EOF
124
125 # Sequential write, but the next cluster is already allocated
126 # and phyiscally in the right position
127 cat  <<EOF
128 write -P 89 0x80000 0x1000
129 write -P 90 0x96000 0x8000
130 aio_flush
131 discard 0x80000 0x10000
132 aio_flush
133 break write_aio A
134 aio_write -P 80 0x86000 0x2000
135 wait_break A
136 aio_write -P 81 0x8a000 0xe000
137 resume A
138 aio_flush
139 EOF
140
141 # Sequential write, and the next cluster is compressed
142 cat  <<EOF
143 write    -P 109 0xa0000 0x1000
144 write -c -P 110 0xb0000 0x10000
145 aio_flush
146 discard 0xa0000 0x10000
147 aio_flush
148 break write_aio A
149 aio_write -P 100 0xa6000 0x2000
150 wait_break A
151 aio_write -P 101 0xaa000 0xe000
152 resume A
153 aio_flush
154 EOF
155
156 # Reverse sequential write
157 cat  <<EOF
158 break write_aio A
159 aio_write -P 121 0xdc000 0x2000
160 wait_break A
161 aio_write -P 120 0xc4000 0x18000
162 resume A
163 aio_flush
164 EOF
165
166 # Reverse sequential write with a gap
167 cat  <<EOF
168 break write_aio A
169 aio_write -P 141 0xfc000 0x2000
170 wait_break A
171 aio_write -P 140 0xe4000 0x14000
172 resume A
173 aio_flush
174 EOF
175
176 # Allocate an area in the middle and then overwrite with a larger request
177 cat  <<EOF
178 break write_aio A
179 aio_write -P 161 0x10c000 0x8000
180 wait_break A
181 aio_write -P 160 0x104000 0x18000
182 resume A
183 aio_flush
184 EOF
185 }
186
187 overlay_io | $QEMU_IO blkdebug::"$TEST_IMG" | _filter_qemu_io |\
188         sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
189
190 echo
191 echo "== Verify image content =="
192
193 function verify_io()
194 {
195     if ($QEMU_IMG info -f "$IMGFMT" "$TEST_IMG" | grep "compat: 0.10" > /dev/null); then
196         # For v2 images, discarded clusters are read from the backing file
197         # Keep the variable empty so that the backing file value can be used as
198         # the default below
199         discarded=
200     else
201         # Discarded clusters are zeroed for v3 or later
202         discarded=0
203     fi
204
205     echo read -P 0 0 0x10000
206
207     echo read -P 1  0x10000 0x2000
208     echo read -P 11 0x12000 0x2000
209     echo read -P 1  0x14000 0x4000
210     echo read -P 10 0x18000 0x2000
211     echo read -P 1  0x1a000 0x2000
212     echo read -P 12 0x1c000 0x2000
213     echo read -P 1  0x1e000 0x2000
214
215     echo read -P 2  0x20000 0x8000
216     echo read -P 20 0x28000 0x2000
217     echo read -P 21 0x2a000 0x10000
218     echo read -P 3  0x3a000 0x6000
219
220     echo read -P 4  0x40000 0x8000
221     echo read -P 40 0x48000 0x2000
222     echo read -P 4  0x4a000 0x2000
223     echo read -P 41 0x4c000 0x10000
224     echo read -P 5  0x5c000 0x4000
225
226     echo read -P 6  0x60000 0x6000
227     echo read -P 60 0x66000 0x2000
228     echo read -P 6  0x68000 0x2000
229     echo read -P 61 0x6a000 0xe000
230     echo read -P 70 0x78000 0x6000
231     echo read -P 7  0x7e000 0x2000
232
233     echo read -P ${discarded:-8} 0x80000 0x6000
234     echo read -P 80 0x86000 0x2000
235     echo read -P ${discarded:-8} 0x88000 0x2000
236     echo read -P 81 0x8a000 0xe000
237     echo read -P 90 0x98000 0x6000
238     echo read -P 9  0x9e000 0x2000
239
240     echo read -P ${discarded:-10} 0xa0000 0x6000
241     echo read -P 100 0xa6000 0x2000
242     echo read -P ${discarded:-10} 0xa8000 0x2000
243     echo read -P 101 0xaa000 0xe000
244     echo read -P 110 0xb8000 0x8000
245
246     echo read -P 12  0xc0000 0x4000
247     echo read -P 120 0xc4000 0x18000
248     echo read -P 121 0xdc000 0x2000
249     echo read -P 13  0xde000 0x2000
250
251     echo read -P 14  0xe0000 0x4000
252     echo read -P 140 0xe4000 0x14000
253     echo read -P 15  0xf8000 0x4000
254     echo read -P 141 0xfc000 0x2000
255     echo read -P 15  0xfe000 0x2000
256
257     echo read -P 16  0x100000 0x4000
258     echo read -P 160 0x104000 0x8000
259     # Undefined content for 0x10c000 0x8000
260     echo read -P 160 0x114000 0x8000
261     echo read -P 17  0x11c000 0x4000
262 }
263
264 verify_io | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
265
266 _check_test_img
267
268 # success, all done
269 echo "*** done"
270 rm -f $seq.full
271 status=0