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.
6 * The V3VEE Project is a joint project between Northwestern University
7 * and the University of New Mexico. You can find out more at
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.
14 * Author: Jack Lange <jarusl@cs.northwestern.edu>
16 * This is free software. You are permitted to use,
17 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
25 #include <palacios/vmm_types.h>
26 #include <palacios/vmm_list.h>
27 #include <palacios/vmm_string.h>
28 #include <palacios/vmm_hashtable.h>
29 #include <palacios/vmm_msr.h>
30 #include <palacios/vmm_config.h>
32 #ifdef V3_CONFIG_CHECKPOINT
33 #include <palacios/vmm_checkpoint.h>
40 typedef void * v3_dev_data_t;
49 struct v3_device_ops * ops;
51 struct v3_vm_info * vm;
53 struct list_head dev_link;
56 struct list_head res_hooks;
63 struct list_head dev_list;
64 struct hashtable * dev_table;
66 struct list_head blk_list;
67 struct hashtable * blk_table;
69 struct list_head net_list;
70 struct hashtable * net_table;
72 struct list_head char_list;
73 struct hashtable * char_table;
75 struct list_head cons_list;
76 struct hashtable * cons_table;
80 int v3_create_device(struct v3_vm_info * vm, const char * dev_name, v3_cfg_tree_t * cfg);
82 struct vm_device * v3_find_dev(struct v3_vm_info * info, const char * dev_name);
85 // Registration of devices
88 // The following device manager functions should only be called
89 // when the guest is stopped
94 int v3_init_dev_mgr(struct v3_vm_info * vm);
95 int v3_deinit_dev_mgr(struct v3_vm_info * vm);
97 int v3_free_vm_devices(struct v3_vm_info * vm);
99 #ifdef V3_CONFIG_CHECKPOINT
100 int v3_save_vm_devices(struct v3_vm_info * vm, struct v3_chkpt * chkpt);
101 int v3_load_vm_devices(struct v3_vm_info * vm, struct v3_chkpt * chkpt);
106 int V3_init_devices();
107 int V3_deinit_devices();
110 struct v3_device_ops {
111 int (*free)(void * private_data);
113 #ifdef V3_CONFIG_CHECKPOINT
115 Both the base and extended save/load functions are optional.
116 If save_extended is defined, then it will be called in
117 preference to save. The idea is that with "save", the caller
118 opens the context using the name of the device, and expects
119 the callee to write it and then return. With "save_extended"
120 the caller passes the checkpoint store and the device name
121 to the callee. The callee is then expected to open
122 contexts as desired, write to them, and then close them
123 before returning. Load and load/extended are symmetric.
126 int (*save)(struct v3_chkpt_ctx * ctx, void * private_data);
127 int (*load)(struct v3_chkpt_ctx * ctx, void * privata_data);
128 int (*save_extended)(struct v3_chkpt * chkpt, char * id, void * private_data);
129 int (*load_extended)(struct v3_chkpt * chkpt, char * id, void * privata_data);
138 int v3_dev_hook_io(struct vm_device * dev,
140 int (*read)(struct guest_info * core, uint16_t port, void * dst, uint_t length, void * priv_data),
141 int (*write)(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data));
143 int v3_dev_unhook_io(struct vm_device * dev,
147 int v3_dev_hook_msr(struct vm_device * dev,
149 int (*read)(struct guest_info * core, uint32_t msr, struct v3_msr * dst, void * priv_data),
150 int (*write)(struct guest_info * core, uint32_t msr, struct v3_msr src, void * priv_data));
152 int v3_dev_unhook_msr(struct vm_device * dev,
158 struct vm_device * v3_add_device(struct v3_vm_info * vm, char * name,
159 struct v3_device_ops * ops, void * private_data);
160 int v3_remove_device(struct vm_device * dev);
163 int v3_attach_device(struct v3_vm_info * vm, struct vm_device * dev);
164 int v3_detach_device(struct vm_device * dev);
165 struct vm_device * v3_allocate_device(char * name, struct v3_device_ops * ops, void * private_data);
168 struct v3_device_info {
170 int (*init)(struct v3_vm_info * info, v3_cfg_tree_t * cfg);
174 #define device_register(name, init_dev_fn) \
175 static char _v3_device_name[] = name; \
176 static struct v3_device_info _v3_device \
177 __attribute__((__used__)) \
178 __attribute__((unused, __section__ ("_v3_devices"), \
179 aligned(sizeof(addr_t)))) \
180 = {_v3_device_name , init_dev_fn};
185 void v3_print_dev_mgr(struct v3_vm_info * vm);
188 struct v3_dev_blk_ops {
189 uint64_t (*get_capacity)(void * private_data);
190 // Reads always operate on 2048 byte blocks
192 // how does this signal bytes_read < requested but not error?
194 int (*read)(uint8_t * buf, uint64_t lba, uint64_t num_bytes, void * private_data);
195 int (*write)(uint8_t * buf, uint64_t lba, uint64_t num_bytes, void * private_data);
199 struct v3_dev_net_ops_cfg{
200 void * frontend_data;
203 int poll; /* need poll? */
206 struct v3_dev_net_ops {
207 /* Backend implemented functions */
208 int (*send)(uint8_t * buf, uint32_t len, void * private_data);
210 /* Frontend implemented functions */
211 int (*recv)(uint8_t * buf, uint32_t len, void * frnt_data);
212 int (*poll)(int quote, void * frnt_data);
214 /* This is ugly... */
215 struct v3_dev_net_ops_cfg config;
218 struct v3_dev_console_ops {
219 int (*update_screen)(uint_t x, uint_t y, uint_t length, uint8_t * fb_data, void * private_data);
220 int (*update_cursor)(uint_t x, uint_t y, void * private_data);
221 int (*scroll)(int rows, void * private_data);
222 int (*set_text_resolution)(int cols, int rows, void * private_data);
224 /* frontend implemented functions */
225 int (*get_screen)(uint_t x, uint_t y, uint_t length, void * frontend_data);
229 struct v3_dev_char_ops {
230 /* Backend implemented functions */
231 sint64_t (*output)(uint8_t * buf, sint64_t len, void * private_data);
232 // int (*read)(uint8_t * buf, uint64_t len, void * private_data);
234 /* Frontend Implemented functions */
235 sint64_t (*input)(struct v3_vm_info * vm, uint8_t * buf, sint64_t len, void * private_data);
239 int v3_dev_add_blk_frontend(struct v3_vm_info * vm,
241 int (*connect)(struct v3_vm_info * vm,
242 void * frontend_data,
243 struct v3_dev_blk_ops * ops,
245 void * private_data),
248 int v3_dev_connect_blk(struct v3_vm_info * vm,
249 char * frontend_name,
250 struct v3_dev_blk_ops * ops,
252 void * private_data);
254 int v3_dev_add_net_frontend(struct v3_vm_info * vm,
256 int (*connect)(struct v3_vm_info * vm,
257 void * frontend_data,
258 struct v3_dev_net_ops * ops,
260 void * private_data),
263 int v3_dev_connect_net(struct v3_vm_info * vm,
264 char * frontend_name,
265 struct v3_dev_net_ops * ops,
267 void * private_data);
272 int v3_dev_add_console_frontend(struct v3_vm_info * vm,
274 int (*connect)(struct v3_vm_info * vm,
275 void * frontend_data,
276 struct v3_dev_console_ops * ops,
278 void * private_data),
281 int v3_dev_connect_console(struct v3_vm_info * vm,
282 char * frontend_name,
283 struct v3_dev_console_ops * ops,
285 void * private_data);
289 int v3_dev_add_char_frontend(struct v3_vm_info * vm,
291 int (*connect)(struct v3_vm_info * vm,
292 void * frontend_data,
293 struct v3_dev_char_ops * ops,
296 void ** push_fn_arg),
299 int v3_dev_connect_char(struct v3_vm_info * vm,
300 char * frontend_name,
301 struct v3_dev_char_ops * ops,
304 void ** push_fn_arg);
307 #endif // ! __V3VEE__