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 mterm_main(void *udata) { size_t cmds_len; char cmds[MTERM_CMD_STRING_SIZE]; /* Print Banner */ vmm_printf("%s", VMM_BANNER_STRING); /* Main loop of VMM */ while (1) { /* Show prompt */ vmm_printf("XVisor# "); vmm_memset(cmds, 0, sizeof(cmds)); /* Get command string */ vmm_gets(cmds, MTERM_CMD_STRING_SIZE, '\n'); cmds_len = vmm_strlen(cmds); if (cmds_len > 0) { if (cmds[cmds_len - 1] == '\r') cmds[cmds_len - 1] = '\0'; /* Execute command string */ vmm_cmdmgr_execute_cmdstr(vmm_stdio_device(), cmds); } } return VMM_OK; }
hvm_bool PagerAddLine(Bit8u *line) { Bit32u len; /* Perform some checks */ /* No more space? */ if(current_page >= PAGES) return FALSE; /* As we take care of checking this at this very function end, if we arrive here it means something is screwed up */ if(current_line >= OUT_SIZE_Y) return FALSE; len = vmm_strlen(line); if(len >= OUT_SIZE_X) len = OUT_SIZE_X - 1; vmm_strncpy(pages[current_page][current_line], line, len); current_line++; if(current_line >= OUT_SIZE_Y) { /* Flip one page */ current_line = 0; /* The check at the beginning of the function will take care of EOPages */ current_page++; } return TRUE; }
int libfdt_parse_devtree(struct fdt_fileinfo * fdt, struct vmm_devtree_node ** root) { char *data; /* Sanity check */ if (!fdt) { return VMM_EFAIL; } /* Get data pointer */ data = fdt->data; /* Sanity check */ if (LIBFDT_DATA32(data) != FDT_BEGIN_NODE) return VMM_EFAIL; /* Point to root node name */ data += sizeof(fdt_cell_t); /* Create root node */ *root = vmm_devtree_addnode(NULL, data, VMM_DEVTREE_NODETYPE_UNKNOWN, NULL); /* Skip root node name */ data += vmm_strlen(data) + 1; while ((virtual_addr_t) (data) % sizeof(fdt_cell_t) != 0) { (data)++; } /* Parse FDT recursively */ libfdt_parse_devtree_recursive(fdt, *root, &data); return VMM_OK; }
void cmdline_parse(const char *cmdline, const cmdline_option_t *options, char vals[][MAX_VALUE_LEN]) { const char *p = cmdline; int i; /* copy default values to vals[] */ for ( i = 0; options[i].name != NULL; i++ ) { vmm_strncpy(vals[i], options[i].def_val, MAX_VALUE_LEN-1); vals[i][MAX_VALUE_LEN-1] = '\0'; } if ( p == NULL ) return; /* parse options */ while ( 1 ) { /* skip whitespace */ while ( isspace(*p) ) p++; if ( *p == '\0' ) break; /* find end of current option */ const char *opt_start = p; const char *opt_end = (const char*)vmm_strchr(opt_start, ' '); if ( opt_end == NULL ) opt_end = opt_start + vmm_strlen(opt_start); p = opt_end; /* find value part; if no value found, use default and continue */ const char *val_start = vmm_strchr(opt_start, '='); if ( val_start == NULL || val_start > opt_end ) continue; val_start++; unsigned int opt_name_size = val_start - opt_start - 1; unsigned int copy_size = opt_end - val_start; if ( copy_size > MAX_VALUE_LEN - 1 ) copy_size = MAX_VALUE_LEN - 1; if ( opt_name_size == 0 || copy_size == 0 ) continue; /* value found, so copy it */ for ( i = 0; options[i].name != NULL; i++ ) { if ( vmm_strncmp(options[i].name, opt_start, opt_name_size ) == 0 ) { vmm_strncpy(vals[i], val_start, copy_size); vals[i][copy_size] = '\0'; /* add '\0' to the end of string */ break; } } } }
static void libfdt_parse_devtree_recursive(struct fdt_fileinfo * fdt, struct vmm_devtree_node * node, char **data) { u32 type, len; const char * name; struct vmm_devtree_node *child; if (!fdt || !node) { return; } while (LIBFDT_DATA32(*data) != FDT_END_NODE) { switch (LIBFDT_DATA32(*data)) { case FDT_PROP: *data += sizeof(fdt_cell_t); len = LIBFDT_DATA32(*data); *data += sizeof(fdt_cell_t); name = &fdt->str[LIBFDT_DATA32(*data)]; *data += sizeof(fdt_cell_t); type = vmm_devtree_estimate_attrtype(name); vmm_devtree_setattr(node, name, *data, type, len); *data += len; while ((virtual_addr_t) (*data) % sizeof(fdt_cell_t) != 0) (*data)++; break; case FDT_NOP: *data += sizeof(fdt_cell_t); break; case FDT_BEGIN_NODE: *data += sizeof(fdt_cell_t); type = VMM_DEVTREE_NODETYPE_UNKNOWN; child = vmm_devtree_addnode(node, *data, type, NULL); *data += vmm_strlen(*data) + 1; while ((virtual_addr_t) (*data) % sizeof(fdt_cell_t) != 0) { (*data)++; } libfdt_parse_devtree_recursive(fdt, child, data); break; default: return; break; }; } *data += sizeof(fdt_cell_t); return; }
struct fdt_property * libfdt_get_property(struct fdt_fileinfo * fdt, struct fdt_node_header * fdt_node, const char * property) { u32 len = 0x0; struct fdt_property * ret = NULL; char * data = NULL; /* Sanity checks */ if (!fdt || !fdt_node || !property) { return NULL; } /* Sanity checks */ if (fdt_node->tag != FDT_BEGIN_NODE) return NULL; /* Convert node to character stream */ data = (char *)fdt_node; data += sizeof(fdt_cell_t); /* Skip node name */ len = vmm_strlen(data); data += len + 1; while ((virtual_addr_t) (data) % sizeof(fdt_cell_t) != 0) { data++; } /* Find node property and its value */ ret = NULL; while (LIBFDT_DATA32(data) == FDT_PROP) { data += sizeof(fdt_cell_t); len = LIBFDT_DATA32(data); data += sizeof(fdt_cell_t); if (!vmm_strcmp(&fdt->str[LIBFDT_DATA32(data)], property)) { data -= sizeof(fdt_cell_t) * 2; ret = (struct fdt_property *)data; break; } data += sizeof(fdt_cell_t); data += len; while ((virtual_addr_t) (data) % sizeof(fdt_cell_t) != 0) { (data)++; } } return ret; }
static struct fdt_node_header * libfdt_find_node_recursive(char **data, char *str, const char * node_path) { struct fdt_node_header * ret = NULL; u32 i, valid, len = 0x0; while ((*node_path == ' ') || (*node_path == '\t') || (*node_path == '\r') || (*node_path == '\n')) { node_path++; } if (LIBFDT_DATA32(*data) != FDT_BEGIN_NODE) return NULL; *data += sizeof(fdt_cell_t); len = vmm_strlen(*data); valid = 1; for (i = 0; i < len; i++) { if (!node_path[i]) { valid = 0; break; } if ((*data)[i] != node_path[i]) { valid = 0; break; } } if (valid) { node_path += len; if (*node_path == '/') { node_path++; } while ((*node_path == ' ') || (*node_path == '\t') || (*node_path == '\r') || (*node_path == '\n')) { node_path++; } if (*node_path == '\0') { *data -= sizeof(fdt_cell_t); return (struct fdt_node_header *)(*data); } } *data += len + 1; while ((virtual_addr_t) (*data) % sizeof(fdt_cell_t) != 0) { (*data)++; } while (LIBFDT_DATA32(*data) != FDT_END_NODE) { switch (LIBFDT_DATA32(*data)) { case FDT_PROP: *data += sizeof(fdt_cell_t); len = LIBFDT_DATA32(*data); *data += sizeof(fdt_cell_t); *data += sizeof(fdt_cell_t); *data += len; while ((virtual_addr_t) (*data) % sizeof(fdt_cell_t) != 0) { (*data)++; } break; case FDT_NOP: *data += sizeof(fdt_cell_t); break; case FDT_BEGIN_NODE: ret = libfdt_find_node_recursive(data, str, node_path); if (ret) { return ret; } break; default: return NULL; break; }; } *data += sizeof(fdt_cell_t); return NULL; }