← Back to branch summary

~ubuntu-branches/ubuntu/hardy/kvm/hardy-backports

« back to all changes in this revision

Viewing changes to libkvm/libkvm.c

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2008-01-03 10:39:25 UTC
  • mfrom: (1.1.16 upstream)
  • Revision ID: james.westby@ubuntu.com-20080103103925-8480u7sq2646hvbh
Tags: 1:59+dfsg-0ubuntu1
* New upstream release
* Build with alsa support (cherry pick from 57+dfsg-2)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libkvm/libkvm.c
44
44
#include "kvm-ia64.h"
45
45
#endif
46
46
 
 
47
#if defined(__powerpc__)
 
48
#include "kvm-powerpc.h"
 
49
#endif
 
50
 
47
51
int kvm_abi = EXPECTED_KVM_API_VERSION;
48
52
int kvm_page_size;
49
53
 
113
117
 
114
118
        for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS ; ++i) {
115
119
                if (slots[i].len && slots[i].phys_addr <= phys_addr &&
116
 
                    (slots[i].phys_addr + slots[i].len) >= phys_addr)
 
120
                    (slots[i].phys_addr + slots[i].len-1) >= phys_addr)
117
121
                        return i;
118
122
        }
119
123
        return -1;
567
571
                          unsigned long len)
568
572
{
569
573
        int slot;
570
 
        struct kvm_memory_region *mem;
571
574
 
572
575
        slot = get_slot(phys_start);
573
576
 
578
581
        }
579
582
        if (phys_start != slots[slot].phys_addr) {
580
583
                fprintf(stderr,
581
 
                        "WARNING: %s: phys_start is 0x%lx expecting 0x%llx\n",
582
 
                        __FUNCTION__, phys_start, mem->guest_phys_addr);
583
 
                phys_start = mem->guest_phys_addr;
 
584
                        "WARNING: %s: phys_start is 0x%lx expecting 0x%lx\n",
 
585
                        __FUNCTION__, phys_start, slots[slot].phys_addr);
 
586
                phys_start = slots[slot].phys_addr;
584
587
        }
585
588
        kvm_create_phys_mem(kvm, phys_start, 0, 0, 0);
586
589
}
826
829
{
827
830
        unsigned long addr = kvm_run->mmio.phys_addr;
828
831
        void *data = kvm_run->mmio.data;
829
 
        int r = -1;
830
832
 
831
 
        /* hack: Red Hat 7.1 generates these wierd accesses. */
832
 
        if (addr == 0xa0000 && kvm_run->mmio.len == 3)
 
833
        /* hack: Red Hat 7.1 generates these weird accesses. */
 
834
        if ((addr > 0xa0000-4 && addr <= 0xa0000) && kvm_run->mmio.len == 3)
833
835
            return 0;
834
836
 
835
 
        if (kvm_run->mmio.is_write) {
836
 
                switch (kvm_run->mmio.len) {
837
 
                case 1:
838
 
                        r = kvm->callbacks->writeb(kvm->opaque, addr, *(uint8_t *)data);
839
 
                        break;
840
 
                case 2:
841
 
                        r = kvm->callbacks->writew(kvm->opaque, addr, *(uint16_t *)data);
842
 
                        break;
843
 
                case 4:
844
 
                        r = kvm->callbacks->writel(kvm->opaque, addr, *(uint32_t *)data);
845
 
                        break;
846
 
                case 8:
847
 
                        r = kvm->callbacks->writeq(kvm->opaque, addr, *(uint64_t *)data);
848
 
                        break;
849
 
                }
850
 
        } else {
851
 
                switch (kvm_run->mmio.len) {
852
 
                case 1:
853
 
                        r = kvm->callbacks->readb(kvm->opaque, addr, (uint8_t *)data);
854
 
                        break;
855
 
                case 2:
856
 
                        r = kvm->callbacks->readw(kvm->opaque, addr, (uint16_t *)data);
857
 
                        break;
858
 
                case 4:
859
 
                        r = kvm->callbacks->readl(kvm->opaque, addr, (uint32_t *)data);
860
 
                        break;
861
 
                case 8:
862
 
                        r = kvm->callbacks->readq(kvm->opaque, addr, (uint64_t *)data);
863
 
                        break;
864
 
                }
865
 
        }
866
 
        return r;
 
837
        if (kvm_run->mmio.is_write)
 
838
                return kvm->callbacks->mmio_write(kvm->opaque, addr, data,
 
839
                                        kvm_run->mmio.len);
 
840
        else
 
841
                return kvm->callbacks->mmio_read(kvm->opaque, addr, data,
 
842
                                        kvm_run->mmio.len);
867
843
}
868
844
 
869
845
int handle_io_window(kvm_context_t kvm)