of: overlay: remove a dependency on device node full_name

The "%pOF" printf format was recently added to print the
full name of a device tree node, with the intent of changing
the node full_name field to contain only the node name instead
of the full path of the node.

dup_and_fixup_symbol_prop() duplicates a property from the
"/__symbols__" node of an overlay device tree.  The value
of each duplicated property must be fixed up to include
the full path of a node in the live device tree.  The
current code uses the node's full_name for that purpose.
Update the code to use the "%pOF" printf format to
determine the node's full path.

Signed-off-by: Frank Rowand <frank.rowand@sony.com>
Signed-off-by: Rob Herring <robh@kernel.org>

diff --git a/drivers/of/base.c b/drivers/of/base.c
index b98f3ad..3de07e6 100644 (file)
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -658,7 +658,7 @@ struct device_node *of_get_child_by_name(const struct device_node *node,
 }
 EXPORT_SYMBOL(of_get_child_by_name);
 
-static struct device_node *__of_find_node_by_path(struct device_node *parent,
+struct device_node *__of_find_node_by_path(struct device_node *parent,
                                                const char *path)
 {
        struct device_node *child;

diff --git a/drivers/of/of_private.h b/drivers/of/of_private.h
index 2487305..92a9a36 100644 (file)
--- a/drivers/of/of_private.h
+++ b/drivers/of/of_private.h
@@ -110,6 +110,8 @@ extern void *__unflatten_device_tree(const void *blob,
 struct property *__of_prop_dup(const struct property *prop, gfp_t allocflags);
 __printf(2, 3) struct device_node *__of_node_dup(const struct device_node *np, const char *fmt, ...);
 
+struct device_node *__of_find_node_by_path(struct device_node *parent,
+                                               const char *path);
 struct device_node *__of_find_node_by_full_path(struct device_node *node,
                                                const char *path);
 

diff --git a/drivers/of/overlay.c b/drivers/of/overlay.c
index 602218e..0e9aefc 100644 (file)
--- a/drivers/of/overlay.c
+++ b/drivers/of/overlay.c
@@ -37,6 +37,7 @@ struct fragment {
 /**
  * struct overlay_changeset
  * @ovcs_list:         list on which we are located
+ * @overlay_tree:      expanded device tree that contains the fragment nodes
  * @count:             count of fragment structures
  * @fragments:         fragment nodes in the overlay expanded device tree
  * @symbols_fragment:  last element of @fragments[] is the  __symbols__ node
@@ -45,6 +46,7 @@ struct fragment {
 struct overlay_changeset {
        int id;
        struct list_head ovcs_list;
+       struct device_node *overlay_tree;
        int count;
        struct fragment *fragments;
        bool symbols_fragment;
@@ -145,12 +147,13 @@ static int overlay_notify(struct overlay_changeset *ovcs,
 }
 
 /*
- * The properties in the "/__symbols__" node are "symbols".
+ * The values of properties in the "/__symbols__" node are paths in
+ * the ovcs->overlay_tree.  When duplicating the properties, the paths
+ * need to be adjusted to be the correct path for the live device tree.
  *
- * The value of properties in the "/__symbols__" node is the path of a
- * node in the subtree of a fragment node's "__overlay__" node, for
- * example "/fragment@0/__overlay__/symbol_path_tail".  Symbol_path_tail
- * can be a single node or it may be a multi-node path.
+ * The paths refer to a node in the subtree of a fragment node's "__overlay__"
+ * node, for example "/fragment@0/__overlay__/symbol_path_tail",
+ * where symbol_path_tail can be a single node or it may be a multi-node path.
  *
  * The duplicated property value will be modified by replacing the
  * "/fragment_name/__overlay/" portion of the value  with the target
@@ -160,59 +163,76 @@ static struct property *dup_and_fixup_symbol_prop(
                struct overlay_changeset *ovcs, const struct property *prop)
 {
        struct fragment *fragment;
-       struct property *new;
-       const char *overlay_name;
-       char *symbol_path_tail;
-       char *symbol_path;
+       struct property *new_prop;
+       struct device_node *fragment_node;
+       struct device_node *overlay_node;
+       const char *path;
+       const char *path_tail;
        const char *target_path;
        int k;
-       int symbol_path_tail_len;
        int overlay_name_len;
+       int path_len;
+       int path_tail_len;
        int target_path_len;
 
        if (!prop->value)
                return NULL;
-       symbol_path = prop->value;
+       if (strnlen(prop->value, prop->length) >= prop->length)
+               return NULL;
+       path = prop->value;
+       path_len = strlen(path);
 
-       new = kzalloc(sizeof(*new), GFP_KERNEL);
-       if (!new)
+       if (path_len < 1)
                return NULL;
+       fragment_node = __of_find_node_by_path(ovcs->overlay_tree, path + 1);
+       overlay_node = __of_find_node_by_path(fragment_node, "__overlay__/");
+       of_node_put(fragment_node);
+       of_node_put(overlay_node);
 
        for (k = 0; k < ovcs->count; k++) {
                fragment = &ovcs->fragments[k];
-               overlay_name = fragment->overlay->full_name;
-               overlay_name_len = strlen(overlay_name);
-               if (!strncasecmp(symbol_path, overlay_name, overlay_name_len))
+               if (fragment->overlay == overlay_node)
                        break;
        }
-
        if (k >= ovcs->count)
-               goto err_free;
+               return NULL;
+
+       overlay_name_len = snprintf(NULL, 0, "%pOF", fragment->overlay);
 
-       target_path = fragment->target->full_name;
+       if (overlay_name_len > path_len)
+               return NULL;
+       path_tail = path + overlay_name_len;
+       path_tail_len = strlen(path_tail);
+
+       target_path = kasprintf(GFP_KERNEL, "%pOF", fragment->target);
+       if (!target_path)
+               return NULL;
        target_path_len = strlen(target_path);
 
-       symbol_path_tail = symbol_path + overlay_name_len;
-       symbol_path_tail_len = strlen(symbol_path_tail);
+       new_prop = kzalloc(sizeof(*new_prop), GFP_KERNEL);
+       if (!new_prop)
+               goto err_free_target_path;
 
-       new->name = kstrdup(prop->name, GFP_KERNEL);
-       new->length = target_path_len + symbol_path_tail_len + 1;
-       new->value = kzalloc(new->length, GFP_KERNEL);
+       new_prop->name = kstrdup(prop->name, GFP_KERNEL);
+       new_prop->length = target_path_len + path_tail_len + 1;
+       new_prop->value = kzalloc(new_prop->length, GFP_KERNEL);
+       if (!new_prop->name || !new_prop->value)
+               goto err_free_new_prop;
 
-       if (!new->name || !new->value)
-               goto err_free;
+       strcpy(new_prop->value, target_path);
+       strcpy(new_prop->value + target_path_len, path_tail);
 
-       strcpy(new->value, target_path);
-       strcpy(new->value + target_path_len, symbol_path_tail);
+       of_property_set_flag(new_prop, OF_DYNAMIC);
 
-       of_property_set_flag(new, OF_DYNAMIC);
+       return new_prop;
 
-       return new;
+err_free_new_prop:
+       kfree(new_prop->name);
+       kfree(new_prop->value);
+       kfree(new_prop);
+err_free_target_path:
+       kfree(target_path);
 
- err_free:
-       kfree(new->name);
-       kfree(new->value);
-       kfree(new);
        return NULL;
 }
 
@@ -519,6 +539,8 @@ static int init_overlay_changeset(struct overlay_changeset *ovcs,
        if (!of_node_is_root(tree))
                pr_debug("%s() tree is not root\n", __func__);
 
+       ovcs->overlay_tree = tree;
+
        INIT_LIST_HEAD(&ovcs->ovcs_list);
 
        of_changeset_init(&ovcs->cset);