← Back to branch summary

~ubuntu-branches/debian/sid/lvm2/sid

« back to all changes in this revision

Viewing changes to test/shell/vgsplit-operation.sh

  • Committer: Package Import Robot
  • Author(s): Bastian Blank
  • Date: 2013-03-03 12:33:47 UTC
  • mfrom: (1.1.15)
  • Revision ID: package-import@ubuntu.com-20130303123347-smfwei6dodkdth55
Tags: 2.02.98-1
New upstream version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/shell/vgsplit-operation.sh
13
13
 
14
14
. lib/test
15
15
 
16
 
COMM() {  
 
16
COMM() {
17
17
        LAST_TEST="$@"
18
18
}
19
19
 
37
37
        for j in PV LV
38
38
        do
39
39
COMM "vgsplit correctly splits single linear LV into $i VG ($j args)"
40
 
                create_vg_ $vg1 $dev1 $dev2
41
 
                test $i = existing && create_vg_ $vg2 $dev3 $dev4
 
40
                create_vg_ $vg1 "$dev1" "$dev2"
 
41
                test $i = existing && create_vg_ $vg2 "$dev3" "$dev4"
42
42
 
43
 
                lvcreate -l 4 -n $lv1 $vg1 $dev1 
44
 
                vgchange -an $vg1 
 
43
                lvcreate -l 4 -n $lv1 $vg1 "$dev1"
 
44
                vgchange -an $vg1
45
45
                if [ $j = PV ]; then
46
 
                  vgsplit $vg1 $vg2 $dev1
 
46
                  vgsplit $vg1 $vg2 "$dev1"
47
47
                else
48
48
                  vgsplit -n $lv1 $vg1 $vg2
49
 
                fi 
50
 
                check pvlv_counts $vg1 1 0 0 
 
49
                fi
 
50
                check pvlv_counts $vg1 1 0 0
51
51
                if [ $i = existing ]; then
52
52
                   check pvlv_counts $vg2 3 1 0
53
53
                else
54
54
                   check pvlv_counts $vg2 1 1 0
55
 
                fi 
56
 
                lvremove -f $vg2/$lv1 
 
55
                fi
 
56
                lvremove -f $vg2/$lv1
57
57
                vgremove -f $vg2 $vg1
58
58
 
59
59
COMM "vgsplit correctly splits single striped LV into $i VG ($j args)"
60
 
                create_vg_ $vg1 $dev1 $dev2
61
 
                test $i = existing && create_vg_ $vg2 $dev3 $dev4
 
60
                create_vg_ $vg1 "$dev1" "$dev2"
 
61
                test $i = existing && create_vg_ $vg2 "$dev3" "$dev4"
62
62
 
63
 
                lvcreate -l 4 -i 2 -n $lv1 $vg1 $dev1 $dev2 
64
 
                vgchange -an $vg1 
 
63
                lvcreate -l 4 -i 2 -n $lv1 $vg1 "$dev1" "$dev2"
 
64
                vgchange -an $vg1
65
65
                if [ $j = PV ]; then
66
 
                  vgsplit $vg1 $vg2 $dev1 $dev2
 
66
                  vgsplit $vg1 $vg2 "$dev1" "$dev2"
67
67
                else
68
68
                  vgsplit -n $lv1 $vg1 $vg2
69
 
                fi 
 
69
                fi
70
70
                if [ $i = existing ]; then
71
71
                  check pvlv_counts $vg2 4 1 0
72
72
                else
73
73
                  check pvlv_counts $vg2 2 1 0
74
 
                fi 
75
 
                lvremove -f $vg2/$lv1 
 
74
                fi
 
75
                lvremove -f $vg2/$lv1
76
76
                vgremove -f $vg2
77
77
 
78
 
COMM "vgsplit correctly splits mirror LV into $i VG ($j args)" 
79
 
                create_vg_ $vg1 $dev1 $dev2 $dev3
80
 
                test $i = existing && create_vg_ $vg2 $dev4
 
78
COMM "vgsplit correctly splits mirror LV into $i VG ($j args)"
 
79
                create_vg_ $vg1 "$dev1" "$dev2" "$dev3"
 
80
                test $i = existing && create_vg_ $vg2 "$dev4"
81
81
 
82
 
                lvcreate -l 64 -m1 -n $lv1 $vg1 $dev1 $dev2 $dev3 
83
 
                vgchange -an $vg1 
 
82
                lvcreate -l 64 -m1 -n $lv1 $vg1 "$dev1" "$dev2" "$dev3"
 
83
                vgchange -an $vg1
84
84
                if [ $j = PV ]; then
85
 
                  vgsplit $vg1 $vg2 $dev1 $dev2 $dev3
 
85
                  vgsplit $vg1 $vg2 "$dev1" "$dev2" "$dev3"
86
86
                else
87
87
                  vgsplit -n $lv1 $vg1 $vg2
88
 
                fi 
 
88
                fi
89
89
                if [ $i = existing ]; then
90
90
                  check pvlv_counts $vg2 4 1 0
91
91
                else
92
92
                  check pvlv_counts $vg2 3 1 0
93
 
                fi 
94
 
                lvremove -f $vg2/$lv1 
 
93
                fi
 
94
                lvremove -f $vg2/$lv1
95
95
                vgremove -f $vg2
96
96
# FIXME: ensure split /doesn't/ work when not all devs of mirror specified
97
97
 
98
98
COMM "vgsplit correctly splits mirror LV with mirrored log into $i VG ($j args)"
99
 
                create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
100
 
                test $i = existing && create_vg_ $vg2 $dev5
 
99
                create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
100
                test $i = existing && create_vg_ $vg2 "$dev5"
101
101
 
102
102
                lvcreate -l 64 --mirrorlog mirrored -m1 -n $lv1 $vg1 \
103
 
                    $dev1 $dev2 $dev3 $dev4
 
103
                    "$dev1" "$dev2" "$dev3" "$dev4"
104
104
 
105
105
                vgchange -an $vg1
106
106
                if [ $j = PV ]; then
107
 
                  vgsplit $vg1 $vg2 $dev1 $dev2 $dev3 $dev4
 
107
                  vgsplit $vg1 $vg2 "$dev1" "$dev2" "$dev3" "$dev4"
108
108
                else
109
109
                  vgsplit -n $lv1 $vg1 $vg2
110
110
                fi
117
117
                vgremove -f $vg2
118
118
# FIXME: ensure split /doesn't/ work when not all devs of mirror specified
119
119
 
120
 
COMM "vgsplit correctly splits origin and snapshot LV into $i VG ($j args)" 
121
 
                create_vg_ $vg1 $dev1 $dev2
122
 
                test $i = existing && create_vg_ $vg2 $dev3 $dev4
 
120
COMM "vgsplit correctly splits origin and snapshot LV into $i VG ($j args)"
 
121
                create_vg_ $vg1 "$dev1" "$dev2"
 
122
                test $i = existing && create_vg_ $vg2 "$dev3" "$dev4"
123
123
 
124
 
                lvcreate -l 64 -i 2 -n $lv1 $vg1 $dev1 $dev2 
125
 
                lvcreate -l 4 -i 2 -s -n $lv2 $vg1/$lv1 
126
 
                vgchange -an $vg1 
 
124
                lvcreate -l 64 -i 2 -n $lv1 $vg1 "$dev1" "$dev2"
 
125
                lvcreate -l 4 -i 2 -s -n $lv2 $vg1/$lv1
 
126
                vgchange -an $vg1
127
127
                if [ $j = PV ]; then
128
 
                  vgsplit $vg1 $vg2 $dev1 $dev2
 
128
                  vgsplit $vg1 $vg2 "$dev1" "$dev2"
129
129
                else
130
130
                  vgsplit -n $lv1 $vg1 $vg2
131
 
                fi 
 
131
                fi
132
132
                if [ $i = existing ]; then
133
133
                  check pvlv_counts $vg2 4 2 1
134
134
                else
135
135
                  check pvlv_counts $vg2 2 2 1
136
 
                fi 
 
136
                fi
137
137
                lvremove -f $vg2/$lv2
138
138
                lvremove -f $vg2/$lv1
139
139
                vgremove -f $vg2
140
140
 
141
 
COMM "vgsplit correctly splits linear LV but not snap+origin LV into $i VG ($j args)" 
142
 
                create_vg_ $vg1 $dev1 $dev2
143
 
                test $i = existing && create_vg_ $vg2 $dev3
 
141
COMM "vgsplit correctly splits linear LV but not snap+origin LV into $i VG ($j args)"
 
142
                create_vg_ $vg1 "$dev1" "$dev2"
 
143
                test $i = existing && create_vg_ $vg2 "$dev3"
144
144
 
145
 
                lvcreate -l 64 -i 2 -n $lv1 $vg1 
146
 
                lvcreate -l 4 -i 2 -s -n $lv2 $vg1/$lv1 
147
 
                vgextend $vg1 $dev4 
148
 
                lvcreate -l 64 -n $lv3 $vg1 $dev4 
149
 
                vgchange -an $vg1 
 
145
                lvcreate -l 64 -i 2 -n $lv1 $vg1
 
146
                lvcreate -l 4 -i 2 -s -n $lv2 $vg1/$lv1
 
147
                vgextend $vg1 "$dev4"
 
148
                lvcreate -l 64 -n $lv3 $vg1 "$dev4"
 
149
                vgchange -an $vg1
150
150
                if [ $j = PV ]; then
151
 
                  vgsplit $vg1 $vg2 $dev4
 
151
                  vgsplit $vg1 $vg2 "$dev4"
152
152
                else
153
153
                  vgsplit -n $lv3 $vg1 $vg2
154
 
                fi 
 
154
                fi
155
155
                if [ $i = existing ]; then
156
156
                  check pvlv_counts $vg2 2 1 0
157
157
                  check pvlv_counts $vg1 2 2 1
158
158
                else
159
159
                  check pvlv_counts $vg2 1 1 0
160
160
                  check pvlv_counts $vg1 2 2 1
161
 
                fi 
 
161
                fi
162
162
                lvremove -f $vg1/$lv2
163
163
                lvremove -f $vg1/$lv1 $vg2/$lv3
164
164
                vgremove -f $vg1 $vg2
165
165
 
166
 
COMM "vgsplit correctly splits linear LV but not mirror LV into $i VG ($j args)" 
167
 
                create_vg_ $vg1 $dev1 $dev2 $dev3 
168
 
                test $i = existing && create_vg_ $vg2 $dev5
 
166
COMM "vgsplit correctly splits linear LV but not mirror LV into $i VG ($j args)"
 
167
                create_vg_ $vg1 "$dev1" "$dev2" "$dev3"
 
168
                test $i = existing && create_vg_ $vg2 "$dev5"
169
169
 
170
 
                lvcreate -l 64 -m1 -n $lv1 $vg1 $dev1 $dev2 $dev3 
171
 
                vgextend $vg1 $dev4 
172
 
                lvcreate -l 64 -n $lv2 $vg1 $dev4 
173
 
                vgchange -an $vg1 
 
170
                lvcreate -l 64 -m1 -n $lv1 $vg1 "$dev1" "$dev2" "$dev3"
 
171
                vgextend $vg1 "$dev4"
 
172
                lvcreate -l 64 -n $lv2 $vg1 "$dev4"
 
173
                vgchange -an $vg1
174
174
                if [ $j = PV ]; then
175
 
                  vgsplit $vg1 $vg2 $dev4
 
175
                  vgsplit $vg1 $vg2 "$dev4"
176
176
                else
177
177
                  vgsplit -n $lv2 $vg1 $vg2
178
 
                fi 
 
178
                fi
179
179
                if [ $i = existing ]; then
180
180
                  check pvlv_counts $vg1 3 1 0
181
181
                  check pvlv_counts $vg2 2 1 0
182
182
                else
183
183
                  check pvlv_counts $vg1 3 1 0
184
184
                  check pvlv_counts $vg2 1 1 0
185
 
                fi 
186
 
                lvremove -f $vg1/$lv1 $vg2/$lv2
 
185
                fi
187
186
                vgremove -f $vg1 $vg2
188
187
 
189
188
        done
192
191
#
193
192
# Test more complex setups where the code has to find associated PVs and
194
193
# LVs to split the VG correctly
195
 
# 
196
 
COMM "vgsplit fails splitting 3 striped LVs into VG when only 1 LV specified" 
197
 
create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
198
 
lvcreate -l 4 -n $lv1 -i 2 $vg1 $dev1 $dev2 
199
 
lvcreate -l 4 -n $lv2 -i 2 $vg1 $dev2 $dev3 
200
 
lvcreate -l 4 -n $lv3 -i 2 $vg1 $dev3 $dev4 
201
 
vgchange -an $vg1 
 
194
#
 
195
COMM "vgsplit fails splitting 3 striped LVs into VG when only 1 LV specified"
 
196
create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
197
lvcreate -l 4 -n $lv1 -i 2 $vg1 "$dev1" "$dev2"
 
198
lvcreate -l 4 -n $lv2 -i 2 $vg1 "$dev2" "$dev3"
 
199
lvcreate -l 4 -n $lv3 -i 2 $vg1 "$dev3" "$dev4"
 
200
vgchange -an $vg1
202
201
not vgsplit -n $lv1 $vg1 $vg2
203
 
vgremove -ff $vg1
 
202
vgremove -f $vg1
204
203
 
205
 
COMM "vgsplit fails splitting one LV with 2 snapshots, only origin LV specified" 
206
 
create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
207
 
lvcreate -l 16 -n $lv1 $vg1 $dev1 $dev2 
208
 
lvcreate -l 4 -n $lv2 -s $vg1/$lv1 $dev3
209
 
lvcreate -l 4 -n $lv3 -s $vg1/$lv1 $dev4
210
 
check pvlv_counts $vg1 4 3 2 
211
 
vgchange -an $vg1 
 
204
COMM "vgsplit fails splitting one LV with 2 snapshots, only origin LV specified"
 
205
create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
206
lvcreate -l 16 -n $lv1 $vg1 "$dev1" "$dev2"
 
207
lvcreate -l 4 -n $lv2 -s $vg1/$lv1 "$dev3"
 
208
lvcreate -l 4 -n $lv3 -s $vg1/$lv1 "$dev4"
 
209
check pvlv_counts $vg1 4 3 2
 
210
vgchange -an $vg1
212
211
not vgsplit -n $lv1 $vg1 $vg2;
213
212
lvremove -f $vg1/$lv2 $vg1/$lv3
214
213
lvremove -f $vg1/$lv1
215
 
vgremove -ff $vg1
 
214
vgremove -f $vg1
216
215
 
217
 
COMM "vgsplit fails splitting one LV with 2 snapshots, only snapshot LV specified" 
218
 
create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
219
 
lvcreate -l 16 -n $lv1 $vg1 $dev1 $dev2 
220
 
lvcreate -l 4 -n $lv2 -s $vg1/$lv1 $dev3
221
 
lvcreate -l 4 -n $lv3 -s $vg1/$lv1 $dev4
222
 
check pvlv_counts $vg1 4 3 2 
223
 
vgchange -an $vg1 
 
216
COMM "vgsplit fails splitting one LV with 2 snapshots, only snapshot LV specified"
 
217
create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
218
lvcreate -l 16 -n $lv1 $vg1 "$dev1" "$dev2"
 
219
lvcreate -l 4 -n $lv2 -s $vg1/$lv1 "$dev3"
 
220
lvcreate -l 4 -n $lv3 -s $vg1/$lv1 "$dev4"
 
221
check pvlv_counts $vg1 4 3 2
 
222
vgchange -an $vg1
224
223
not vgsplit -n $lv2 $vg1 $vg2
225
224
lvremove -f $vg1/$lv2 $vg1/$lv3
226
225
lvremove -f $vg1/$lv1
227
 
vgremove -ff $vg1
228
 
 
229
 
COMM "vgsplit fails splitting one mirror LV, only one PV specified" 
230
 
create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
231
 
lvcreate -l 16 -n $lv1 -m1 $vg1 $dev1 $dev2 $dev3 
232
 
check pvlv_counts $vg1 4 1 0 
233
 
vgchange -an $vg1 
234
 
not vgsplit $vg1 $vg2 $dev2 
235
 
vgremove -ff $vg1
236
 
 
237
 
COMM "vgsplit fails splitting 1 mirror + 1 striped LV, only striped LV specified" 
238
 
create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
239
 
lvcreate -l 16 -n $lv1 -m1 $vg1 $dev1 $dev2 $dev3 
240
 
lvcreate -l 16 -n $lv2 -i 2 $vg1 $dev3 $dev4 
241
 
check pvlv_counts $vg1 4 2 0 
242
 
vgchange -an $vg1 
 
226
vgremove -f $vg1
 
227
 
 
228
COMM "vgsplit fails splitting one mirror LV, only one PV specified"
 
229
create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
230
lvcreate -l 16 -n $lv1 -m1 $vg1 "$dev1" "$dev2" "$dev3"
 
231
check pvlv_counts $vg1 4 1 0
 
232
vgchange -an $vg1
 
233
not vgsplit $vg1 $vg2 "$dev2"
 
234
vgremove -ff $vg1
 
235
 
 
236
COMM "vgsplit fails splitting 1 mirror + 1 striped LV, only striped LV specified"
 
237
create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
238
lvcreate -l 16 -n $lv1 -m1 $vg1 "$dev1" "$dev2" "$dev3"
 
239
lvcreate -l 16 -n $lv2 -i 2 $vg1 "$dev3" "$dev4"
 
240
check pvlv_counts $vg1 4 2 0
 
241
vgchange -an $vg1
243
242
not vgsplit -n $lv2 $vg1 $vg2 2>err
244
 
vgremove -ff $vg1
 
243
vgremove -f $vg1
245
244
 
246
245
#
247
246
# Verify vgsplit rejects active LVs only when active LVs involved in split
248
247
#
249
 
COMM "vgsplit fails, active mirror involved in split" 
250
 
create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
251
 
lvcreate -l 16 -n $lv1 -m1 $vg1 $dev1 $dev2 $dev3 
252
 
lvcreate -l 16 -n $lv2 $vg1 $dev4 
253
 
lvchange -an $vg1/$lv2 
254
 
check pvlv_counts $vg1 4 2 0 
 
248
COMM "vgsplit fails, active mirror involved in split"
 
249
create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
250
lvcreate -l 16 -n $lv1 -m1 $vg1 "$dev1" "$dev2" "$dev3"
 
251
lvcreate -l 16 -n $lv2 $vg1 "$dev4"
 
252
lvchange -an $vg1/$lv2
 
253
check pvlv_counts $vg1 4 2 0
255
254
not vgsplit -n $lv1 $vg1 $vg2;
256
 
check pvlv_counts $vg1 4 2 0 
257
 
vgremove -ff $vg1
258
 
 
259
 
COMM "vgsplit succeeds, active mirror not involved in split" 
260
 
create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
261
 
lvcreate -l 16 -n $lv1 -m1 $vg1 $dev1 $dev2 $dev3 
262
 
lvcreate -l 16 -n $lv2 $vg1 $dev4 
263
 
lvchange -an $vg1/$lv2 
264
 
check pvlv_counts $vg1 4 2 0 
265
 
vgsplit -n $lv2 $vg1 $vg2 
266
 
check pvlv_counts $vg1 3 1 0 
267
 
check pvlv_counts $vg2 1 1 0 
268
 
vgremove -ff $vg1 $vg2
269
 
 
270
 
COMM "vgsplit fails, active snapshot involved in split" 
271
 
create_vg_ $vg1 $dev1 $dev2 $dev3 $dev4
272
 
lvcreate -l 64 -i 2 -n $lv1 $vg1 $dev1 $dev2 
273
 
lvcreate -l 4 -i 2 -s -n $lv2 $vg1/$lv1 
274
 
lvcreate -l 64 -i 2 -n $lv3 $vg1 $dev3 $dev4 
275
 
lvchange -an $vg1/$lv3 
276
 
check pvlv_counts $vg1 4 3 1 
 
255
check pvlv_counts $vg1 4 2 0
 
256
vgremove -f $vg1
 
257
 
 
258
COMM "vgsplit succeeds, active mirror not involved in split"
 
259
create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
260
lvcreate -l 16 -n $lv1 -m1 $vg1 "$dev1" "$dev2" "$dev3"
 
261
lvcreate -l 16 -n $lv2 $vg1 "$dev4"
 
262
lvchange -an $vg1/$lv2
 
263
check pvlv_counts $vg1 4 2 0
 
264
vgsplit -n $lv2 $vg1 $vg2
 
265
check pvlv_counts $vg1 3 1 0
 
266
check pvlv_counts $vg2 1 1 0
 
267
vgremove -f $vg1 $vg2
 
268
 
 
269
COMM "vgsplit fails, active snapshot involved in split"
 
270
create_vg_ $vg1 "$dev1" "$dev2" "$dev3" "$dev4"
 
271
lvcreate -l 64 -i 2 -n $lv1 $vg1 "$dev1" "$dev2"
 
272
lvcreate -l 4 -i 2 -s -n $lv2 $vg1/$lv1
 
273
lvcreate -l 64 -i 2 -n $lv3 $vg1 "$dev3" "$dev4"
 
274
lvchange -an $vg1/$lv3
 
275
check pvlv_counts $vg1 4 3 1
277
276
not vgsplit -n $lv2 $vg1 $vg2;
278
 
check pvlv_counts $vg1 4 3 1 
279
 
lvremove -f $vg1/$lv2 
280
 
vgremove -ff $vg1
 
277
check pvlv_counts $vg1 4 3 1
 
278
lvremove -f $vg1/$lv2
 
279
vgremove -f $vg1
281
280
 
282
 
COMM "vgsplit succeeds, active snapshot not involved in split" 
283
 
create_vg_ $vg1 $dev1 $dev2 $dev3
284
 
lvcreate -l 64 -i 2 -n $lv1 $vg1 $dev1 $dev2 
285
 
lvcreate -l 4 -s -n $lv2 $vg1/$lv1 
286
 
vgextend $vg1 $dev4 
287
 
lvcreate -l 64 -n $lv3 $vg1 $dev4 
288
 
lvchange -an $vg1/$lv3 
289
 
check pvlv_counts $vg1 4 3 1 
290
 
vgsplit -n $lv3 $vg1 $vg2 
291
 
check pvlv_counts $vg1 3 2 1 
292
 
check pvlv_counts $vg2 1 1 0 
293
 
vgchange -an $vg1 
294
 
lvremove -f $vg1/$lv2 
295
 
vgremove -ff $vg1 $vg2
 
281
COMM "vgsplit succeeds, active snapshot not involved in split"
 
282
create_vg_ $vg1 "$dev1" "$dev2" "$dev3"
 
283
lvcreate -l 64 -i 2 -n $lv1 $vg1 "$dev1" "$dev2"
 
284
lvcreate -l 4 -s -n $lv2 $vg1/$lv1
 
285
vgextend $vg1 "$dev4"
 
286
lvcreate -l 64 -n $lv3 $vg1 "$dev4"
 
287
lvchange -an $vg1/$lv3
 
288
check pvlv_counts $vg1 4 3 1
 
289
vgsplit -n $lv3 $vg1 $vg2
 
290
check pvlv_counts $vg1 3 2 1
 
291
check pvlv_counts $vg2 1 1 0
 
292
vgchange -an $vg1
 
293
lvremove -f $vg1/$lv2
 
294
vgremove -f $vg1 $vg2