int vmm_netdev_register(struct vmm_netdev * ndev) { struct vmm_classdev *cd; if (ndev == NULL) { return VMM_EFAIL; } if (ndev->read == NULL || ndev->write == NULL) { return VMM_EFAIL; } cd = vmm_malloc(sizeof(struct vmm_classdev)); if (!cd) { return VMM_EFAIL; } INIT_LIST_HEAD(&cd->head); vmm_strcpy(cd->name, ndev->name); cd->dev = ndev->dev; cd->priv = ndev; vmm_devdrv_register_classdev(VMM_NETDEV_CLASS_NAME, cd); return VMM_OK; }
int vmm_chardev_register(struct vmm_chardev * cdev) { int rc; struct vmm_classdev *cd; if (!(cdev && cdev->read && cdev->write)) { return VMM_EFAIL; } cd = vmm_malloc(sizeof(struct vmm_classdev)); if (!cd) { return VMM_EFAIL; } vmm_memset(cd, 0, sizeof(struct vmm_classdev)); INIT_LIST_HEAD(&cd->head); vmm_strcpy(cd->name, cdev->name); cd->dev = cdev->dev; cd->priv = cdev; rc = vmm_devdrv_register_classdev(VMM_CHARDEV_CLASS_NAME, cd); if (rc != VMM_OK) { vmm_free(cd); } return rc; }
void libfdt_node_parse_recursive(vmm_devtree_node_t * node, char **data_ptr, char *str_buf) { vmm_devtree_node_t *child; vmm_devtree_attr_t *attr; if (LIBFDT_DATA32(*data_ptr) != FDT_BEGIN_NODE) return; *data_ptr += sizeof(u32); node->name = vmm_malloc(vmm_strlen(*data_ptr) + 1); vmm_strcpy(node->name, *data_ptr); node->type = VMM_DEVTREE_NODETYPE_UNKNOWN; node->priv = NULL; *data_ptr += vmm_strlen(*data_ptr) + 1; while ((u32) (*data_ptr) % sizeof(u32) != 0) (*data_ptr)++; while (LIBFDT_DATA32(*data_ptr) != FDT_END_NODE) { switch (LIBFDT_DATA32(*data_ptr)) { case FDT_PROP: *data_ptr += sizeof(u32); attr = vmm_malloc(sizeof(vmm_devtree_attr_t)); INIT_LIST_HEAD(&attr->head); attr->len = LIBFDT_DATA32(*data_ptr); *data_ptr += sizeof(u32); attr->name = &str_buf[LIBFDT_DATA32(*data_ptr)]; *data_ptr += sizeof(u32); attr->value = vmm_malloc(attr->len); vmm_memcpy(attr->value, *data_ptr, attr->len); *data_ptr += attr->len; while ((u32) (*data_ptr) % sizeof(u32) != 0) (*data_ptr)++; list_add_tail(&node->attr_list, &attr->head); break; case FDT_NOP: *data_ptr += sizeof(u32); break; case FDT_BEGIN_NODE: child = vmm_malloc(sizeof(vmm_devtree_node_t)); INIT_LIST_HEAD(&child->head); INIT_LIST_HEAD(&child->attr_list); INIT_LIST_HEAD(&child->child_list); child->parent = node; libfdt_node_parse_recursive(child, data_ptr, str_buf); list_add_tail(&node->child_list, &child->head); break; default: return; break; }; } *data_ptr += sizeof(u32); return; }
static int ne2k_driver_probe(struct vmm_driver *dev, const struct vmm_devid *devid) { int rc; struct vmm_netdev *ndev; struct nic_priv_data *priv_data; ndev = vmm_malloc(sizeof(struct vmm_netdev)); if(!ndev) { rc = VMM_EFAIL; goto free_nothing; } vmm_memset(ndev,0, sizeof(struct vmm_netdev)); priv_data = vmm_malloc(sizeof(struct nic_priv_data)); if(!priv_data) { rc = VMM_EFAIL; goto free_chardev; } vmm_memset(priv_data,0, sizeof(struct nic_priv_data)); if (ne2k_init(priv_data)) { rc = VMM_EFAIL; goto free_chardev; } priv_data->txrx_thread = vmm_hyperthread_create("ne2k-isa-driver", dp83902a_poll, priv_data); if (priv_data == NULL) { rc = VMM_EFAIL; goto free_chardev; } vmm_hyperthread_run(priv_data->txrx_thread); vmm_strcpy(ndev->name, dev->node->name); ndev->dev = dev; ndev->ioctl = NULL; ndev->read = ne2k_read; ndev->write = ne2k_write; ndev->priv = (void *)priv_data; rc = vmm_netdev_register(ndev); if(rc) { goto free_port; } dev->priv = (void *)ndev; return VMM_OK; free_port: vmm_free(priv_data); free_chardev: vmm_free(ndev); free_nothing: return rc; }
static int cmd_vcpu_list(struct vmm_chardev *cdev, int dummy) { int id, count; char state[10]; char path[256]; struct vmm_vcpu *vcpu; vmm_cprintf(cdev, "----------------------------------------" "----------------------------------------\n"); vmm_cprintf(cdev, "| %-5s| %-6s| %-9s| %-16s| %-33s|\n", "ID ", "Prio", "State", "Name", "Device Path"); vmm_cprintf(cdev, "----------------------------------------" "----------------------------------------\n"); count = vmm_manager_vcpu_count(); for (id = 0; id < count; id++) { vcpu = vmm_manager_vcpu(id); switch (vcpu->state) { case VMM_VCPU_STATE_UNKNOWN: vmm_strcpy(state, "Unknown"); break; case VMM_VCPU_STATE_RESET: vmm_strcpy(state, "Reset"); break; case VMM_VCPU_STATE_READY: vmm_strcpy(state, "Ready"); break; case VMM_VCPU_STATE_RUNNING: vmm_strcpy(state, "Running"); break; case VMM_VCPU_STATE_PAUSED: vmm_strcpy(state, "Paused"); break; case VMM_VCPU_STATE_HALTED: vmm_strcpy(state, "Halted"); break; default: vmm_strcpy(state, "Invalid"); break; } if (vcpu->node) { vmm_devtree_getpath(path, vcpu->node); vmm_cprintf(cdev, "| %-5d| %-6d| %-9s| %-16s| %-33s|\n", id, vcpu->priority, state, vcpu->name, path); } else { vmm_cprintf(cdev, "| %-5d| %-6d| %-9s| %-16s| %-33s|\n", id, vcpu->priority, state, vcpu->name, "(NA)"); } } vmm_cprintf(cdev, "----------------------------------------" "----------------------------------------\n"); return VMM_OK; }
static int cmd_profile_count_iterator(void *data, const char *name, unsigned long addr) { struct count_record *ptr = data; u32 index = kallsyms_get_symbol_pos(addr, NULL, NULL); u32 count = vmm_profiler_get_function_count(addr); u64 time = vmm_profiler_get_function_total_time(addr); ptr += index; /* It would be nice to have the strncpy variant */ vmm_strcpy(ptr->function_name, name); ptr->function_name[39] = 0; ptr->count = count; ptr->total_time = time; if (count) { ptr->time_per_call = vmm_udiv64(time, (u64)count); } return VMM_OK; }
int vmm_netdev_init(void) { int rc; struct vmm_class *c; c = vmm_malloc(sizeof(struct vmm_class)); if (!c) { return VMM_EFAIL; } INIT_LIST_HEAD(&c->head); vmm_strcpy(c->name, VMM_NETDEV_CLASS_NAME); INIT_LIST_HEAD(&c->classdev_list); rc = vmm_devdrv_register_class(c); if (rc) { vmm_free(c); return rc; } return VMM_OK; }
int __init vmm_chardev_init(void) { int rc; struct vmm_class *c; c = vmm_malloc(sizeof(struct vmm_class)); if (!c) { return VMM_EFAIL; } vmm_memset(c, 0, sizeof(struct vmm_class)); INIT_LIST_HEAD(&c->head); vmm_strcpy(c->name, VMM_CHARDEV_CLASS_NAME); INIT_LIST_HEAD(&c->classdev_list); rc = vmm_devdrv_register_class(c); if (rc != VMM_OK) { vmm_free(c); } return rc; }
static int __init vmm_netdev_init(void) { int rc; struct vmm_class *c; vmm_printf("Initialize Networking Device Framework\n"); c = vmm_malloc(sizeof(struct vmm_class)); if (!c) { return VMM_EFAIL; } INIT_LIST_HEAD(&c->head); vmm_strcpy(c->name, VMM_NETDEV_CLASS_NAME); INIT_LIST_HEAD(&c->classdev_list); rc = vmm_devdrv_register_class(c); if (rc) { vmm_free(c); return rc; } return VMM_OK; }
static int uart_driver_probe(struct vmm_device *dev,const struct vmm_devid *devid) { int rc; const char *attr; struct vmm_chardev *cd; struct uart_port *port; cd = vmm_malloc(sizeof(struct vmm_chardev)); if(!cd) { rc = VMM_EFAIL; goto free_nothing; } vmm_memset(cd, 0, sizeof(struct vmm_chardev)); port = vmm_malloc(sizeof(struct uart_port)); if(!port) { rc = VMM_EFAIL; goto free_chardev; } vmm_memset(port, 0, sizeof(struct uart_port)); vmm_strcpy(cd->name, dev->node->name); cd->dev = dev; cd->ioctl = NULL; cd->read = uart_read; cd->write = uart_write; cd->priv = port; rc = vmm_devdrv_ioremap(dev, &port->base, 0); if(rc) { goto free_port; } attr = vmm_devtree_attrval(dev->node, "reg_align"); if (attr) { port->reg_align = *((u32 *)attr); } else { port->reg_align = 1; } attr = vmm_devtree_attrval(dev->node, "reg_offset"); if (attr) { port->base += *((u32 *)attr); } attr = vmm_devtree_attrval(dev->node, "baudrate"); if(!attr) { rc = VMM_EFAIL; goto free_port; } port->baudrate = *((u32 *)attr); port->input_clock = vmm_devdrv_clock_rate(dev); /* Call low-level init function */ uart_lowlevel_init(port->base, port->reg_align, port->baudrate, port->input_clock); rc = vmm_chardev_register(cd); if(rc) { goto free_port; } return VMM_OK; free_port: vmm_free(port); free_chardev: vmm_free(cd); free_nothing: return rc; }