Revision 41cb62c2 kvm-all.c

b/kvm-all.c
501 501
}
502 502

  
503 503
static int kvm_set_ioeventfd_mmio(int fd, uint32_t addr, uint32_t val,
504
                                  bool assign, uint32_t size)
504
                                  bool assign, uint32_t size, bool datamatch)
505 505
{
506 506
    int ret;
507 507
    struct kvm_ioeventfd iofd;
508 508

  
509
    iofd.datamatch = val;
509
    iofd.datamatch = datamatch ? val : 0;
510 510
    iofd.addr = addr;
511 511
    iofd.len = size;
512
    iofd.flags = KVM_IOEVENTFD_FLAG_DATAMATCH;
512
    iofd.flags = 0;
513 513
    iofd.fd = fd;
514 514

  
515 515
    if (!kvm_enabled()) {
516 516
        return -ENOSYS;
517 517
    }
518 518

  
519
    if (datamatch) {
520
        iofd.flags |= KVM_IOEVENTFD_FLAG_DATAMATCH;
521
    }
519 522
    if (!assign) {
520 523
        iofd.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
521 524
    }
......
530 533
}
531 534

  
532 535
static int kvm_set_ioeventfd_pio(int fd, uint16_t addr, uint16_t val,
533
                                 bool assign, uint32_t size)
536
                                 bool assign, uint32_t size, bool datamatch)
534 537
{
535 538
    struct kvm_ioeventfd kick = {
536
        .datamatch = val,
539
        .datamatch = datamatch ? val : 0,
537 540
        .addr = addr,
541
        .flags = KVM_IOEVENTFD_FLAG_PIO,
538 542
        .len = size,
539
        .flags = KVM_IOEVENTFD_FLAG_DATAMATCH | KVM_IOEVENTFD_FLAG_PIO,
540 543
        .fd = fd,
541 544
    };
542 545
    int r;
543 546
    if (!kvm_enabled()) {
544 547
        return -ENOSYS;
545 548
    }
549
    if (datamatch) {
550
        kick.flags |= KVM_IOEVENTFD_FLAG_DATAMATCH;
551
    }
546 552
    if (!assign) {
547 553
        kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
548 554
    }
......
571 577
        if (ioeventfds[i] < 0) {
572 578
            break;
573 579
        }
574
        ret = kvm_set_ioeventfd_pio(ioeventfds[i], 0, i, true, 2);
580
        ret = kvm_set_ioeventfd_pio(ioeventfds[i], 0, i, true, 2, true);
575 581
        if (ret < 0) {
576 582
            close(ioeventfds[i]);
577 583
            break;
......
582 588
    ret = i == ARRAY_SIZE(ioeventfds);
583 589

  
584 590
    while (i-- > 0) {
585
        kvm_set_ioeventfd_pio(ioeventfds[i], 0, i, false, 2);
591
        kvm_set_ioeventfd_pio(ioeventfds[i], 0, i, false, 2, true);
586 592
        close(ioeventfds[i]);
587 593
    }
588 594
    return ret;
......
802 808
    int fd = event_notifier_get_fd(e);
803 809
    int r;
804 810

  
805
    assert(match_data && section->size <= 8);
806

  
807 811
    r = kvm_set_ioeventfd_mmio(fd, section->offset_within_address_space,
808
                               data, true, section->size);
812
                               data, true, section->size, match_data);
809 813
    if (r < 0) {
810 814
        abort();
811 815
    }
......
820 824
    int r;
821 825

  
822 826
    r = kvm_set_ioeventfd_mmio(fd, section->offset_within_address_space,
823
                               data, false, section->size);
827
                               data, false, section->size, match_data);
824 828
    if (r < 0) {
825 829
        abort();
826 830
    }
......
834 838
    int fd = event_notifier_get_fd(e);
835 839
    int r;
836 840

  
837
    assert(match_data && section->size <= 8);
838

  
839 841
    r = kvm_set_ioeventfd_pio(fd, section->offset_within_address_space,
840
                              data, true, section->size);
842
                              data, true, section->size, match_data);
841 843
    if (r < 0) {
842 844
        abort();
843 845
    }
......
853 855
    int r;
854 856

  
855 857
    r = kvm_set_ioeventfd_pio(fd, section->offset_within_address_space,
856
                              data, false, section->size);
858
                              data, false, section->size, match_data);
857 859
    if (r < 0) {
858 860
        abort();
859 861
    }

Also available in: Unified diff