palacios/include/vnet/vnet_host.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) 2011, Lei Xia <lxia@northwestern.edu>
  11  * Copyright (c) 2011, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Lei Xia <lxia@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 #ifndef __VNET_HOST_H__
  21 #define __VNET_HOST_H__
  22
  23 #include <vnet/vnet_vmm.h>
  24
  25 struct vnet_thread {
  26     void * host_thread;
  27 };
  28
  29 struct vnet_timer {
  30     void * host_timer;
  31 };
  32
  33 typedef addr_t vnet_lock_t;
  34
  35
  36
  37 struct vnet_host_hooks {
  38     void *(*thread_start)(int (*fn)(void * arg), void * arg, char * thread_name);
  39     void (*thread_sleep)(int timeout);
  40     void (*thread_wakeup)(void * thread);
  41     void (*thread_stop)(void * thread);
  42     int (*thread_should_stop)();
  43
  44     void *(*timer_create)(unsigned long interval, void (* timer_fun)(void * priv_data), void * data);
  45     void (*timer_del)(void * timer);
  46     int (*timer_start)(void * timer);
  47     int (*timer_stop)(void * timer);
  48     void (*timer_reset)(void * timer, unsigned long interval);
  49
  50     void (*udelay)(unsigned long usecs);
  51
  52     /* duplicate part from os_hooks */
  53     void (*yield_cpu)(void);
  54     void (*print)(const char * format, ...)
  55         __attribute__ ((format (printf, 1, 2)));
  56
  57     void *(*allocate_pages)(int num_pages, unsigned int alignment);
  58     void (*free_pages)(void * page, int num_pages);
  59
  60     void *(*malloc)(unsigned int size);
  61     void (*free)(void * addr);
  62
  63     void *(*paddr_to_vaddr)(void * addr);
  64     void *(*vaddr_to_paddr)(void * addr);
  65
  66     void *(*mutex_alloc)(void);
  67     void (*mutex_free)(void * mutex);
  68     void (*mutex_lock)(void * mutex, int must_spin);
  69     void (*mutex_unlock)(void * mutex);
  70 };
  71
  72
  73
  74 extern struct vnet_host_hooks * host_hooks;
  75
  76
  77 /* MEMORY ALLOCATE/DEALLOCATE */
  78
  79 #define PAGE_SIZE_4KB 4096
  80
  81 /* 4KB-aligned */
  82 static inline void * Vnet_AllocPages(int num_pages){
  83     if ((host_hooks) && host_hooks->allocate_pages) {
  84         return host_hooks->allocate_pages(num_pages, PAGE_SIZE_4KB);
  85     }
  86
  87     return NULL;
  88 }
  89
  90 static inline void Vnet_FreePages(void * page, int num_pages){
  91     if ((host_hooks) && host_hooks->free_pages) {
  92         host_hooks->free_pages(page, num_pages);
  93     }
  94 }
  95
  96 static inline void * Vnet_VAddr(void * addr) {
  97     if ((host_hooks) && host_hooks->paddr_to_vaddr){
  98         return host_hooks->paddr_to_vaddr(addr);
  99     }
 100
 101     return NULL;
 102 }
 103
 104 static inline void * Vnet_PAddr(void *addr) {
 105     if ((host_hooks) && host_hooks->vaddr_to_paddr) {
 106         return host_hooks->vaddr_to_paddr(addr);
 107     }
 108
 109     return NULL;
 110 }
 111
 112 static inline void * Vnet_Malloc(uint32_t size){
 113     if ((host_hooks) && host_hooks->malloc) {
 114         return host_hooks->malloc(size);
 115     }
 116
 117     return NULL;
 118 }
 119
 120 static inline void Vnet_Free(void * addr){
 121     if ((host_hooks) && host_hooks->free) {
 122         host_hooks->free(addr);
 123     }
 124 }
 125
 126
 127 static inline void Vnet_Yield(){
 128     if ((host_hooks) && (host_hooks)->yield_cpu) {
 129         host_hooks->yield_cpu();
 130     }
 131 }
 132
 133 /* THREAD FUNCTIONS */
 134 struct vnet_thread * vnet_start_thread(int (*func)(void *),
 135                                        void *arg, char * name);
 136
 137 static inline void vnet_thread_sleep(long timeout){
 138     if((host_hooks) && host_hooks->thread_sleep){
 139         host_hooks->thread_sleep(timeout);
 140     }
 141 }
 142
 143 static inline void vnet_thread_wakeup(struct vnet_thread * thread){
 144     if((host_hooks) && host_hooks->thread_wakeup){
 145         host_hooks->thread_wakeup(thread->host_thread);
 146     }
 147 }
 148
 149
 150 static inline void vnet_thread_stop(struct vnet_thread * thread){
 151     if((host_hooks) && host_hooks->thread_stop){
 152         host_hooks->thread_stop(thread->host_thread);
 153     }
 154 }
 155
 156 static inline int vnet_thread_should_stop(){
 157     if((host_hooks) && host_hooks->thread_should_stop){
 158         return host_hooks->thread_should_stop();
 159     }
 160
 161     return 0;
 162 }
 163
 164 static inline void  vnet_udelay(unsigned long usecs){
 165     if((host_hooks) && host_hooks->udelay){
 166         host_hooks->udelay(usecs);
 167     }
 168 }
 169
 170 /* TIMER FUNCTIONS */
 171 /* interval, in jittes */
 172 struct vnet_timer * vnet_create_timer(unsigned long interval,
 173                                       void (* timer_fun)(void * priv_data),
 174                                       void * pri_data);
 175
 176 static inline void vnet_del_timer(struct vnet_timer * timer){
 177     if((host_hooks) && host_hooks->timer_del){
 178         host_hooks->timer_del(timer->host_timer);
 179         Vnet_Free(timer);
 180     }
 181 }
 182
 183 static inline int vnet_start_timer(struct vnet_timer * timer){
 184     if((host_hooks) && host_hooks->timer_start){
 185         return host_hooks->timer_start(timer->host_timer);
 186     }
 187
 188     return -1;
 189 }
 190
 191 static inline int vnet_stop_timer(struct vnet_timer * timer){
 192     if((host_hooks) && host_hooks->timer_stop){
 193         return host_hooks->timer_stop(timer->host_timer);
 194     }
 195
 196     return -1;
 197 }
 198
 199 static inline void vnet_reset_timer(struct vnet_timer * timer, unsigned long new_interval){
 200     if((host_hooks) && host_hooks->timer_reset){
 201         host_hooks->timer_reset(timer->host_timer, new_interval);
 202     }
 203 }
 204
 205
 206
 207 #define Vnet_Print(level, fmt, args...)                                 \
 208     do {                                                                \
 209         extern int vnet_debug;                                          \
 210         if(level <= vnet_debug) {                                       \
 211             extern struct vnet_host_hooks * host_hooks;                 \
 212             if ((host_hooks) && (host_hooks)->print) {                  \
 213                 (host_hooks)->print((fmt), ##args);                     \
 214             }                                                           \
 215         }                                                               \
 216     } while (0)
 217
 218
 219 #define Vnet_Debug(fmt, args...)                                        \
 220     do {                                                                \
 221         extern struct vnet_host_hooks * host_hooks;                     \
 222         if ((host_hooks) && (host_hooks)->print) {                      \
 223             (host_hooks)->print((fmt), ##args);                         \
 224         }                                                               \
 225     } while (0)
 226
 227
 228
 229 /* Lock Utilities */
 230 int vnet_lock_init(vnet_lock_t * lock);
 231
 232 static inline void vnet_lock_deinit(vnet_lock_t * lock) {
 233     host_hooks->mutex_free((void *)*lock);
 234     *lock = 0;
 235 }
 236
 237 static inline void vnet_lock(vnet_lock_t lock) {
 238     host_hooks->mutex_lock((void *)lock, 0);
 239 }
 240
 241 static inline void vnet_unlock(vnet_lock_t lock) {
 242     host_hooks->mutex_unlock((void *)lock);
 243 }
 244
 245 static inline addr_t vnet_lock_irqsave(vnet_lock_t lock) {
 246     addr_t irq_state = v3_irq_save();
 247     host_hooks->mutex_lock((void *)lock, 1);
 248     return irq_state;
 249 }
 250
 251
 252 static inline void vnet_unlock_irqrestore(vnet_lock_t lock, addr_t irq_state) {
 253     host_hooks->mutex_unlock((void *)lock);
 254     v3_irq_restore(irq_state);
 255 }
 256
 257
 258
 259 void init_vnet(struct vnet_host_hooks * hooks);
 260
 261
 262 #endif
 263
 264