WebSVN – HelenOS – Diff – //branches/tracing/boot/genarch/ofw_tree.c

     return balloc(sizeof(ofw_tree_node_t), sizeof(ofw_tree_node_t));
+}
 static ofw_tree_property_t *ofw_tree_properties_alloc(unsigned count)
+{
-    return balloc(count * sizeof(ofw_tree_property_t), sizeof(ofw_tree_property_t));
+    return balloc(count * sizeof(ofw_tree_property_t),
+        sizeof(ofw_tree_property_t));
+}
-static void * ofw_tree_space_alloc(size_t size)
+static void *ofw_tree_space_alloc(size_t size)
+{
     char *addr;
     /*
      * What we do here is a nasty hack :-)
     if (addr)
         addr[size] = '\0';
     return addr;
+}
-/** Transfer information from one OpenFirmware node into its memory representation.
+/** Transfer information from one OpenFirmware node into its memory
+ * representation.
+ *
- * Transfer entire information from the OpenFirmware device tree 'current' node to
+ * Transfer entire information from the OpenFirmware device tree 'current' node
- * its memory representation in 'current_node'. This function recursively processes
+ * to its memory representation in 'current_node'. This function recursively
- * all node's children. Node's peers are processed iteratively in order to prevent
+ * processes all node's children. Node's peers are processed iteratively in
- * stack from overflowing.
+ * order to prevent stack from overflowing.
+ *
- * @param current_node  Pointer to uninitialized ofw_tree_node structure that will
+ * @param current_node  Pointer to uninitialized ofw_tree_node structure that
- *          become the memory represenation of 'current'.
+ *          will become the memory represenation of 'current'.
- * @param parent_node   Parent ofw_tree_node structure or NULL in case of root node.
+ * @param parent_node   Parent ofw_tree_node structure or NULL in case of root
+ *          node.
  * @param current   OpenFirmware phandle to the current device tree node.
  */
 static void ofw_tree_node_process(ofw_tree_node_t *current_node,
     ofw_tree_node_t *parent_node, phandle current)
+{
-    static char path[MAX_PATH_LEN+1];
+    static char path[MAX_PATH_LEN + 1];
     static char name[OFW_TREE_PROPERTY_MAX_NAMELEN];
+    static char name2[OFW_TREE_PROPERTY_MAX_NAMELEN];
     phandle peer;
     phandle child;
     size_t len;
     int i;
         if (child != 0 && child != -1) {
             ofw_tree_node_t *child_node;
             child_node = ofw_tree_node_alloc();
             if (child_node) {
-                ofw_tree_node_process(child_node, current_node, child);
+                ofw_tree_node_process(child_node, current_node,
+                    child);
                 current_node->child = child_node;
+            }
+        }
         /*
          * Count properties.
          */
         name[0] = '\0';
-        while (ofw_next_property(current, name, name) == 1)
+        while (ofw_next_property(current, name, name2) == 1) {
             current_node->properties++;
+            memcpy(name, name2, OFW_TREE_PROPERTY_MAX_NAMELEN);
+        }
         if (!current_node->properties)
             return;
         /*
          * Copy properties.
          */
+        current_node->property =
-        current_node->property = ofw_tree_properties_alloc(current_node->properties);
+            ofw_tree_properties_alloc(current_node->properties);
         if (!current_node->property)
             return;
         name[0] = '\0';
-        for (i = 0; ofw_next_property(current, name, name) == 1; i++) {
+        for (i = 0; ofw_next_property(current, name, name2) == 1; i++) {
             size_t size;
             if (i == current_node->properties)
                 break;
+            memcpy(name, name2, OFW_TREE_PROPERTY_MAX_NAMELEN);
             memcpy(current_node->property[i].name, name,
                 OFW_TREE_PROPERTY_MAX_NAMELEN);
+            current_node->property[i].name[
-            current_node->property[i].name[OFW_TREE_PROPERTY_MAX_NAMELEN] = '\0';
+                OFW_TREE_PROPERTY_MAX_NAMELEN] = '\0';
             size = ofw_get_proplen(current, name);
             current_node->property[i].size = size;
             if (size) {
                 void *buf;
                 buf = ofw_tree_space_alloc(size);
                 if (current_node->property[i].value = buf) {
                     /*
                      * Copy property value to memory node.
                      */
-                    (void) ofw_get_property(current, name, buf, size);
+                    (void) ofw_get_property(current, name,
+                        buf, size);
+                }
             } else {
                 current_node->property[i].value = NULL;
+            }
+        }
-        current_node->properties = i;   /* Just in case we ran out of memory. */
+        /* Just in case we ran out of memory. */
+        current_node->properties = i;
         /*
          * Iteratively process the next peer node.
          * Note that recursion is a bad idea here.
          * Due to the topology of the OpenFirmware device tree,
+    }
+}
 /** Construct memory representation of OpenFirmware device tree.
+ *
- * @return NULL on failure or pointer to the root node.
+ * @return      NULL on failure or pointer to the root node.
  */
 ofw_tree_node_t *ofw_tree_build(void)
+{
     ofw_tree_node_t *root;
     phandle ssm_node;
      */
     ssm_node = ofw_find_device("/ssm@0,0");
     if (ssm_node != -1) {
         ssm = ofw_tree_node_alloc();
         if (ssm) {
-            ofw_tree_node_process(
+            ofw_tree_node_process(ssm, root,
-                ssm, root, ofw_find_device("/ssm@0,0"));
+                ofw_find_device("/ssm@0,0"));
             ssm->peer = root->child;
             root->child = ssm;
+        }
+    }

Subversion Repositories HelenOS

(root)//branches/tracing/boot/genarch/ofw_tree.c – Rev 3675 → 4377