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#include "qemu/osdep.h"
26
27
28#include "libqtest.h"
29#include "libqos/libqos.h"
30#include "libqos/pci-pc.h"
31#include "libqos/malloc-pc.h"
32
33#include "qemu-common.h"
34#include "qemu/bswap.h"
35#include "hw/pci/pci_ids.h"
36#include "hw/pci/pci_regs.h"
37
38#define TEST_IMAGE_SIZE 64 * 1024 * 1024
39
40#define IDE_PCI_DEV 1
41#define IDE_PCI_FUNC 1
42
43#define IDE_BASE 0x1f0
44#define IDE_PRIMARY_IRQ 14
45
46#define ATAPI_BLOCK_SIZE 2048
47
48
49
50#define BYTE_COUNT_LIMIT 5120
51
52enum {
53 reg_data = 0x0,
54 reg_feature = 0x1,
55 reg_error = 0x1,
56 reg_nsectors = 0x2,
57 reg_lba_low = 0x3,
58 reg_lba_middle = 0x4,
59 reg_lba_high = 0x5,
60 reg_device = 0x6,
61 reg_status = 0x7,
62 reg_command = 0x7,
63};
64
65enum {
66 BSY = 0x80,
67 DRDY = 0x40,
68 DF = 0x20,
69 DRQ = 0x08,
70 ERR = 0x01,
71};
72
73
74enum {
75 ABRT = 0x04,
76};
77
78enum {
79 DEV = 0x10,
80 LBA = 0x40,
81};
82
83enum {
84 bmreg_cmd = 0x0,
85 bmreg_status = 0x2,
86 bmreg_prdt = 0x4,
87};
88
89enum {
90 CMD_DSM = 0x06,
91 CMD_READ_DMA = 0xc8,
92 CMD_WRITE_DMA = 0xca,
93 CMD_FLUSH_CACHE = 0xe7,
94 CMD_IDENTIFY = 0xec,
95 CMD_PACKET = 0xa0,
96
97 CMDF_ABORT = 0x100,
98 CMDF_NO_BM = 0x200,
99};
100
101enum {
102 BM_CMD_START = 0x1,
103 BM_CMD_WRITE = 0x8,
104};
105
106enum {
107 BM_STS_ACTIVE = 0x1,
108 BM_STS_ERROR = 0x2,
109 BM_STS_INTR = 0x4,
110};
111
112enum {
113 PRDT_EOT = 0x80000000,
114};
115
116#define assert_bit_set(data, mask) g_assert_cmphex((data) & (mask), ==, (mask))
117#define assert_bit_clear(data, mask) g_assert_cmphex((data) & (mask), ==, 0)
118
119static QPCIBus *pcibus = NULL;
120static QGuestAllocator *guest_malloc;
121
122static char tmp_path[] = "/tmp/qtest.XXXXXX";
123static char debug_path[] = "/tmp/qtest-blkdebug.XXXXXX";
124
125static void ide_test_start(const char *cmdline_fmt, ...)
126{
127 va_list ap;
128 char *cmdline;
129
130 va_start(ap, cmdline_fmt);
131 cmdline = g_strdup_vprintf(cmdline_fmt, ap);
132 va_end(ap);
133
134 qtest_start(cmdline);
135 guest_malloc = pc_alloc_init(global_qtest);
136
137 g_free(cmdline);
138}
139
140static void ide_test_quit(void)
141{
142 pc_alloc_uninit(guest_malloc);
143 guest_malloc = NULL;
144 qtest_end();
145}
146
147static QPCIDevice *get_pci_device(QPCIBar *bmdma_bar, QPCIBar *ide_bar)
148{
149 QPCIDevice *dev;
150 uint16_t vendor_id, device_id;
151
152 if (!pcibus) {
153 pcibus = qpci_init_pc(global_qtest, NULL);
154 }
155
156
157 dev = qpci_device_find(pcibus, QPCI_DEVFN(IDE_PCI_DEV, IDE_PCI_FUNC));
158 g_assert(dev != NULL);
159
160 vendor_id = qpci_config_readw(dev, PCI_VENDOR_ID);
161 device_id = qpci_config_readw(dev, PCI_DEVICE_ID);
162 g_assert(vendor_id == PCI_VENDOR_ID_INTEL);
163 g_assert(device_id == PCI_DEVICE_ID_INTEL_82371SB_1);
164
165
166 *bmdma_bar = qpci_iomap(dev, 4, NULL);
167
168 *ide_bar = qpci_legacy_iomap(dev, IDE_BASE);
169
170 qpci_device_enable(dev);
171
172 return dev;
173}
174
175static void free_pci_device(QPCIDevice *dev)
176{
177
178 g_free(dev);
179}
180
181typedef struct PrdtEntry {
182 uint32_t addr;
183 uint32_t size;
184} QEMU_PACKED PrdtEntry;
185
186#define assert_bit_set(data, mask) g_assert_cmphex((data) & (mask), ==, (mask))
187#define assert_bit_clear(data, mask) g_assert_cmphex((data) & (mask), ==, 0)
188
189static uint64_t trim_range_le(uint64_t sector, uint16_t count)
190{
191
192 return cpu_to_le64(((uint64_t)count << 48) + sector);
193}
194
195static int send_dma_request(int cmd, uint64_t sector, int nb_sectors,
196 PrdtEntry *prdt, int prdt_entries,
197 void(*post_exec)(QPCIDevice *dev, QPCIBar ide_bar,
198 uint64_t sector, int nb_sectors))
199{
200 QPCIDevice *dev;
201 QPCIBar bmdma_bar, ide_bar;
202 uintptr_t guest_prdt;
203 size_t len;
204 bool from_dev;
205 uint8_t status;
206 int flags;
207
208 dev = get_pci_device(&bmdma_bar, &ide_bar);
209
210 flags = cmd & ~0xff;
211 cmd &= 0xff;
212
213 switch (cmd) {
214 case CMD_READ_DMA:
215 case CMD_PACKET:
216
217
218 from_dev = true;
219 break;
220 case CMD_DSM:
221 case CMD_WRITE_DMA:
222 from_dev = false;
223 break;
224 default:
225 g_assert_not_reached();
226 }
227
228 if (flags & CMDF_NO_BM) {
229 qpci_config_writew(dev, PCI_COMMAND,
230 PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
231 }
232
233
234 qpci_io_writeb(dev, ide_bar, reg_device, 0 | LBA);
235
236
237 qpci_io_writeb(dev, bmdma_bar, bmreg_cmd, 0);
238 qpci_io_writeb(dev, bmdma_bar, bmreg_status, BM_STS_INTR);
239
240
241 len = sizeof(*prdt) * prdt_entries;
242 guest_prdt = guest_alloc(guest_malloc, len);
243 memwrite(guest_prdt, prdt, len);
244 qpci_io_writel(dev, bmdma_bar, bmreg_prdt, guest_prdt);
245
246
247 if (cmd == CMD_PACKET) {
248
249 qpci_io_writeb(dev, ide_bar, reg_feature, 0x01);
250 } else {
251 if (cmd == CMD_DSM) {
252
253 qpci_io_writeb(dev, ide_bar, reg_feature, 0x01);
254 }
255 qpci_io_writeb(dev, ide_bar, reg_nsectors, nb_sectors);
256 qpci_io_writeb(dev, ide_bar, reg_lba_low, sector & 0xff);
257 qpci_io_writeb(dev, ide_bar, reg_lba_middle, (sector >> 8) & 0xff);
258 qpci_io_writeb(dev, ide_bar, reg_lba_high, (sector >> 16) & 0xff);
259 }
260
261 qpci_io_writeb(dev, ide_bar, reg_command, cmd);
262
263 if (post_exec) {
264 post_exec(dev, ide_bar, sector, nb_sectors);
265 }
266
267
268 qpci_io_writeb(dev, bmdma_bar, bmreg_cmd,
269 BM_CMD_START | (from_dev ? BM_CMD_WRITE : 0));
270
271 if (flags & CMDF_ABORT) {
272 qpci_io_writeb(dev, bmdma_bar, bmreg_cmd, 0);
273 }
274
275
276 do {
277 status = qpci_io_readb(dev, bmdma_bar, bmreg_status);
278 } while ((status & (BM_STS_ACTIVE | BM_STS_INTR)) == BM_STS_ACTIVE);
279
280 g_assert_cmpint(get_irq(IDE_PRIMARY_IRQ), ==, !!(status & BM_STS_INTR));
281
282
283 assert_bit_set(qpci_io_readb(dev, ide_bar, reg_status), DRDY);
284 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), BSY | DRQ);
285
286
287 g_assert(!get_irq(IDE_PRIMARY_IRQ));
288
289
290 if (status & BM_STS_ACTIVE) {
291 qpci_io_writeb(dev, bmdma_bar, bmreg_cmd, 0);
292 }
293
294 free_pci_device(dev);
295
296 return status;
297}
298
299static void test_bmdma_simple_rw(void)
300{
301 QPCIDevice *dev;
302 QPCIBar bmdma_bar, ide_bar;
303 uint8_t status;
304 uint8_t *buf;
305 uint8_t *cmpbuf;
306 size_t len = 512;
307 uintptr_t guest_buf = guest_alloc(guest_malloc, len);
308
309 PrdtEntry prdt[] = {
310 {
311 .addr = cpu_to_le32(guest_buf),
312 .size = cpu_to_le32(len | PRDT_EOT),
313 },
314 };
315
316 dev = get_pci_device(&bmdma_bar, &ide_bar);
317
318 buf = g_malloc(len);
319 cmpbuf = g_malloc(len);
320
321
322 memset(buf, 0x55, len);
323 memwrite(guest_buf, buf, len);
324
325 status = send_dma_request(CMD_WRITE_DMA, 0, 1, prdt,
326 ARRAY_SIZE(prdt), NULL);
327 g_assert_cmphex(status, ==, BM_STS_INTR);
328 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
329
330
331 memset(buf, 0xaa, len);
332 memwrite(guest_buf, buf, len);
333
334 status = send_dma_request(CMD_WRITE_DMA, 1, 1, prdt,
335 ARRAY_SIZE(prdt), NULL);
336 g_assert_cmphex(status, ==, BM_STS_INTR);
337 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
338
339
340 memset(cmpbuf, 0x55, len);
341
342 status = send_dma_request(CMD_READ_DMA, 0, 1, prdt, ARRAY_SIZE(prdt), NULL);
343 g_assert_cmphex(status, ==, BM_STS_INTR);
344 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
345
346 memread(guest_buf, buf, len);
347 g_assert(memcmp(buf, cmpbuf, len) == 0);
348
349
350 memset(cmpbuf, 0xaa, len);
351
352 status = send_dma_request(CMD_READ_DMA, 1, 1, prdt, ARRAY_SIZE(prdt), NULL);
353 g_assert_cmphex(status, ==, BM_STS_INTR);
354 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
355
356 memread(guest_buf, buf, len);
357 g_assert(memcmp(buf, cmpbuf, len) == 0);
358
359
360 free_pci_device(dev);
361 g_free(buf);
362 g_free(cmpbuf);
363}
364
365static void test_bmdma_trim(void)
366{
367 QPCIDevice *dev;
368 QPCIBar bmdma_bar, ide_bar;
369 uint8_t status;
370 const uint64_t trim_range[] = { trim_range_le(0, 2),
371 trim_range_le(6, 8),
372 trim_range_le(10, 1),
373 };
374 const uint64_t bad_range = trim_range_le(TEST_IMAGE_SIZE / 512 - 1, 2);
375 size_t len = 512;
376 uint8_t *buf;
377 uintptr_t guest_buf = guest_alloc(guest_malloc, len);
378
379 PrdtEntry prdt[] = {
380 {
381 .addr = cpu_to_le32(guest_buf),
382 .size = cpu_to_le32(len | PRDT_EOT),
383 },
384 };
385
386 dev = get_pci_device(&bmdma_bar, &ide_bar);
387
388 buf = g_malloc(len);
389
390
391 *((uint64_t *)buf) = trim_range[0];
392 *((uint64_t *)buf + 1) = trim_range[1];
393
394 memwrite(guest_buf, buf, 2 * sizeof(uint64_t));
395
396 status = send_dma_request(CMD_DSM, 0, 1, prdt,
397 ARRAY_SIZE(prdt), NULL);
398 g_assert_cmphex(status, ==, BM_STS_INTR);
399 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
400
401
402 *((uint64_t *)buf) = trim_range[2];
403 *((uint64_t *)buf + 1) = bad_range;
404
405 memwrite(guest_buf, buf, 2 * sizeof(uint64_t));
406
407 status = send_dma_request(CMD_DSM, 0, 1, prdt,
408 ARRAY_SIZE(prdt), NULL);
409 g_assert_cmphex(status, ==, BM_STS_INTR);
410 assert_bit_set(qpci_io_readb(dev, ide_bar, reg_status), ERR);
411 assert_bit_set(qpci_io_readb(dev, ide_bar, reg_error), ABRT);
412
413 free_pci_device(dev);
414 g_free(buf);
415}
416
417static void test_bmdma_short_prdt(void)
418{
419 QPCIDevice *dev;
420 QPCIBar bmdma_bar, ide_bar;
421 uint8_t status;
422
423 PrdtEntry prdt[] = {
424 {
425 .addr = 0,
426 .size = cpu_to_le32(0x10 | PRDT_EOT),
427 },
428 };
429
430 dev = get_pci_device(&bmdma_bar, &ide_bar);
431
432
433 status = send_dma_request(CMD_READ_DMA, 0, 1,
434 prdt, ARRAY_SIZE(prdt), NULL);
435 g_assert_cmphex(status, ==, 0);
436 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
437
438
439 status = send_dma_request(CMD_READ_DMA | CMDF_ABORT, 0, 1,
440 prdt, ARRAY_SIZE(prdt), NULL);
441 g_assert_cmphex(status, ==, 0);
442 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
443 free_pci_device(dev);
444}
445
446static void test_bmdma_one_sector_short_prdt(void)
447{
448 QPCIDevice *dev;
449 QPCIBar bmdma_bar, ide_bar;
450 uint8_t status;
451
452
453 PrdtEntry prdt[] = {
454 {
455 .addr = 0,
456 .size = cpu_to_le32(0x200 | PRDT_EOT),
457 },
458 };
459
460 dev = get_pci_device(&bmdma_bar, &ide_bar);
461
462
463 status = send_dma_request(CMD_READ_DMA, 0, 2,
464 prdt, ARRAY_SIZE(prdt), NULL);
465 g_assert_cmphex(status, ==, 0);
466 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
467
468
469 status = send_dma_request(CMD_READ_DMA | CMDF_ABORT, 0, 2,
470 prdt, ARRAY_SIZE(prdt), NULL);
471 g_assert_cmphex(status, ==, 0);
472 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
473 free_pci_device(dev);
474}
475
476static void test_bmdma_long_prdt(void)
477{
478 QPCIDevice *dev;
479 QPCIBar bmdma_bar, ide_bar;
480 uint8_t status;
481
482 PrdtEntry prdt[] = {
483 {
484 .addr = 0,
485 .size = cpu_to_le32(0x1000 | PRDT_EOT),
486 },
487 };
488
489 dev = get_pci_device(&bmdma_bar, &ide_bar);
490
491
492 status = send_dma_request(CMD_READ_DMA, 0, 1,
493 prdt, ARRAY_SIZE(prdt), NULL);
494 g_assert_cmphex(status, ==, BM_STS_ACTIVE | BM_STS_INTR);
495 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
496
497
498 status = send_dma_request(CMD_READ_DMA | CMDF_ABORT, 0, 1,
499 prdt, ARRAY_SIZE(prdt), NULL);
500 g_assert_cmphex(status, ==, BM_STS_INTR);
501 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
502 free_pci_device(dev);
503}
504
505static void test_bmdma_no_busmaster(void)
506{
507 QPCIDevice *dev;
508 QPCIBar bmdma_bar, ide_bar;
509 uint8_t status;
510
511 dev = get_pci_device(&bmdma_bar, &ide_bar);
512
513
514
515
516
517 PrdtEntry prdt[4096] = { };
518
519 status = send_dma_request(CMD_READ_DMA | CMDF_NO_BM, 0, 512,
520 prdt, ARRAY_SIZE(prdt), NULL);
521
522
523
524 g_assert_cmphex(status, ==, BM_STS_ACTIVE | BM_STS_INTR);
525 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
526 free_pci_device(dev);
527}
528
529static void test_bmdma_setup(void)
530{
531 ide_test_start(
532 "-drive file=%s,if=ide,serial=%s,cache=writeback,format=raw "
533 "-global ide-hd.ver=%s",
534 tmp_path, "testdisk", "version");
535 qtest_irq_intercept_in(global_qtest, "ioapic");
536}
537
538static void test_bmdma_teardown(void)
539{
540 ide_test_quit();
541}
542
543static void string_cpu_to_be16(uint16_t *s, size_t bytes)
544{
545 g_assert((bytes & 1) == 0);
546 bytes /= 2;
547
548 while (bytes--) {
549 *s = cpu_to_be16(*s);
550 s++;
551 }
552}
553
554static void test_identify(void)
555{
556 QPCIDevice *dev;
557 QPCIBar bmdma_bar, ide_bar;
558 uint8_t data;
559 uint16_t buf[256];
560 int i;
561 int ret;
562
563 ide_test_start(
564 "-drive file=%s,if=ide,serial=%s,cache=writeback,format=raw "
565 "-global ide-hd.ver=%s",
566 tmp_path, "testdisk", "version");
567
568 dev = get_pci_device(&bmdma_bar, &ide_bar);
569
570
571 qpci_io_writeb(dev, ide_bar, reg_device, 0);
572 qpci_io_writeb(dev, ide_bar, reg_command, CMD_IDENTIFY);
573
574
575 data = qpci_io_readb(dev, ide_bar, reg_device);
576 g_assert_cmpint(data & DEV, ==, 0);
577
578 for (i = 0; i < 256; i++) {
579 data = qpci_io_readb(dev, ide_bar, reg_status);
580 assert_bit_set(data, DRDY | DRQ);
581 assert_bit_clear(data, BSY | DF | ERR);
582
583 buf[i] = qpci_io_readw(dev, ide_bar, reg_data);
584 }
585
586 data = qpci_io_readb(dev, ide_bar, reg_status);
587 assert_bit_set(data, DRDY);
588 assert_bit_clear(data, BSY | DF | ERR | DRQ);
589
590
591 string_cpu_to_be16(&buf[10], 20);
592 ret = memcmp(&buf[10], "testdisk ", 20);
593 g_assert(ret == 0);
594
595 string_cpu_to_be16(&buf[23], 8);
596 ret = memcmp(&buf[23], "version ", 8);
597 g_assert(ret == 0);
598
599
600 assert_bit_set(buf[85], 0x20);
601
602 ide_test_quit();
603 free_pci_device(dev);
604}
605
606
607
608
609
610static void make_dirty(uint8_t device)
611{
612 QPCIDevice *dev;
613 QPCIBar bmdma_bar, ide_bar;
614 uint8_t status;
615 size_t len = 512;
616 uintptr_t guest_buf;
617 void* buf;
618
619 dev = get_pci_device(&bmdma_bar, &ide_bar);
620
621 guest_buf = guest_alloc(guest_malloc, len);
622 buf = g_malloc(len);
623 memset(buf, rand() % 255 + 1, len);
624 g_assert(guest_buf);
625 g_assert(buf);
626
627 memwrite(guest_buf, buf, len);
628
629 PrdtEntry prdt[] = {
630 {
631 .addr = cpu_to_le32(guest_buf),
632 .size = cpu_to_le32(len | PRDT_EOT),
633 },
634 };
635
636 status = send_dma_request(CMD_WRITE_DMA, 1, 1, prdt,
637 ARRAY_SIZE(prdt), NULL);
638 g_assert_cmphex(status, ==, BM_STS_INTR);
639 assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
640
641 g_free(buf);
642 free_pci_device(dev);
643}
644
645static void test_flush(void)
646{
647 QPCIDevice *dev;
648 QPCIBar bmdma_bar, ide_bar;
649 uint8_t data;
650
651 ide_test_start(
652 "-drive file=blkdebug::%s,if=ide,cache=writeback,format=raw",
653 tmp_path);
654
655 dev = get_pci_device(&bmdma_bar, &ide_bar);
656
657 qtest_irq_intercept_in(global_qtest, "ioapic");
658
659
660 make_dirty(0);
661
662
663 g_free(hmp("qemu-io ide0-hd0 \"break flush_to_os A\""));
664
665
666 qpci_io_writeb(dev, ide_bar, reg_device, 0);
667 qpci_io_writeb(dev, ide_bar, reg_command, CMD_FLUSH_CACHE);
668
669
670 data = qpci_io_readb(dev, ide_bar, reg_status);
671 assert_bit_set(data, BSY | DRDY);
672 assert_bit_clear(data, DF | ERR | DRQ);
673
674
675 g_free(hmp("qemu-io ide0-hd0 \"resume A\""));
676
677
678 data = qpci_io_readb(dev, ide_bar, reg_device);
679 g_assert_cmpint(data & DEV, ==, 0);
680
681 do {
682 data = qpci_io_readb(dev, ide_bar, reg_status);
683 } while (data & BSY);
684
685 assert_bit_set(data, DRDY);
686 assert_bit_clear(data, BSY | DF | ERR | DRQ);
687
688 ide_test_quit();
689 free_pci_device(dev);
690}
691
692static void test_retry_flush(const char *machine)
693{
694 QPCIDevice *dev;
695 QPCIBar bmdma_bar, ide_bar;
696 uint8_t data;
697 const char *s;
698
699 prepare_blkdebug_script(debug_path, "flush_to_disk");
700
701 ide_test_start(
702 "-drive file=blkdebug:%s:%s,if=ide,cache=writeback,format=raw,"
703 "rerror=stop,werror=stop",
704 debug_path, tmp_path);
705
706 dev = get_pci_device(&bmdma_bar, &ide_bar);
707
708 qtest_irq_intercept_in(global_qtest, "ioapic");
709
710
711 make_dirty(0);
712
713
714 qpci_io_writeb(dev, ide_bar, reg_device, 0);
715 qpci_io_writeb(dev, ide_bar, reg_command, CMD_FLUSH_CACHE);
716
717
718 data = qpci_io_readb(dev, ide_bar, reg_status);
719 assert_bit_set(data, BSY | DRDY);
720 assert_bit_clear(data, DF | ERR | DRQ);
721
722 qmp_eventwait("STOP");
723
724
725 s = "{'execute':'cont' }";
726 qmp_discard_response(s);
727
728
729 data = qpci_io_readb(dev, ide_bar, reg_device);
730 g_assert_cmpint(data & DEV, ==, 0);
731
732 do {
733 data = qpci_io_readb(dev, ide_bar, reg_status);
734 } while (data & BSY);
735
736 assert_bit_set(data, DRDY);
737 assert_bit_clear(data, BSY | DF | ERR | DRQ);
738
739 ide_test_quit();
740 free_pci_device(dev);
741}
742
743static void test_flush_nodev(void)
744{
745 QPCIDevice *dev;
746 QPCIBar bmdma_bar, ide_bar;
747
748 ide_test_start("");
749
750 dev = get_pci_device(&bmdma_bar, &ide_bar);
751
752
753 qpci_io_writeb(dev, ide_bar, reg_device, 0);
754 qpci_io_writeb(dev, ide_bar, reg_command, CMD_FLUSH_CACHE);
755
756
757
758 free_pci_device(dev);
759 ide_test_quit();
760}
761
762static void test_flush_empty_drive(void)
763{
764 QPCIDevice *dev;
765 QPCIBar bmdma_bar, ide_bar;
766
767 ide_test_start("-device ide-cd,bus=ide.0");
768 dev = get_pci_device(&bmdma_bar, &ide_bar);
769
770
771 qpci_io_writeb(dev, ide_bar, reg_device, 0);
772 qpci_io_writeb(dev, ide_bar, reg_command, CMD_FLUSH_CACHE);
773
774
775
776 free_pci_device(dev);
777 ide_test_quit();
778}
779
780static void test_pci_retry_flush(void)
781{
782 test_retry_flush("pc");
783}
784
785static void test_isa_retry_flush(void)
786{
787 test_retry_flush("isapc");
788}
789
790typedef struct Read10CDB {
791 uint8_t opcode;
792 uint8_t flags;
793 uint32_t lba;
794 uint8_t reserved;
795 uint16_t nblocks;
796 uint8_t control;
797 uint16_t padding;
798} __attribute__((__packed__)) Read10CDB;
799
800static void send_scsi_cdb_read10(QPCIDevice *dev, QPCIBar ide_bar,
801 uint64_t lba, int nblocks)
802{
803 Read10CDB pkt = { .padding = 0 };
804 int i;
805
806 g_assert_cmpint(lba, <=, UINT32_MAX);
807 g_assert_cmpint(nblocks, <=, UINT16_MAX);
808 g_assert_cmpint(nblocks, >=, 0);
809
810
811 pkt.opcode = 0x28;
812 pkt.lba = cpu_to_be32(lba);
813 pkt.nblocks = cpu_to_be16(nblocks);
814
815
816 for (i = 0; i < sizeof(Read10CDB)/2; i++) {
817 qpci_io_writew(dev, ide_bar, reg_data,
818 le16_to_cpu(((uint16_t *)&pkt)[i]));
819 }
820}
821
822static void nsleep(int64_t nsecs)
823{
824 const struct timespec val = { .tv_nsec = nsecs };
825 nanosleep(&val, NULL);
826 clock_set(nsecs);
827}
828
829static uint8_t ide_wait_clear(uint8_t flag)
830{
831 QPCIDevice *dev;
832 QPCIBar bmdma_bar, ide_bar;
833 uint8_t data;
834 time_t st;
835
836 dev = get_pci_device(&bmdma_bar, &ide_bar);
837
838
839 time(&st);
840 while (true) {
841 data = qpci_io_readb(dev, ide_bar, reg_status);
842 if (!(data & flag)) {
843 free_pci_device(dev);
844 return data;
845 }
846 if (difftime(time(NULL), st) > 5.0) {
847 break;
848 }
849 nsleep(400);
850 }
851 g_assert_not_reached();
852}
853
854static void ide_wait_intr(int irq)
855{
856 time_t st;
857 bool intr;
858
859 time(&st);
860 while (true) {
861 intr = get_irq(irq);
862 if (intr) {
863 return;
864 }
865 if (difftime(time(NULL), st) > 5.0) {
866 break;
867 }
868 nsleep(400);
869 }
870
871 g_assert_not_reached();
872}
873
874static void cdrom_pio_impl(int nblocks)
875{
876 QPCIDevice *dev;
877 QPCIBar bmdma_bar, ide_bar;
878 FILE *fh;
879 int patt_blocks = MAX(16, nblocks);
880 size_t patt_len = ATAPI_BLOCK_SIZE * patt_blocks;
881 char *pattern = g_malloc(patt_len);
882 size_t rxsize = ATAPI_BLOCK_SIZE * nblocks;
883 uint16_t *rx = g_malloc0(rxsize);
884 int i, j;
885 uint8_t data;
886 uint16_t limit;
887 size_t ret;
888
889
890 generate_pattern(pattern, patt_len, ATAPI_BLOCK_SIZE);
891 fh = fopen(tmp_path, "w+");
892 ret = fwrite(pattern, ATAPI_BLOCK_SIZE, patt_blocks, fh);
893 g_assert_cmpint(ret, ==, patt_blocks);
894 fclose(fh);
895
896 ide_test_start("-drive if=none,file=%s,media=cdrom,format=raw,id=sr0,index=0 "
897 "-device ide-cd,drive=sr0,bus=ide.0", tmp_path);
898 dev = get_pci_device(&bmdma_bar, &ide_bar);
899 qtest_irq_intercept_in(global_qtest, "ioapic");
900
901
902 qpci_io_writeb(dev, ide_bar, reg_device, 0);
903 qpci_io_writeb(dev, ide_bar, reg_lba_middle, BYTE_COUNT_LIMIT & 0xFF);
904 qpci_io_writeb(dev, ide_bar, reg_lba_high, (BYTE_COUNT_LIMIT >> 8 & 0xFF));
905 qpci_io_writeb(dev, ide_bar, reg_command, CMD_PACKET);
906
907 nsleep(400);
908 data = ide_wait_clear(BSY);
909
910 assert_bit_set(data, DRQ | DRDY);
911 assert_bit_clear(data, ERR | DF | BSY);
912
913
914 send_scsi_cdb_read10(dev, ide_bar, 0, nblocks);
915
916
917
918
919
920
921
922 g_assert(!(rxsize & 1));
923 limit = BYTE_COUNT_LIMIT & ~1;
924 for (i = 0; i < DIV_ROUND_UP(rxsize, limit); i++) {
925 size_t offset = i * (limit / 2);
926 size_t rem = (rxsize / 2) - offset;
927
928
929 ide_wait_intr(IDE_PRIMARY_IRQ);
930
931
932 data = ide_wait_clear(BSY);
933 assert_bit_set(data, DRQ | DRDY);
934 assert_bit_clear(data, ERR | DF | BSY);
935
936
937 for (j = 0; j < MIN((limit / 2), rem); j++) {
938 rx[offset + j] = cpu_to_le16(qpci_io_readw(dev, ide_bar,
939 reg_data));
940 }
941 }
942
943
944 ide_wait_intr(IDE_PRIMARY_IRQ);
945
946
947 data = ide_wait_clear(DRQ);
948 assert_bit_set(data, DRDY);
949 assert_bit_clear(data, DRQ | ERR | DF | BSY);
950
951 g_assert_cmpint(memcmp(pattern, rx, rxsize), ==, 0);
952 g_free(pattern);
953 g_free(rx);
954 test_bmdma_teardown();
955 free_pci_device(dev);
956}
957
958static void test_cdrom_pio(void)
959{
960 cdrom_pio_impl(1);
961}
962
963static void test_cdrom_pio_large(void)
964{
965
966 cdrom_pio_impl(BYTE_COUNT_LIMIT * 4 / ATAPI_BLOCK_SIZE);
967}
968
969
970static void test_cdrom_dma(void)
971{
972 static const size_t len = ATAPI_BLOCK_SIZE;
973 size_t ret;
974 char *pattern = g_malloc(ATAPI_BLOCK_SIZE * 16);
975 char *rx = g_malloc0(len);
976 uintptr_t guest_buf;
977 PrdtEntry prdt[1];
978 FILE *fh;
979
980 ide_test_start("-drive if=none,file=%s,media=cdrom,format=raw,id=sr0,index=0 "
981 "-device ide-cd,drive=sr0,bus=ide.0", tmp_path);
982 qtest_irq_intercept_in(global_qtest, "ioapic");
983
984 guest_buf = guest_alloc(guest_malloc, len);
985 prdt[0].addr = cpu_to_le32(guest_buf);
986 prdt[0].size = cpu_to_le32(len | PRDT_EOT);
987
988 generate_pattern(pattern, ATAPI_BLOCK_SIZE * 16, ATAPI_BLOCK_SIZE);
989 fh = fopen(tmp_path, "w+");
990 ret = fwrite(pattern, ATAPI_BLOCK_SIZE, 16, fh);
991 g_assert_cmpint(ret, ==, 16);
992 fclose(fh);
993
994 send_dma_request(CMD_PACKET, 0, 1, prdt, 1, send_scsi_cdb_read10);
995
996
997 memread(guest_buf, rx, len);
998 g_assert_cmpint(memcmp(pattern, rx, len), ==, 0);
999
1000 g_free(pattern);
1001 g_free(rx);
1002 test_bmdma_teardown();
1003}
1004
1005int main(int argc, char **argv)
1006{
1007 const char *arch = qtest_get_arch();
1008 int fd;
1009 int ret;
1010
1011
1012 if (strcmp(arch, "i386") && strcmp(arch, "x86_64")) {
1013 g_test_message("Skipping test for non-x86\n");
1014 return 0;
1015 }
1016
1017
1018 fd = mkstemp(debug_path);
1019 g_assert(fd >= 0);
1020 close(fd);
1021
1022
1023 fd = mkstemp(tmp_path);
1024 g_assert(fd >= 0);
1025 ret = ftruncate(fd, TEST_IMAGE_SIZE);
1026 g_assert(ret == 0);
1027 close(fd);
1028
1029
1030 g_test_init(&argc, &argv, NULL);
1031
1032 qtest_add_func("/ide/identify", test_identify);
1033
1034 qtest_add_func("/ide/bmdma/setup", test_bmdma_setup);
1035 qtest_add_func("/ide/bmdma/simple_rw", test_bmdma_simple_rw);
1036 qtest_add_func("/ide/bmdma/trim", test_bmdma_trim);
1037 qtest_add_func("/ide/bmdma/short_prdt", test_bmdma_short_prdt);
1038 qtest_add_func("/ide/bmdma/one_sector_short_prdt",
1039 test_bmdma_one_sector_short_prdt);
1040 qtest_add_func("/ide/bmdma/long_prdt", test_bmdma_long_prdt);
1041 qtest_add_func("/ide/bmdma/no_busmaster", test_bmdma_no_busmaster);
1042 qtest_add_func("/ide/bmdma/teardown", test_bmdma_teardown);
1043
1044 qtest_add_func("/ide/flush", test_flush);
1045 qtest_add_func("/ide/flush/nodev", test_flush_nodev);
1046 qtest_add_func("/ide/flush/empty_drive", test_flush_empty_drive);
1047 qtest_add_func("/ide/flush/retry_pci", test_pci_retry_flush);
1048 qtest_add_func("/ide/flush/retry_isa", test_isa_retry_flush);
1049
1050 qtest_add_func("/ide/cdrom/pio", test_cdrom_pio);
1051 qtest_add_func("/ide/cdrom/pio_large", test_cdrom_pio_large);
1052 qtest_add_func("/ide/cdrom/dma", test_cdrom_dma);
1053
1054 ret = g_test_run();
1055
1056
1057 unlink(tmp_path);
1058 unlink(debug_path);
1059
1060 return ret;
1061}
1062