tests/qemu-iotests/046

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