palacios/src/interfaces/vmm_host_dev.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2011, Peter Dinda <pdinda@northwestern.edu>
  11  * Copyright (c) 2011, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Peter Dinda <pdinda@northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20
  21 #include <interfaces/vmm_host_dev.h>
  22 #include <palacios/vmm.h>
  23 #include <palacios/vmm_debug.h>
  24 #include <palacios/vmm_types.h>
  25 #include <palacios/vm_guest.h>
  26 #include <palacios/vm_guest_mem.h>
  27
  28 struct v3_host_dev_hooks * host_dev_hooks = 0;
  29
  30 v3_host_dev_t v3_host_dev_open(char *impl,
  31                                v3_bus_class_t bus,
  32                                v3_guest_dev_t gdev,
  33                                v3_guest_dev_intr_t intr,
  34                                struct v3_vm_info *vm)
  35 {
  36     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks != NULL);
  37     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->open != NULL);
  38
  39     return host_dev_hooks->open(impl,bus,gdev,intr,vm->host_priv_data);
  40 }
  41
  42 int v3_host_dev_close(v3_host_dev_t hdev)
  43 {
  44     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks);
  45     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->close);
  46
  47     return host_dev_hooks->close(hdev);
  48 }
  49
  50 uint64_t v3_host_dev_read_io(v3_host_dev_t hdev,
  51                              uint16_t port,
  52                              void *dst,
  53                              uint64_t len)
  54 {
  55     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks != NULL);
  56     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->read_io != NULL);
  57
  58     return host_dev_hooks->read_io(hdev,port,dst,len);
  59 }
  60
  61 uint64_t v3_host_dev_write_io(v3_host_dev_t hdev,
  62                               uint16_t port,
  63                               void *src,
  64                               uint64_t len)
  65 {
  66     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks != NULL);
  67     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->write_io != NULL);
  68
  69     return host_dev_hooks->write_io(hdev,port,src,len);
  70 }
  71
  72 uint64_t v3_host_dev_read_mem(v3_host_dev_t hdev,
  73                               addr_t gpa,
  74                               void *dst,
  75                               uint64_t len)
  76 {
  77     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks != NULL);
  78     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->read_mem != NULL);
  79
  80     return host_dev_hooks->read_mem(hdev,(void*)gpa,dst,len);
  81 }
  82
  83 uint64_t v3_host_dev_write_mem(v3_host_dev_t hdev,
  84                               addr_t gpa,
  85                               void *src,
  86                               uint64_t len)
  87 {
  88     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks != NULL);
  89     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->write_mem != NULL);
  90
  91     return host_dev_hooks->write_mem(hdev,(void*)gpa,src,len);
  92 }
  93
  94 uint64_t v3_host_dev_read_config(v3_host_dev_t hdev,
  95                                  uint64_t offset,
  96                                  void *dst,
  97                                  uint64_t len)
  98 {
  99     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks != NULL);
 100     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->read_config);
 101
 102     return host_dev_hooks->read_config(hdev,offset,dst,len);
 103 }
 104
 105 uint64_t v3_host_dev_write_config(v3_host_dev_t hdev,
 106                                   uint64_t offset,
 107                                   void *src,
 108                                   uint64_t len)
 109 {
 110     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks != NULL);
 111     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->write_config);
 112
 113     return host_dev_hooks->write_config(hdev,offset,src,len);
 114
 115 }
 116
 117
 118 int v3_host_dev_ack_irq(v3_host_dev_t hdev, uint8_t irq)
 119 {
 120     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks != NULL);
 121     V3_ASSERT(VM_NONE, VCORE_NONE, host_dev_hooks->ack_irq);
 122
 123     return host_dev_hooks->ack_irq(hdev,irq);
 124 }
 125
 126
 127 int v3_host_dev_raise_irq(v3_host_dev_t hostdev,
 128                           v3_guest_dev_t guest_dev,
 129                           v3_guest_dev_intr_t intr,
 130                           uint8_t irq)
 131 {
 132     if (intr) {
 133         intr(hostdev,guest_dev,irq,1);
 134         return 0;
 135     } else {
 136         struct vm_device *dev = (struct vm_device *) guest_dev;
 137
 138         if (dev && dev->vm) {
 139             return v3_raise_irq(dev->vm,irq);
 140         } else {
 141             return -1;
 142         }
 143     }
 144 }
 145
 146 int v3_host_dev_lower_irq(v3_host_dev_t hostdev,
 147                           v3_guest_dev_t guest_dev,
 148                           v3_guest_dev_intr_t intr,
 149                           uint8_t irq)
 150 {
 151     struct vm_device *dev = (struct vm_device *) guest_dev;
 152
 153     if (dev && dev->vm) {
 154         if (intr) {
 155             intr(hostdev,guest_dev,irq,0);
 156             return 0;
 157         } else {
 158             return v3_lower_irq(dev->vm,irq);
 159         }
 160     } else {
 161         return -1;
 162     }
 163 }
 164
 165
 166 uint64_t v3_host_dev_read_guest_mem(v3_host_dev_t  hostdev,
 167                                     v3_guest_dev_t guest_dev,
 168                                     void *         gpa,
 169                                     void           *dst,
 170                                     uint64_t       len)
 171 {
 172     struct vm_device *dev = (struct vm_device *) guest_dev;
 173
 174     if (!dev) {
 175         return 0;
 176     } else {
 177         struct v3_vm_info *vm = dev->vm;
 178
 179         if (!vm) {
 180             return 0;
 181         } else {
 182             return v3_read_gpa_memory(&(vm->cores[0]), (addr_t)gpa, len, dst);
 183         }
 184     }
 185 }
 186
 187 uint64_t v3_host_dev_write_guest_mem(v3_host_dev_t  hostdev,
 188                                      v3_guest_dev_t guest_dev,
 189                                      void *         gpa,
 190                                      void           *src,
 191                                      uint64_t       len)
 192 {
 193     struct vm_device *dev = (struct vm_device *) guest_dev;
 194
 195     if (!dev) {
 196         return 0;
 197     } else {
 198         struct v3_vm_info *vm = dev->vm;
 199
 200         if (!vm) {
 201             return 0;
 202         } else {
 203             return v3_write_gpa_memory(&(vm->cores[0]), (addr_t)gpa, len, src);
 204         }
 205     }
 206 }
 207
 208
 209
 210 void V3_Init_Host_Device_Support(struct v3_host_dev_hooks * hooks) {
 211     host_dev_hooks = hooks;
 212     PrintDebug(VM_NONE, VCORE_NONE, "V3 host device interface inited\n");
 213
 214     return;
 215 }