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;
}
