Subversion Repositories HelenOS

/*

 * Copyright (c) 2009 Pavel Rimsky

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright

 *   notice, this list of conditions and the following disclaimer in the

 *   documentation and/or other materials provided with the distribution.

 * - The name of the author may not be used to endorse or promote products

 *   derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/** @addtogroup sparc64

 * @{

 */

/** @file

 */

#include <debug.h>

#include <panic.h>

#include <func.h>

#include <print.h>

#include <arch/sun4v/md.h>

#include <arch/sun4v/hypercall.h>

#include <arch/mm/page.h>

/* maximum MD size estimate (in bytes) */

#define MD_MAX_SIZE (64 * 1024)

/** element types (element tag values) */

#define LIST_END    0x0 /**< End of element list */

#define NODE        0x4e    /**< Start of node definition */

#define NODE_END    0x45    /**< End of node definition */

#define NOOP        0x20    /**< NOOP list element - to be ignored */

#define PROP_ARC    0x61    /**< Node property arc'ing to another node */

#define PROP_VAL    0x76    /**< Node property with an integer value */

#define PROP_STR    0x73    /**< Node property with a string value */

#define PROP_DATA   0x64    /**< Node property with a block of data */

/** machine description header */

typedef struct {

    uint32_t transport_version; /**< Transport version number */

    uint32_t node_blk_sz;       /**< Size in bytes of node block */

    uint32_t name_blk_sz;       /**< Size in bytes of name block */

    uint32_t data_blk_sz;       /**< Size in bytes of data block */

} __attribute__ ((packed)) md_header_t;

/** machine description element (in the node block) */

typedef struct {

    uint8_t tag;            /**< Type of element */

    uint8_t name_len;       /**< Length in bytes of element name */

    uint16_t _reserved_field;   /**< reserved field (zeros) */

    uint32_t name_offset;       /**< Location offset of name associated

                         with this element relative to

                         start of name block */

    union {

        /** for elements of type “PROP_STR” and of type “PROP_DATA” */

        struct {

            /** Length in bytes of data in data block */

            uint32_t data_len;

            /**

             * Location offset of data associated with this

             * element relative to start of data block

             */

            uint32_t data_offset;

        } y;

        /**

         *  64 bit value for elements of tag type “NODE”, “PROP_VAL”

         *  or “PROP_ARC”

         */

        uint64_t val;

    } d;

} __attribute__ ((packed)) md_element_t;

/** index of the element within the node block */

typedef unsigned int element_idx_t;

/** buffer to which the machine description will be saved */

static uint8_t mach_desc[MD_MAX_SIZE]

     __attribute__ ((aligned (16)));

/** returns pointer to the element at the given index */

static md_element_t *get_element(element_idx_t idx)

{

    return (md_element_t *) (

        mach_desc + sizeof(md_header_t) + idx * sizeof(md_element_t));

}

/** returns the name of the element represented by the index */

static const char *get_element_name(element_idx_t idx)

{

    md_header_t *md_header = (md_header_t *) mach_desc;

    uintptr_t name_offset = get_element(idx)->name_offset;

    return (char *) mach_desc + sizeof(md_header_t) +

        md_header->node_blk_sz + name_offset;

}

/** finds the name of the node represented by "node" */

const char *md_get_node_name(md_node_t node)

{

    return get_element_name(node);

}

/**

 * Returns the value of the integer property of the given node.

 *

 * @param

 */

bool md_get_integer_property(md_node_t node, const char *key,

    uint64_t *result)

{

    element_idx_t idx = node;  

    while (get_element(idx)->tag != NODE_END) {

        idx++;

        md_element_t *element = get_element(idx);

        if (element->tag == PROP_VAL &&

                strcmp(key, get_element_name(idx)) == 0) {

            *result = element->d.val;

            return true;

        }

    }

    return false;

}

/**

 * Returns the value of the string property of the given node.

 *

 * @param

 */

bool md_get_string_property(md_node_t node, const char *key,

    const char **result)

{

    md_header_t *md_header = (md_header_t *) mach_desc;

    element_idx_t idx = node;

    while (get_element(idx)->tag != NODE_END) {

        idx++;

        md_element_t *element = get_element(idx);

        if (element->tag == PROP_DATA &&

                strcmp(key, get_element_name(idx)) == 0) {

            *result = (char *) mach_desc + sizeof(md_header_t) +

                md_header->node_blk_sz + md_header->name_blk_sz +

                element->d.y.data_offset;

            return true;

        }

    }

    return false;

}

/**

 * Moves the child oterator to the next child (following sibling of the node

 * the oterator currently points to).

 *

 * @param it    pointer to the iterator to be moved

 */

bool md_next_child(md_child_iter_t *it)

{

    element_idx_t backup = *it;

    while (get_element(*it)->tag != NODE_END) {

        (*it)++;

        md_element_t *element = get_element(*it);

        if (element->tag == PROP_ARC &&

                strcmp("fwd", get_element_name(*it)) == 0) {

            return true;

        }

    }

    *it = backup;

    return false;

}

/**

 * Returns the node the iterator point to.

 */

md_node_t md_get_child_node(md_child_iter_t it)

{

    return get_element(it)->d.val;

}

/**

 * Helper function used to split a string to a part before the first

 * slash sign and a part after the slash sign.

 *

 * @param str   pointer to the string to be split; when the function finishes,

 *      it will contain only the part following the first slash sign of

 *      the original string

 * @param head  pointer to the string which will be set to the part before the

 *      first slash sign

 */

static bool str_parse_head(char **str, char **head)

{

    *head = *str;

    char *cur = *str;

    while (*cur != '\0') {

        if (*cur == '/') {

            *cur = '\0';

            *str = cur + 1;

            return true;

        }

        cur++;

    }

    return false;

}

/**

 * Returns the descendant of the given node. The descendant is identified

 * by a path where the node names are separated by a slash.

 *

 * Ex.: Let there be a node N with path "a/b/c/x/y/z" and let P represent the

 * node with path "a/b/c". Then md_get_child(P, "x/y/z") will return N.

 */

md_node_t md_get_child(md_node_t node, char *name)

{

    bool more;

    do {

        char *head;

        more = str_parse_head(&name, &head);

        while (md_next_child(&node)) {

            element_idx_t child = md_get_child_node(node);

            if (strcmp(head, get_element_name(child)) == 0) {

                node = child;

                break;

            }

        }

    } while (more);

    return node;

}

/** returns the root node of MD */

md_node_t md_get_root(void)

{

    return 0;

}

/**

 * Returns the child iterator - a token to be passed to functions iterating

 * through all the children of a node.

 *

 * @param node  a node whose children the iterator will be used

 *      to iterate through

 */

md_child_iter_t md_get_child_iterator(md_node_t node)

{

    return node;

}

/**

 * Moves "node" to the node following "node" in the list of all the existing

 * nodes of the MD whose name is "name".

 */

bool md_next_node(md_node_t *node, const char *name)

{

    md_element_t *element;

    (*node)++;

    do {

        element = get_element(*node);

        if (element->tag == NODE &&

                strcmp(name, get_element_name(*node)) == 0) {

            return true;

        }

        (*node)++;

    } while (element->tag != LIST_END);

    return false;

}

/**

 * Retrieves the machine description from the hypervisor and saves it to

 * a kernel buffer.

 */

void md_init(void)

{

    uint64_t retval = __hypercall_fast2(MACH_DESC, KA2PA(mach_desc),

        MD_MAX_SIZE);

    retval = retval;

    if (retval != EOK) {

        printf("Could not retrieve machine description, error = %d.\n",

            retval);

    }

}

/** @}

 */