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