migration: do cleanup operation after completion
[kvmfornfv.git] / qemu / tests / hd-geo-test.c
1 /*
2  * Hard disk geometry test cases.
3  *
4  * Copyright (c) 2012 Red Hat Inc.
5  *
6  * Authors:
7  *  Markus Armbruster <armbru@redhat.com>,
8  *
9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
10  * See the COPYING file in the top-level directory.
11  */
12
13 /*
14  * Covers only IDE and tests only CMOS contents.  Better than nothing.
15  * Improvements welcome.
16  */
17
18 #include <glib.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <unistd.h>
22 #include "qemu-common.h"
23 #include "libqtest.h"
24
25 static char *create_test_img(int secs)
26 {
27     char *template = strdup("/tmp/qtest.XXXXXX");
28     int fd, ret;
29
30     fd = mkstemp(template);
31     g_assert(fd >= 0);
32     ret = ftruncate(fd, (off_t)secs * 512);
33     g_assert(ret == 0);
34     close(fd);
35     return template;
36 }
37
38 typedef struct {
39     int cyls, heads, secs, trans;
40 } CHST;
41
42 typedef enum {
43     mbr_blank, mbr_lba, mbr_chs,
44     mbr_last
45 } MBRcontents;
46
47 typedef enum {
48     /* order is relevant */
49     backend_small, backend_large, backend_empty,
50     backend_last
51 } Backend;
52
53 static const int img_secs[backend_last] = {
54     [backend_small] = 61440,
55     [backend_large] = 8388608,
56     [backend_empty] = -1,
57 };
58
59 static const CHST hd_chst[backend_last][mbr_last] = {
60     [backend_small] = {
61         [mbr_blank] = { 60, 16, 63, 0 },
62         [mbr_lba]   = { 60, 16, 63, 2 },
63         [mbr_chs]   = { 60, 16, 63, 0 }
64     },
65     [backend_large] = {
66         [mbr_blank] = { 8322, 16, 63, 1 },
67         [mbr_lba]   = { 8322, 16, 63, 1 },
68         [mbr_chs]   = { 8322, 16, 63, 0 }
69     },
70 };
71
72 static const char *img_file_name[backend_last];
73
74 static const CHST *cur_ide[4];
75
76 static bool is_hd(const CHST *expected_chst)
77 {
78     return expected_chst && expected_chst->cyls;
79 }
80
81 static void test_cmos_byte(int reg, int expected)
82 {
83     enum { cmos_base = 0x70 };
84     int actual;
85
86     outb(cmos_base + 0, reg);
87     actual = inb(cmos_base + 1);
88     g_assert(actual == expected);
89 }
90
91 static void test_cmos_bytes(int reg0, int n, uint8_t expected[])
92 {
93     int i;
94
95     for (i = 0; i < 9; i++) {
96         test_cmos_byte(reg0 + i, expected[i]);
97     }
98 }
99
100 static void test_cmos_disk_data(void)
101 {
102     test_cmos_byte(0x12,
103                    (is_hd(cur_ide[0]) ? 0xf0 : 0) |
104                    (is_hd(cur_ide[1]) ? 0x0f : 0));
105 }
106
107 static void test_cmos_drive_cyl(int reg0, const CHST *expected_chst)
108 {
109     if (is_hd(expected_chst)) {
110         int c = expected_chst->cyls;
111         int h = expected_chst->heads;
112         int s = expected_chst->secs;
113         uint8_t expected_bytes[9] = {
114             c & 0xff, c >> 8, h, 0xff, 0xff, 0xc0 | ((h > 8) << 3),
115             c & 0xff, c >> 8, s
116         };
117         test_cmos_bytes(reg0, 9, expected_bytes);
118     } else {
119         int i;
120
121         for (i = 0; i < 9; i++) {
122             test_cmos_byte(reg0 + i, 0);
123         }
124     }
125 }
126
127 static void test_cmos_drive1(void)
128 {
129     test_cmos_byte(0x19, is_hd(cur_ide[0]) ? 47 : 0);
130     test_cmos_drive_cyl(0x1b, cur_ide[0]);
131 }
132
133 static void test_cmos_drive2(void)
134 {
135     test_cmos_byte(0x1a, is_hd(cur_ide[1]) ? 47 : 0);
136     test_cmos_drive_cyl(0x24, cur_ide[1]);
137 }
138
139 static void test_cmos_disktransflag(void)
140 {
141     int val, i;
142
143     val = 0;
144     for (i = 0; i < ARRAY_SIZE(cur_ide); i++) {
145         if (is_hd(cur_ide[i])) {
146             val |= cur_ide[i]->trans << (2 * i);
147         }
148     }
149     test_cmos_byte(0x39, val);
150 }
151
152 static void test_cmos(void)
153 {
154     test_cmos_disk_data();
155     test_cmos_drive1();
156     test_cmos_drive2();
157     test_cmos_disktransflag();
158 }
159
160 static int append_arg(int argc, char *argv[], int argv_sz, char *arg)
161 {
162     g_assert(argc + 1 < argv_sz);
163     argv[argc++] = arg;
164     argv[argc] = NULL;
165     return argc;
166 }
167
168 static int setup_common(char *argv[], int argv_sz)
169 {
170     memset(cur_ide, 0, sizeof(cur_ide));
171     return append_arg(0, argv, argv_sz,
172                       g_strdup("-nodefaults"));
173 }
174
175 static void setup_mbr(int img_idx, MBRcontents mbr)
176 {
177     static const uint8_t part_lba[16] = {
178         /* chs 0,1,1 (lba 63) to chs 0,127,63 (8001 sectors) */
179         0x80, 1, 1, 0, 6, 127, 63, 0, 63, 0, 0, 0, 0x41, 0x1F, 0, 0,
180     };
181     static const uint8_t part_chs[16] = {
182         /* chs 0,1,1 (lba 63) to chs 7,15,63 (8001 sectors) */
183         0x80, 1, 1, 0, 6,  15, 63, 7, 63, 0, 0, 0, 0x41, 0x1F, 0, 0,
184     };
185     uint8_t buf[512];
186     int fd, ret;
187
188     memset(buf, 0, sizeof(buf));
189
190     if (mbr != mbr_blank) {
191         buf[0x1fe] = 0x55;
192         buf[0x1ff] = 0xAA;
193         memcpy(buf + 0x1BE, mbr == mbr_lba ? part_lba : part_chs, 16);
194     }
195
196     fd = open(img_file_name[img_idx], O_WRONLY);
197     g_assert(fd >= 0);
198     ret = write(fd, buf, sizeof(buf));
199     g_assert(ret == sizeof(buf));
200     close(fd);
201 }
202
203 static int setup_ide(int argc, char *argv[], int argv_sz,
204                      int ide_idx, const char *dev, int img_idx,
205                      MBRcontents mbr, const char *opts)
206 {
207     char *s1, *s2, *s3;
208
209     s1 = g_strdup_printf("-drive id=drive%d,if=%s,format=raw",
210                          ide_idx, dev ? "none" : "ide");
211     s2 = dev ? g_strdup("") : g_strdup_printf(",index=%d", ide_idx);
212
213     if (img_secs[img_idx] >= 0) {
214         setup_mbr(img_idx, mbr);
215         s3 = g_strdup_printf(",file=%s", img_file_name[img_idx]);
216     } else {
217         s3 = g_strdup(",media=cdrom");
218     }
219     argc = append_arg(argc, argv, argv_sz,
220                       g_strdup_printf("%s%s%s%s", s1, s2, s3, opts));
221     g_free(s1);
222     g_free(s2);
223     g_free(s3);
224
225     if (dev) {
226         argc = append_arg(argc, argv, argv_sz,
227                           g_strdup_printf("-device %s,drive=drive%d,"
228                                           "bus=ide.%d,unit=%d",
229                                           dev, ide_idx,
230                                           ide_idx / 2, ide_idx % 2));
231     }
232     return argc;
233 }
234
235 /*
236  * Test case: no IDE devices
237  */
238 static void test_ide_none(void)
239 {
240     char *argv[256];
241
242     setup_common(argv, ARRAY_SIZE(argv));
243     qtest_start(g_strjoinv(" ", argv));
244     test_cmos();
245     qtest_end();
246 }
247
248 static void test_ide_mbr(bool use_device, MBRcontents mbr)
249 {
250     char *argv[256];
251     int argc;
252     Backend i;
253     const char *dev;
254
255     argc = setup_common(argv, ARRAY_SIZE(argv));
256     for (i = 0; i < backend_last; i++) {
257         cur_ide[i] = &hd_chst[i][mbr];
258         dev = use_device ? (is_hd(cur_ide[i]) ? "ide-hd" : "ide-cd") : NULL;
259         argc = setup_ide(argc, argv, ARRAY_SIZE(argv), i, dev, i, mbr, "");
260     }
261     qtest_start(g_strjoinv(" ", argv));
262     test_cmos();
263     qtest_end();
264 }
265
266 /*
267  * Test case: IDE devices (if=ide) with blank MBRs
268  */
269 static void test_ide_drive_mbr_blank(void)
270 {
271     test_ide_mbr(false, mbr_blank);
272 }
273
274 /*
275  * Test case: IDE devices (if=ide) with MBRs indicating LBA is in use
276  */
277 static void test_ide_drive_mbr_lba(void)
278 {
279     test_ide_mbr(false, mbr_lba);
280 }
281
282 /*
283  * Test case: IDE devices (if=ide) with MBRs indicating CHS is in use
284  */
285 static void test_ide_drive_mbr_chs(void)
286 {
287     test_ide_mbr(false, mbr_chs);
288 }
289
290 /*
291  * Test case: IDE devices (if=none) with blank MBRs
292  */
293 static void test_ide_device_mbr_blank(void)
294 {
295     test_ide_mbr(true, mbr_blank);
296 }
297
298 /*
299  * Test case: IDE devices (if=none) with MBRs indicating LBA is in use
300  */
301 static void test_ide_device_mbr_lba(void)
302 {
303     test_ide_mbr(true, mbr_lba);
304 }
305
306 /*
307  * Test case: IDE devices (if=none) with MBRs indicating CHS is in use
308  */
309 static void test_ide_device_mbr_chs(void)
310 {
311     test_ide_mbr(true, mbr_chs);
312 }
313
314 static void test_ide_drive_user(const char *dev, bool trans)
315 {
316     char *argv[256], *opts;
317     int argc;
318     int secs = img_secs[backend_small];
319     const CHST expected_chst = { secs / (4 * 32) , 4, 32, trans };
320
321     argc = setup_common(argv, ARRAY_SIZE(argv));
322     opts = g_strdup_printf("%s,%s%scyls=%d,heads=%d,secs=%d",
323                            dev ?: "",
324                            trans && dev ? "bios-chs-" : "",
325                            trans ? "trans=lba," : "",
326                            expected_chst.cyls, expected_chst.heads,
327                            expected_chst.secs);
328     cur_ide[0] = &expected_chst;
329     argc = setup_ide(argc, argv, ARRAY_SIZE(argv),
330                      0, dev ? opts : NULL, backend_small, mbr_chs,
331                      dev ? "" : opts);
332     g_free(opts);
333     qtest_start(g_strjoinv(" ", argv));
334     test_cmos();
335     qtest_end();
336 }
337
338 /*
339  * Test case: IDE device (if=ide) with explicit CHS
340  */
341 static void test_ide_drive_user_chs(void)
342 {
343     test_ide_drive_user(NULL, false);
344 }
345
346 /*
347  * Test case: IDE device (if=ide) with explicit CHS and translation
348  */
349 static void test_ide_drive_user_chst(void)
350 {
351     test_ide_drive_user(NULL, true);
352 }
353
354 /*
355  * Test case: IDE device (if=none) with explicit CHS
356  */
357 static void test_ide_device_user_chs(void)
358 {
359     test_ide_drive_user("ide-hd", false);
360 }
361
362 /*
363  * Test case: IDE device (if=none) with explicit CHS and translation
364  */
365 static void test_ide_device_user_chst(void)
366 {
367     test_ide_drive_user("ide-hd", true);
368 }
369
370 /*
371  * Test case: IDE devices (if=ide), but use index=0 for CD-ROM
372  */
373 static void test_ide_drive_cd_0(void)
374 {
375     char *argv[256];
376     int argc, ide_idx;
377     Backend i;
378
379     argc = setup_common(argv, ARRAY_SIZE(argv));
380     for (i = 0; i <= backend_empty; i++) {
381         ide_idx = backend_empty - i;
382         cur_ide[ide_idx] = &hd_chst[i][mbr_blank];
383         argc = setup_ide(argc, argv, ARRAY_SIZE(argv),
384                          ide_idx, NULL, i, mbr_blank, "");
385     }
386     qtest_start(g_strjoinv(" ", argv));
387     test_cmos();
388     qtest_end();
389 }
390
391 int main(int argc, char **argv)
392 {
393     Backend i;
394     int ret;
395
396     g_test_init(&argc, &argv, NULL);
397
398     for (i = 0; i < backend_last; i++) {
399         if (img_secs[i] >= 0) {
400             img_file_name[i] = create_test_img(img_secs[i]);
401         } else {
402             img_file_name[i] = NULL;
403         }
404     }
405
406     qtest_add_func("hd-geo/ide/none", test_ide_none);
407     qtest_add_func("hd-geo/ide/drive/mbr/blank", test_ide_drive_mbr_blank);
408     qtest_add_func("hd-geo/ide/drive/mbr/lba", test_ide_drive_mbr_lba);
409     qtest_add_func("hd-geo/ide/drive/mbr/chs", test_ide_drive_mbr_chs);
410     qtest_add_func("hd-geo/ide/drive/user/chs", test_ide_drive_user_chs);
411     qtest_add_func("hd-geo/ide/drive/user/chst", test_ide_drive_user_chst);
412     qtest_add_func("hd-geo/ide/drive/cd_0", test_ide_drive_cd_0);
413     qtest_add_func("hd-geo/ide/device/mbr/blank", test_ide_device_mbr_blank);
414     qtest_add_func("hd-geo/ide/device/mbr/lba", test_ide_device_mbr_lba);
415     qtest_add_func("hd-geo/ide/device/mbr/chs", test_ide_device_mbr_chs);
416     qtest_add_func("hd-geo/ide/device/user/chs", test_ide_device_user_chs);
417     qtest_add_func("hd-geo/ide/device/user/chst", test_ide_device_user_chst);
418
419     ret = g_test_run();
420
421     for (i = 0; i < backend_last; i++) {
422         unlink(img_file_name[i]);
423     }
424
425     return ret;
426 }