palacios/include/palacios/vmm_hvm.h

   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) 2015, The V3VEE Project <http://www.v3vee.org>
  11  * All rights reserved.
  12  *
  13  * Author: Peter Dinda <pdinda@northwestern.edu>
  14  *
  15  * This is free software.  You are permitted to use,
  16  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  17  */
  18
  19
  20 #ifndef __VMM_HVM_H
  21 #define __VMM_HVM_H
  22
  23
  24 #ifdef __V3VEE__
  25
  26 #include <palacios/vmm_types.h>
  27 #include <palacios/vmm_multiboot.h>
  28
  29 struct v3_ros_event {
  30     enum { ROS_NONE=0, ROS_PAGE_FAULT=1, ROS_SYSCALL=2 } event_type;
  31     uint64_t       last_ros_event_result; // valid when ROS_NONE
  32     union {
  33         struct {   // valid when ROS_PAGE_FAULT
  34             uint64_t rip;
  35             uint64_t cr2;
  36             enum {ROS_READ, ROS_WRITE} action;
  37         } page_fault;
  38         struct { // valid when ROS_SYSCALL
  39             uint64_t args[8];
  40         } syscall;
  41     };
  42 };
  43
  44 struct v3_vm_hvm {
  45     uint8_t   is_hvm;
  46     uint32_t  first_hrt_core;
  47     uint64_t  first_hrt_gpa;
  48     struct v3_cfg_file *hrt_file;  // image provided via PAL file, if any
  49     void      *hrt_image;          // image provided by ROS, if any
  50     uint64_t  hrt_image_size;      //   size of this image
  51     uint64_t  hrt_entry_addr;
  52     enum { HRT_BLOB, HRT_ELF64, HRT_MBOOT2, HRT_MBOOT64 } hrt_type;
  53
  54     // The following parallel the content of mb_info_hrt_t in
  55     // the extended multiboot header.   They reflect how the
  56     // HRT has actually been mapped, as opposed to the requested
  57     // mapping/flags from the mb_mb64_hrt_t
  58     uint64_t  hrt_flags;
  59     uint64_t  max_mem_mapped;
  60     uint64_t  gva_offset;
  61     uint64_t  gva_entry;
  62     uint64_t  comm_page_gpa;
  63     uint8_t   hrt_int_vector;
  64
  65     void     *comm_page_hpa;
  66     void     *comm_page_hva;
  67
  68     enum {HRT_IDLE=0, HRT_CALL=1, HRT_PARCALL=2, HRT_SYNCSETUP=3, HRT_SYNC=4, HRT_SYNCTEARDOWN=5, HRT_MERGE=6} trans_state;
  69     uint64_t  trans_count;
  70
  71     // the ROS event to be handed back
  72     struct v3_ros_event ros_event;
  73
  74 };
  75
  76 struct v3_core_hvm {
  77     uint8_t   is_hrt;
  78     uint64_t  last_boot_start;
  79 };
  80
  81
  82
  83 struct v3_xml;
  84
  85 int v3_init_hvm();
  86 int v3_deinit_hvm();
  87
  88 int v3_init_hvm_vm(struct v3_vm_info *vm, struct v3_xml *config);
  89 int v3_deinit_hvm_vm(struct v3_vm_info *vm);
  90
  91
  92 int v3_init_hvm_core(struct guest_info *core);
  93 int v3_deinit_hvm_core(struct guest_info *core);
  94
  95
  96 uint64_t v3_get_hvm_ros_memsize(struct v3_vm_info *vm);
  97 uint64_t v3_get_hvm_hrt_memsize(struct v3_vm_info *vm);
  98 int      v3_is_hvm_ros_mem_gpa(struct v3_vm_info *vm, addr_t gpa);
  99 int      v3_is_hvm_hrt_mem_gpa(struct v3_vm_info *vm, addr_t gpa);
 100
 101 uint32_t v3_get_hvm_ros_cores(struct v3_vm_info *vm);
 102 uint32_t v3_get_hvm_hrt_cores(struct v3_vm_info *vm);
 103 int      v3_is_hvm_ros_core(struct guest_info *core);
 104 int      v3_is_hvm_hrt_core(struct guest_info *core);
 105
 106
 107 int      v3_hvm_should_deliver_ipi(struct guest_info *src, struct guest_info *dest);
 108 void     v3_hvm_find_apics_seen_by_core(struct guest_info *core, struct v3_vm_info *vm,
 109                                         uint32_t *start_apic, uint32_t *num_apics);
 110
 111
 112 int v3_build_hrt_multiboot_tag(struct guest_info *core, mb_info_hrt_t *hrt);
 113
 114 int v3_setup_hvm_vm_for_boot(struct v3_vm_info *vm);
 115 int v3_setup_hvm_hrt_core_for_boot(struct guest_info *core);
 116
 117 int v3_handle_hvm_reset(struct guest_info *core);
 118
 119 /*
 120   HVM/HRT interaction is as follows:
 121
 122   1. MB_TAG_MB64_HRT tag in the HRT multiboot kernel signifies it
 123      is handled by the HVM.
 124   2. The flags and other info in the the tag indicate the properties of the HRT
 125      to the HVM.  (see vmm_multiboot.h), in particular:
 126          - position independence
 127          - ability to be initially mapped with an offset
 128            between virtual and physical addresses, for example
 129            to hoist it into the same position that the ROS kernel
 130            will occupy in the virtual address space of a ROS
 131            process
 132          - how much physical address space we will intiially map
 133            and what kind of page tables are used to map it
 134          - what physical page (4KB) should we reserve for use
 135            in HVM/HRT communication (particularly upcalls)
 136          - the interrupt vector used to upcall from the HVM to the HRT
 137   3. The MB_INFO_HRT_TAG within the multiboot info structures the
 138      HRT sees on boot indicates that HRT functionality is established and
 139      gives details of operation to the HRT, including the following.
 140      See vmm_multiboot.c for more info
 141          - apics and ioapic ids, and indications of which apics
 142            and which entries on ioapics are exclusively for HRT use
 143          - physical address range that is exclusively for HRT use
 144          - where the the physical address range exclusively for HRT use
 145            is mapped into the virtual address space (offset).  The
 146            ROS part of the physical address space is always identity mapped
 147            initially.
 148          - the amount of physical memory that has been mapped
 149          - the physical address of the page the HVM will use to
 150            communicate with the HRT
 151          - the interrupt vector the HVM will use to upcall the HRT
 152          - flags copied from the HRT's HRT tag (position independence,
 153            page table model, offset, etc)
 154   4. Downcalls:
 155          hypercall 0xf00df00d with arguments depending on operation
 156          with examples described below.
 157   5. Upcalls
 158          interrupt injected by VMM or a magic #PF
 159          communication via a shared memory page, contents below
 160
 161   Upcalls
 162
 163    Type of upcall is determined by the first 64 bits in the commm page
 164
 165    0x0  =>  Null (test)
 166    0x20 =>  Invoke function in HRT
 167             Next 64 bits contains address of structure
 168             describing function call.   This is typically the ROS
 169             trying to get the HRT to run a function for it.
 170             ROS is resposible for assuring that this address
 171             (and other addresses) are correct with respect to
 172             mappings.   That is, for a non-merged address space,
 173             the ROS needs to supply physical addresses so that
 174             they can be used (with the identity-mapped ROS physical
 175             memory.)  If it wants to use virtual addresses, it
 176             needs to first merge the address spaces.
 177    0x21 =>  Invoke function in HRT in parallel
 178             Exactly like previos, but the upcall is happening
 179             simultaneously on all HRT cores.
 180    0x30 =>  Merge address space
 181             Next 64 bits contains the ROS CR3 that we will use
 182             to map the user portion of ROS address space into
 183             the HRT address space
 184    0x31 =>  Unmerge address space
 185             return the ROS memory mapping to normal (physical/virtual identity)
 186
 187   Downcalls
 188
 189    HVM_HCALL is the general hypercall number used to talk to the HVM
 190      The first argument is the request number (below).   The other arguments
 191      depend on the first.
 192
 193    0x0  =>  Null, just for timing
 194    0x1  =>  Reboot ROS
 195    0x2  =>  Reboot HRT
 196    0x3  =>  Reboot Both
 197
 198    0x8  =>  Replace HRT image
 199             pass in pointer (gva) and length of new image
 200
 201    0xf  =>  Get HRT transaction state and current ROS event
 202             first argument is pointer to the ROS event state
 203             to be filled out
 204
 205    0x10 =>  ROS event request (HRT->ROS)
 206             first argument is pointer where to write the ROS event state
 207    0x1f =>  ROS event completion (ROS->HRT)
 208             first argument is the result code
 209
 210    0x20 =>  Invoke function (ROS->HRT)
 211             first argument is pointer to structure describing call
 212    0x21 =>  Invoke function in parallel (ROS->HRT)
 213             same as above, but simultaneously on all HRT cores
 214    0x2f =>  Function execution complete (HRT->ROS, once per core)
 215    0x30 =>  Merge address space (ROS->HRT)
 216             no arguments (CR3 implicit).   Merge the current
 217             address space in the ROS with the address space on
 218             the HRT
 219    0x31 =>  Unmerge address apce (ROS->HRT)
 220             release any address space merger and restore identity mapping
 221    0x3f =>  Merge request complete (HRT->ROS)
 222
 223 */
 224
 225
 226
 227 #endif /* ! __V3VEE__ */
 228
 229
 230 #endif