aboutsummaryrefslogtreecommitdiff
path: root/tests/qemu-iotests/common.pattern
blob: 85a40eecc0f1b3637c015d6ef203d2c9be89acdd (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#!/bin/bash
#
# Copyright (C) 2009 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

function do_is_allocated() {
    local start=$1
    local size=$(( $2 / 512))
    local step=$3
    local count=$4

    for i in `seq 1 $count`; do
        echo alloc $(( start + (i - 1) * step )) $size
    done
}

function is_allocated() {
    do_is_allocated "$@" | $QEMU_IO $TEST_IMG | _filter_qemu_io
}

function do_io() {
    local op=$1
    local start=$2
    local size=$3
    local step=$4
    local count=$5
    local pattern=$6

    echo === IO: pattern $pattern >&2
    for i in `seq 1 $count`; do
        echo $op -P $pattern $(( start + (i - 1) * step )) $size
    done
}

function io_pattern() {
    do_io "$@" | $QEMU_IO $TEST_IMG | _filter_qemu_io
}

function io() {
    local start=$2
    local pattern=$(( (start >> 9) % 256 ))

    do_io "$@" $pattern | $QEMU_IO $TEST_IMG | _filter_qemu_io
}

function io_zero() {
    do_io "$@" 0 | $QEMU_IO $TEST_IMG | _filter_qemu_io
}

function io_test() {
    local op=$1
    local offset=$2
    local cluster_size=$3

    local num_large=$4
    local num_medium=$((num_large * num_large))
    local num_small=$((4 * num_medium))

    local half_cluster=$((cluster_size / 2))
    local quarter_cluster=$((cluster_size / 4))
    local l2_size=$((cluster_size * cluster_size / 8))

    # Complete clusters
    io "$op" $offset $cluster_size $cluster_size $num_small
    offset=$((offset + num_small * $cluster_size))

    # From somewhere in the middle to the end of a cluster
    io "$op" $((offset + $half_cluster)) $half_cluster $cluster_size $num_small
    offset=$((offset + num_small * $cluster_size))

    # From the start to somewhere in the middle of a cluster
    io "$op" $offset $half_cluster $cluster_size $num_small
    offset=$((offset + num_small * $cluster_size))

    # Completely misaligned (and small)
    io "$op" $((offset + $quarter_cluster)) $half_cluster $cluster_size $num_small
    offset=$((offset + num_small * $cluster_size))

    # Spanning multiple clusters
    io "$op" $((offset + $half_cluster)) $((cluster_size * 2)) $((cluster_size * 3)) $num_medium
    offset=$((offset + num_medium * 3 * $cluster_size))

    # Spanning multiple L2 tables
    # L2 table size: 512 clusters of 4k = 2M
    offset=$(( ((offset + l2_size - 1) & ~(l2_size - 1)) - (3 * half_cluster) ))
    io "$op" $offset $((6 * half_cluster)) $(( l2_size + half_cluster )) $num_large
    offset=$((offset + num_large * ( l2_size + half_cluster )))
}

function io_test2() {
    local orig_offset=$1
    local cluster_size=$2
    local num=$3

    # Pattern (repeat after 9 clusters):
    #	used - used - free - used - compressed - compressed -
    #	free - free - compressed

    # Write the clusters to be compressed
    echo === Clusters to be compressed [1]
    io_pattern writev $((offset + 4 * $cluster_size)) $cluster_size $((9 * $cluster_size)) $num 165
    echo === Clusters to be compressed [2]
    io_pattern writev $((offset + 5 * $cluster_size)) $cluster_size $((9 * $cluster_size)) $num 165
    echo === Clusters to be compressed [3]
    io_pattern writev $((offset + 8 * $cluster_size)) $cluster_size $((9 * $cluster_size)) $num 165

    mv $TEST_IMG $TEST_IMG.orig
    $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c $TEST_IMG.orig $TEST_IMG

    # Write the used clusters
    echo === Used clusters [1]
    io_pattern writev $((offset + 0 * $cluster_size)) $cluster_size $((9 * $cluster_size)) $num 165
    echo === Used clusters [2]
    io_pattern writev $((offset + 1 * $cluster_size)) $cluster_size $((9 * $cluster_size)) $num 165
    echo === Used clusters [3]
    io_pattern writev $((offset + 3 * $cluster_size)) $cluster_size $((9 * $cluster_size)) $num 165

    # Read them
    echo === Read used/compressed clusters
    io_pattern readv $((offset + 0 * $cluster_size)) $((2 * $cluster_size)) $((9 * $cluster_size)) $num 165
    io_pattern readv $((offset + 3 * $cluster_size)) $((3 * $cluster_size)) $((9 * $cluster_size)) $num 165
    io_pattern readv $((offset + 8 * $cluster_size)) $((1 * $cluster_size)) $((9 * $cluster_size)) $num 165

    echo === Read zeros
    io_zero readv $((offset + 2 * $cluster_size)) $((1 * $cluster_size)) $((9 * $cluster_size)) $num
    io_zero readv $((offset + 6 * $cluster_size)) $((2 * $cluster_size)) $((9 * $cluster_size)) $num
}