X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?p=palacios.git;a=blobdiff_plain;f=palacios%2Fsrc%2Fpalacios%2Fvmm_io.c;h=0211b99b97bad6dd822fcea5d54639577dfa9235;hp=d6431b7e25f1a2837215767836de28df3c2fcb5f;hb=123a1ba27ea09c8fa77a1b36ce625b43d7c48b14;hpb=d16ef42bba84c7fe88352e5dc23e5e70a5207e29 diff --git a/palacios/src/palacios/vmm_io.c b/palacios/src/palacios/vmm_io.c index d6431b7..0211b99 100644 --- a/palacios/src/palacios/vmm_io.c +++ b/palacios/src/palacios/vmm_io.c @@ -1,135 +1,114 @@ +/* + * This file is part of the Palacios Virtual Machine Monitor developed + * by the V3VEE Project with funding from the United States National + * Science Foundation and the Department of Energy. + * + * The V3VEE Project is a joint project between Northwestern University + * and the University of New Mexico. You can find out more at + * http://www.v3vee.org + * + * Copyright (c) 2008, Jack Lange + * Copyright (c) 2008, The V3VEE Project + * All rights reserved. + * + * Author: Jack Lange + * + * This is free software. You are permitted to use, + * redistribute, and modify it as specified in the file "V3VEE_LICENSE". + */ + #include #include #include +#include -extern struct vmm_os_hooks * os_hooks; +#ifndef CONFIG_DEBUG_IO +#undef PrintDebug +#define PrintDebug(fmt, args...) +#endif +static int default_write(uint16_t port, void *src, uint_t length, void * priv_data); +static int default_read(uint16_t port, void * dst, uint_t length, void * priv_data); -void init_vmm_io_map(vmm_io_map_t * io_map) { - io_map->num_ports = 0; - io_map->head = NULL; -} +void v3_init_io_map(struct guest_info * info) { + info->io_map.map.rb_node = NULL; + info->io_map.arch_data = NULL; + info->io_map.update_map = NULL; -int add_io_hook(vmm_io_map_t * io_map, vmm_io_hook_t * io_hook) { +} - if (!(io_map->head)) { - io_map->head = io_hook; - io_map->num_ports = 1; - return 0; - } else if (io_map->head->port > io_hook->port) { - io_hook->next = io_map->head; - io_map->head->prev = io_hook; - io_map->head = io_hook; - io_map->num_ports++; - return 0; - } else { - vmm_io_hook_t * tmp_hook = io_map->head; - - while ((tmp_hook->next) && - (tmp_hook->next->port <= io_hook->port)) { - tmp_hook = tmp_hook->next; - } - - if (tmp_hook->port == io_hook->port) { - //tmp_hook->read = io_hook->read; - //tmp_hook->write = io_hook->write; - //V3_Free(io_hook); - return -1; - } else { - io_hook->prev = tmp_hook; - io_hook->next = tmp_hook->next; - if (tmp_hook->next) { - tmp_hook->next->prev = io_hook; - } +static inline struct v3_io_hook * __insert_io_hook(struct guest_info * info, struct v3_io_hook * hook) { + struct rb_node ** p = &(info->io_map.map.rb_node); + struct rb_node * parent = NULL; + struct v3_io_hook * tmp_hook = NULL; - tmp_hook->next = io_hook; + while (*p) { + parent = *p; + tmp_hook = rb_entry(parent, struct v3_io_hook, tree_node); - io_map->num_ports++; - return 0; + if (hook->port < tmp_hook->port) { + p = &(*p)->rb_left; + } else if (hook->port > tmp_hook->port) { + p = &(*p)->rb_right; + } else { + return tmp_hook; } } - return -1; + rb_link_node(&(hook->tree_node), parent, p); + + return NULL; } -int remove_io_hook(vmm_io_map_t * io_map, vmm_io_hook_t * io_hook) { - if (io_map->head == io_hook) { - io_map->head = io_hook->next; - } else if (io_hook->prev) { - io_hook->prev->next = io_hook->next; - } else { - return -1; - // data corruption failure - } - - if (io_hook->next) { - io_hook->next->prev = io_hook->prev; + +static inline struct v3_io_hook * insert_io_hook(struct guest_info * info, struct v3_io_hook * hook) { + struct v3_io_hook * ret; + + if ((ret = __insert_io_hook(info, hook))) { + return ret; } - io_map->num_ports--; + v3_rb_insert_color(&(hook->tree_node), &(info->io_map.map)); - return 0; + return NULL; } +struct v3_io_hook * v3_get_io_hook(struct guest_info * info, uint16_t port) { + struct rb_node * n = info->io_map.map.rb_node; + struct v3_io_hook * hook = NULL; -/* FIX ME */ -static int default_write(ushort_t port, void *src, uint_t length, void * priv_data) { - /* + while (n) { + hook = rb_entry(n, struct v3_io_hook, tree_node); - if (length == 1) { - __asm__ __volatile__ ( - "outb %b0, %w1" - : - : "a" (*dst), "Nd" (port) - ); - } else if (length == 2) { - __asm__ __volatile__ ( - "outw %b0, %w1" - : - : "a" (*dst), "Nd" (port) - ); - } else if (length == 4) { - __asm__ __volatile__ ( - "outw %b0, %w1" - : - : "a" (*dst), "Nd" (port) - ); + if (port < hook->port) { + n = n->rb_left; + } else if (port > hook->port) { + n = n->rb_right; + } else { + return hook; + } } - */ - return 0; -} -static int default_read(ushort_t port, void * dst, uint_t length, void * priv_data) -{ + return NULL; +} - /* - uchar_t value; - __asm__ __volatile__ ( - "inb %w1, %b0" - : "=a" (value) - : "Nd" (port) - ); - return value; - */ - return 0; -} -int hook_io_port(vmm_io_map_t * io_map, uint_t port, - int (*read)(ushort_t port, void * dst, uint_t length, void * priv_data), - int (*write)(ushort_t port, void * src, uint_t length, void * priv_data), - void * priv_data) { - vmm_io_hook_t * io_hook = os_hooks->malloc(sizeof(vmm_io_hook_t)); +int v3_hook_io_port(struct guest_info * info, uint16_t port, + int (*read)(uint16_t port, void * dst, uint_t length, void * priv_data), + int (*write)(uint16_t port, void * src, uint_t length, void * priv_data), + void * priv_data) { + struct v3_io_hook * io_hook = (struct v3_io_hook *)V3_Malloc(sizeof(struct v3_io_hook)); io_hook->port = port; @@ -145,49 +124,194 @@ int hook_io_port(vmm_io_map_t * io_map, uint_t port, io_hook->write = write; } - io_hook->next = NULL; - io_hook->prev = NULL; io_hook->priv_data = priv_data; - if (add_io_hook(io_map, io_hook) != 0) { - V3_Free(io_hook); - return -1; + if (insert_io_hook(info, io_hook)) { + PrintError("Could not insert IO hook for port %u (0x%x)\n", port, port); + V3_Free(io_hook); + return -1; + } + + if (info->io_map.update_map) { + if (info->io_map.update_map(info, port, + ((read == NULL) ? 0 : 1), + ((write == NULL) ? 0 : 1)) == -1) { + PrintError("Could not update IO map for port %u (0x%x)\n", port, port); + V3_Free(io_hook); + return -1; + } } return 0; } -int unhook_io_port(vmm_io_map_t * io_map, uint_t port) { - vmm_io_hook_t * hook = get_io_hook(io_map, port); +int v3_unhook_io_port(struct guest_info * info, uint16_t port) { + struct v3_io_hook * hook = v3_get_io_hook(info, port); - if (hook == NULL) { - return -1; - } + if (hook == NULL) { + PrintError("Could not find port to unhook %u (0x%x)\n", port, port); + return -1; + } - remove_io_hook(io_map, hook); - return 0; + v3_rb_erase(&(hook->tree_node), &(info->io_map.map)); + + if (info->io_map.update_map) { + // set the arch map to default (this should be 1, 1) + info->io_map.update_map(info, port, 0, 0); + } + + V3_Free(hook); + + return 0; } -vmm_io_hook_t * get_io_hook(vmm_io_map_t * io_map, uint_t port) { - vmm_io_hook_t * tmp_hook; - FOREACH_IO_HOOK(*io_map, tmp_hook) { - if (tmp_hook->port == port) { - return tmp_hook; + + + + + +void v3_refresh_io_map(struct guest_info * info) { + struct v3_io_map * io_map = &(info->io_map); + struct v3_io_hook * tmp = NULL; + + if (io_map->update_map == NULL) { + PrintError("Trying to refresh an io map with no backend\n"); + return; } - } - return NULL; + + v3_rb_for_each_entry(tmp, &(io_map->map), tree_node) { + io_map->update_map(info, tmp->port, + ((tmp->read == NULL) ? 0 : 1), + ((tmp->write == NULL) ? 0 : 1)); + } + } -void PrintDebugIOMap(vmm_io_map_t * io_map) { - vmm_io_hook_t * iter = io_map->head; +void v3_print_io_map(struct guest_info * info) { + struct v3_io_map * io_map = &(info->io_map); + struct v3_io_hook * tmp_hook = NULL; - PrintDebug("VMM IO Map (Entries=%d)\n", io_map->num_ports); + V3_Print("VMM IO Map\n"); - while (iter) { - PrintDebug("IO Port: %hu (Read=%x) (Write=%x)\n", iter->port, iter->read, iter->write); - } + v3_rb_for_each_entry(tmp_hook, &(io_map->map), tree_node) { + V3_Print("IO Port: %hu (Read=%p) (Write=%p)\n", + tmp_hook->port, + (void *)(tmp_hook->read), (void *)(tmp_hook->write)); + } +} + + + +/* + * Write a byte to an I/O port. + */ +void v3_outb(uint16_t port, uint8_t value) { + __asm__ __volatile__ ( + "outb %b0, %w1" + : + : "a" (value), "Nd" (port) + ); +} + +/* + * Read a byte from an I/O port. + */ +uint8_t v3_inb(uint16_t port) { + uint8_t value; + + __asm__ __volatile__ ( + "inb %w1, %b0" + : "=a" (value) + : "Nd" (port) + ); + + return value; +} + +/* + * Write a word to an I/O port. + */ +void v3_outw(uint16_t port, uint16_t value) { + __asm__ __volatile__ ( + "outw %w0, %w1" + : + : "a" (value), "Nd" (port) + ); +} + +/* + * Read a word from an I/O port. + */ +uint16_t v3_inw(uint16_t port) { + uint16_t value; + + __asm__ __volatile__ ( + "inw %w1, %w0" + : "=a" (value) + : "Nd" (port) + ); + + return value; +} + +/* + * Write a double word to an I/O port. + */ +void v3_outdw(uint16_t port, uint_t value) { + __asm__ __volatile__ ( + "outl %0, %1" + : + : "a" (value), "Nd" (port) + ); +} + +/* + * Read a double word from an I/O port. + */ +uint_t v3_indw(uint16_t port) { + uint_t value; + + __asm__ __volatile__ ( + "inl %1, %0" + : "=a" (value) + : "Nd" (port) + ); + + return value; +} + + + + +/* FIX ME */ +static int default_write(uint16_t port, void * src, uint_t length, void * priv_data) { + if (length == 1) { + v3_outb(port, *(uint8_t *)src); + } else if (length == 2) { + v3_outw(port, *(uint16_t *)src); + } else if (length == 4) { + v3_outdw(port, *(uint32_t *)src); + } else { + return -1; + } + + return length; +} + +static int default_read(uint16_t port, void * dst, uint_t length, void * priv_data) { + if (length == 1) { + *(uint8_t *)dst = v3_inb(port); + } else if (length == 2) { + *(uint16_t *)dst = v3_inw(port); + } else if (length == 4) { + *(uint32_t *)dst = v3_indw(port); + } else { + return -1; + } + + return length; }