Palacios Public Git Repository

To checkout Palacios execute

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.


Corrected RTC timer bug (nvram)
[palacios.git] / palacios / include / palacios / vmm.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) 2008, Jack Lange <jarusl@cs.northwestern.edu> 
11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org> 
12  * All rights reserved.
13  *
14  * Author: Jack Lange <jarusl@cs.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 __VMM_H__
21 #define __VMM_H__
22
23
24 /*#include <palacios/vm_guest.h>*/
25
26 struct guest_info;
27
28
29 #ifdef __V3VEE__
30 #include <palacios/vmm_mem.h>
31 #include <palacios/vmm_types.h>
32
33 //#include <palacios/vmm_types.h>
34 #include <palacios/vmm_string.h>
35
36
37
38
39 /* utility definitions */
40
41
42 #define V3_Print(fmt, args...)                                  \
43     do {                                                        \
44         extern struct v3_os_hooks * os_hooks;                   \
45         if ((os_hooks) && (os_hooks)->print) {                  \
46             (os_hooks)->print((fmt), ##args);                   \
47         }                                                       \
48     } while (0) 
49
50
51 #define PrintDebug(fmt, args...)                        \
52     do {                                                \
53         extern struct v3_os_hooks * os_hooks;           \
54         if ((os_hooks) && (os_hooks)->print) {  \
55             (os_hooks)->print((fmt), ##args);   \
56         }                                               \
57     } while (0)                                         
58
59
60 #define PrintError(fmt, args...)                                        \
61     do {                                                                \
62         extern struct v3_os_hooks * os_hooks;                           \
63         if ((os_hooks) && (os_hooks)->print) {                  \
64             (os_hooks)->print("%s(%d): " fmt, __FILE__, __LINE__, ##args); \
65         }                                                               \
66     } while (0)                                         
67
68
69
70 /* 4KB-aligned */
71 #define V3_AllocPages(num_pages)                                        \
72     ({                                                                  \
73         extern struct v3_os_hooks * os_hooks;                           \
74         void * ptr = 0;                                                 \
75         if ((os_hooks) && (os_hooks)->allocate_pages) {                 \
76             ptr = (os_hooks)->allocate_pages(num_pages,PAGE_SIZE_4KB);  \
77         }                                                               \
78         ptr;                                                            \
79     })
80
81
82 #define V3_AllocAlignedPages(num_pages, align)                          \
83     ({                                                                  \
84         extern struct v3_os_hooks * os_hooks;                           \
85         void * ptr = 0;                                                 \
86         if ((os_hooks) && (os_hooks)->allocate_pages) {                 \
87             ptr = (os_hooks)->allocate_pages(num_pages,align);          \
88         }                                                               \
89         ptr;                                                            \
90     })
91
92
93 #define V3_FreePages(page, num_pages)                   \
94     do {                                                \
95         extern struct v3_os_hooks * os_hooks;           \
96         if ((os_hooks) && (os_hooks)->free_pages) {     \
97             (os_hooks)->free_pages(page, num_pages);    \
98         }                                               \
99     } while(0)
100
101
102 #define V3_VAddr(addr) ({                                       \
103             extern struct v3_os_hooks * os_hooks;               \
104             void * var = 0;                                     \
105             if ((os_hooks) && (os_hooks)->paddr_to_vaddr) {     \
106                 var = (os_hooks)->paddr_to_vaddr(addr);         \
107             }                                                   \
108             var;                                                \
109         })
110
111
112 #define V3_PAddr(addr) ({                                       \
113             extern struct v3_os_hooks * os_hooks;               \
114             void * var = 0;                                     \
115             if ((os_hooks) && (os_hooks)->vaddr_to_paddr) {     \
116                 var = (os_hooks)->vaddr_to_paddr(addr);         \
117             }                                                   \
118             var;                                                \
119         })
120
121
122
123 #define V3_Malloc(size) ({                              \
124             extern struct v3_os_hooks * os_hooks;       \
125             void * var = 0;                             \
126             if ((os_hooks) && (os_hooks)->malloc) {     \
127                 var = (os_hooks)->malloc(size);         \
128             }                                           \
129             if (!var) PrintError("MALLOC FAILURE. Memory LEAK!!\n");    \
130             var;                                        \
131         })
132
133 // We need to check the hook structure at runtime to ensure its SAFE
134 #define V3_Free(addr)                           \
135     do {                                        \
136         extern struct v3_os_hooks * os_hooks;   \
137         if ((os_hooks) && (os_hooks)->free) {   \
138             (os_hooks)->free(addr);             \
139         }                                       \
140     } while (0)
141
142 // uint_t V3_CPU_KHZ();
143 #define V3_CPU_KHZ() ({                                                 \
144             unsigned int khz = 0;                                       \
145             extern struct v3_os_hooks * os_hooks;                       \
146             if ((os_hooks) && (os_hooks)->get_cpu_khz) {                \
147                 khz = (os_hooks)->get_cpu_khz();                        \
148             }                                                           \
149             khz;                                                        \
150         })                                                              \
151         
152
153
154
155 #define V3_Hook_Interrupt(vm, irq) ({                                   \
156             int ret = 0;                                                \
157             extern struct v3_os_hooks * os_hooks;                       \
158             if ((os_hooks) && (os_hooks)->hook_interrupt) {             \
159                 ret = (os_hooks)->hook_interrupt(vm, irq);              \
160             }                                                           \
161             ret;                                                        \
162         })                                                              \
163         
164
165 #define V3_ACK_IRQ(irq)                                         \
166     do {                                                        \
167         extern struct v3_os_hooks * os_hooks;                   \
168         if ((os_hooks) && (os_hooks)->ack_irq) {                \
169             (os_hooks)->ack_irq(irq);                           \
170         }                                                       \
171     } while (0)
172
173
174
175 #define V3_Get_CPU() ({                                                 \
176             int ret = 0;                                                \
177             extern struct v3_os_hooks * os_hooks;                       \
178             if ((os_hooks) && (os_hooks)->get_cpu) {                    \
179                 ret = (os_hooks)->get_cpu();                            \
180             }                                                           \
181             ret;                                                        \
182         })
183
184
185 #ifdef CONFIG_MULTITHREAD_OS
186
187 #define V3_CREATE_THREAD(fn, arg, name)                         \
188     do {                                                        \
189         extern struct v3_os_hooks * os_hooks;                   \
190         if ((os_hooks) && (os_hooks)->start_kernel_thread) {    \
191             (os_hooks)->start_kernel_thread(fn, arg, name);     \
192         }                                                       \
193     } while (0)
194
195
196 #define V3_Call_On_CPU(cpu, fn, arg)                    \
197     do {                                                \
198         extern struct v3_os_hooks * os_hooks;           \
199         if ((os_hooks) && (os_hooks)->call_on_cpu) {    \
200             (os_hooks)->call_on_cpu(cpu, fn, arg);      \
201         }                                               \
202     } while (0)
203
204
205
206 #define V3_CREATE_THREAD_ON_CPU(cpu, fn, arg, name) ({                  \
207             void * thread = NULL;                                       \
208             extern struct v3_os_hooks * os_hooks;                       \
209             if ((os_hooks) && (os_hooks)->start_thread_on_cpu) {        \
210                 thread = (os_hooks)->start_thread_on_cpu(cpu, fn, arg, name); \
211             }                                                           \
212             thread;                                                     \
213         })
214
215 #endif
216
217 /* ** */
218
219
220 #define V3_ASSERT(x)                                                    \
221     do {                                                                \
222         extern struct v3_os_hooks * os_hooks;                           \
223         if (!(x)) {                                                     \
224             PrintDebug("Failed assertion in %s: %s at %s, line %d, RA=%lx\n", \
225                        __func__, #x, __FILE__, __LINE__,                \
226                        (ulong_t) __builtin_return_address(0));          \
227             while(1){                                                   \
228                 if ((os_hooks) && (os_hooks)->yield_cpu) {              \
229                         (os_hooks)->yield_cpu();                        \
230                 }                                                       \
231             }                                                           \
232         }                                                               \
233     } while(0)                                                          \
234         
235
236
237
238
239 typedef enum v3_vm_class {V3_INVALID_VM, V3_PC_VM, V3_CRAY_VM} v3_vm_class_t;
240
241
242 // Maybe make this a define....
243 typedef enum v3_cpu_arch {V3_INVALID_CPU, V3_SVM_CPU, V3_SVM_REV3_CPU, V3_VMX_CPU, V3_VMX_EPT_CPU} v3_cpu_arch_t;
244
245
246 v3_cpu_mode_t v3_get_host_cpu_mode();
247
248 void v3_yield(struct guest_info * info);
249 void v3_yield_cond(struct guest_info * info);
250 void v3_print_cond(const char * fmt, ...);
251
252
253 #ifdef CONFIG_MULTITHREAD_OS
254 void v3_interrupt_cpu(struct v3_vm_info * vm, int logical_cpu, int vector);
255 #endif
256
257
258 v3_cpu_arch_t v3_get_cpu_type(int cpu_id);
259
260
261 int v3_vm_enter(struct guest_info * info);
262
263
264 #endif /*!__V3VEE__ */
265
266
267
268 struct v3_vm_info;
269
270 /* This will contain function pointers that provide OS services */
271 struct v3_os_hooks {
272     void (*print)(const char * format, ...)
273         __attribute__ ((format (printf, 1, 2)));
274   
275     void *(*allocate_pages)(int num_pages, unsigned int alignment);
276     void (*free_pages)(void * page, int num_pages);
277
278     void *(*malloc)(unsigned int size);
279     void (*free)(void * addr);
280
281     void *(*paddr_to_vaddr)(void * addr);
282     void *(*vaddr_to_paddr)(void * addr);
283
284     int (*hook_interrupt)(struct v3_vm_info * vm, unsigned int irq);
285     int (*ack_irq)(int irq);
286
287     unsigned int (*get_cpu_khz)(void);
288
289
290     void (*yield_cpu)(void); 
291
292     void *(*mutex_alloc)(void);
293     void (*mutex_free)(void * mutex);
294     void (*mutex_lock)(void * mutex, int must_spin);
295     void (*mutex_unlock)(void * mutex);
296
297     unsigned int (*get_cpu)(void);
298
299
300
301     void (*start_kernel_thread)(int (*fn)(void * arg), void * arg, char * thread_name); 
302     void (*interrupt_cpu)(struct v3_vm_info * vm, int logical_cpu, int vector);
303     void (*call_on_cpu)(int logical_cpu, void (*fn)(void * arg), void * arg);
304     void * (*start_thread_on_cpu)(int cpu_id, int (*fn)(void * arg), void * arg, char * thread_name);
305
306 };
307
308
309 /*
310  *
311  * This is the interrupt state that the VMM's interrupt handlers need to see
312  */
313 struct v3_interrupt {
314     unsigned int irq;
315     unsigned int error;
316
317     unsigned int should_ack;  /* Should the vmm ack this interrupt, or will
318                                * the host OS do it? */
319 };
320
321
322
323
324 void Init_V3(struct v3_os_hooks * hooks,  int num_cpus);
325 void Shutdown_V3( void );
326
327
328 struct v3_vm_info * v3_create_vm(void * cfg, void * priv_data, char * name);
329 int v3_start_vm(struct v3_vm_info * vm, unsigned int cpu_mask);
330 int v3_stop_vm(struct v3_vm_info * vm);
331 int v3_free_vm(struct v3_vm_info * vm);
332
333 int v3_deliver_irq(struct v3_vm_info * vm, struct v3_interrupt * intr);
334
335
336 #endif