thunderbolt: Add tb_property_merge_dir()

This allows merging one XDomain property directory into another. We are
going to use this in the subsequent patch.

Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>

diff --git a/drivers/thunderbolt/property.c b/drivers/thunderbolt/property.c
index 50cbfc92fe65ed8fdcc0351afbd590efa2e7e152..6b9666b61181865f5bc6f82326193bd2586aa436 100644 (file)
--- a/drivers/thunderbolt/property.c
+++ b/drivers/thunderbolt/property.c
@@ -38,6 +38,7 @@ struct tb_property_dir_entry {
 static struct tb_property_dir *__tb_property_parse_dir(const u32 *block,
        size_t block_len, unsigned int dir_offset, size_t dir_len,
        bool is_root);
+static struct tb_property *tb_property_copy(const struct tb_property *property);
 
 static inline void parse_dwdata(void *dst, const void *src, size_t dwords)
 {
@@ -507,17 +508,9 @@ ssize_t tb_property_format_dir(const struct tb_property_dir *dir, u32 *block,
        return ret < 0 ? ret : 0;
 }
 
-/**
- * tb_property_copy_dir() - Take a deep copy of directory
- * @dir: Directory to copy
- *
- * The resulting directory needs to be released by calling tb_property_free_dir().
- *
- * Return: Pointer to &struct tb_property_dir, %NULL in case of failure.
- */
-struct tb_property_dir *tb_property_copy_dir(const struct tb_property_dir *dir)
+static struct tb_property_dir *copy_dir(const struct tb_property_dir *dir)
 {
-       struct tb_property *property, *p = NULL;
+       struct tb_property *property, *p;
        struct tb_property_dir *d;
 
        if (!dir)
@@ -528,56 +521,131 @@ struct tb_property_dir *tb_property_copy_dir(const struct tb_property_dir *dir)
                return NULL;
 
        list_for_each_entry(property, &dir->properties, list) {
-               struct tb_property *p;
-
-               p = tb_property_alloc(property->key, property->type);
+               p = tb_property_copy(property);
                if (!p)
                        goto err_free;
+               list_add_tail(&p->list, &d->properties);
+       }
 
-               p->length = property->length;
+       return d;
 
-               switch (property->type) {
-               case TB_PROPERTY_TYPE_DIRECTORY:
-                       p->value.dir = tb_property_copy_dir(property->value.dir);
-                       if (!p->value.dir)
-                               goto err_free;
-                       break;
+err_free:
+       tb_property_free_dir(d);
+       return NULL;
+}
 
-               case TB_PROPERTY_TYPE_DATA:
-                       p->value.data = kmemdup(property->value.data,
-                                               property->length * 4,
-                                               GFP_KERNEL);
-                       if (!p->value.data)
-                               goto err_free;
-                       break;
+static struct tb_property *tb_property_copy(const struct tb_property *property)
+{
+       struct tb_property *p;
 
-               case TB_PROPERTY_TYPE_TEXT:
-                       p->value.text = kzalloc(p->length * 4, GFP_KERNEL);
-                       if (!p->value.text)
-                               goto err_free;
-                       strcpy(p->value.text, property->value.text);
-                       break;
+       p = tb_property_alloc(property->key, property->type);
+       if (!p)
+               return NULL;
 
-               case TB_PROPERTY_TYPE_VALUE:
-                       p->value.immediate = property->value.immediate;
-                       break;
+       p->length = property->length;
+       switch (property->type) {
+       case TB_PROPERTY_TYPE_DIRECTORY:
+               p->value.dir = copy_dir(property->value.dir);
+               if (!p->value.dir)
+                       goto err_free;
+               break;
 
-               default:
-                       break;
-               }
+       case TB_PROPERTY_TYPE_DATA:
+               p->value.data = kmemdup(property->value.data,
+                                       property->length * 4,
+                                       GFP_KERNEL);
+               if (!p->value.data)
+                       goto err_free;
+               break;
 
-               list_add_tail(&p->list, &d->properties);
+       case TB_PROPERTY_TYPE_TEXT:
+               p->value.text = kzalloc(p->length * 4, GFP_KERNEL);
+               if (!p->value.text)
+                       goto err_free;
+               strcpy(p->value.text, property->value.text);
+               break;
+
+       case TB_PROPERTY_TYPE_VALUE:
+               p->value.immediate = property->value.immediate;
+               break;
+
+       default:
+               break;
        }
 
-       return d;
+       return p;
 
 err_free:
        kfree(p);
-       tb_property_free_dir(d);
-
        return NULL;
 }
 
+/**
+ * tb_property_copy_dir() - Take a deep copy of directory
+ * @dir: Directory to copy
+ *
+ * The resulting directory needs to be released by calling tb_property_free_dir().
+ *
+ * Return: Pointer to &struct tb_property_dir, %NULL in case of failure.
+ */
+struct tb_property_dir *tb_property_copy_dir(const struct tb_property_dir *dir)
+{
+       return copy_dir(dir);
+}
+EXPORT_SYMBOL_GPL(tb_property_copy_dir);
+
+/**
+ * tb_property_merge_dir() - Merges directory into parent
+ * @parent: Directory to merge @dir
+ * @dir: Directory that is merged
+ * @replace: Replace existing entries
+ *
+ * This will merge @dir into @parent. Both must have same UUID. The
+ * properties in @dir will overwrite overlapping properties in @parent
+ * if @replace is %true. Contents of @dir is copied (so if it is not
+ * needed afterwards it needs to relesed by calling tb_property_free_dir()).
+ */
+int tb_property_merge_dir(struct tb_property_dir *parent,
+                         const struct tb_property_dir *dir,
+                         bool replace)
+{
+       const struct tb_property *property;
+
+       if (WARN_ON(parent == dir))
+               return -EINVAL;
+
+       if (!uuid_equal(parent->uuid, dir->uuid))
+               return -EINVAL;
+
+       list_for_each_entry(property, &dir->properties, list) {
+               struct tb_property *p, *tmp;
+
+               tmp = tb_property_copy(property);
+               if (!tmp)
+                       return -ENOMEM;
+
+               p = tb_property_find(parent, property->key, property->type);
+               if (p) {
+                       if (replace) {
+                               /*
+                                * Found existing property in parent so
+                                * replace with the new one.
+                                */
+                               list_replace(&p->list, &tmp->list);
+                               tb_property_free(p);
+                       } else {
+                               tb_property_free(tmp);
+                               continue;
+                       }
+               } else {
+                       list_add_tail(&tmp->list, &parent->properties);
+               }
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(tb_property_merge_dir);
+
 /**
  * tb_property_add_immediate() - Add immediate property to directory
  * @parent: Directory to add the property

diff --git a/include/linux/thunderbolt.h b/include/linux/thunderbolt.h
index bbdbbc84c9998cb51fd7c0acda1412f1d90d9f26..e98d569779f9c4bd39985f7362e25d2702a2c666 100644 (file)
--- a/include/linux/thunderbolt.h
+++ b/include/linux/thunderbolt.h
@@ -153,6 +153,9 @@ struct tb_property_dir *tb_property_parse_dir(const u32 *block,
 ssize_t tb_property_format_dir(const struct tb_property_dir *dir, u32 *block,
                               size_t block_len);
 struct tb_property_dir *tb_property_copy_dir(const struct tb_property_dir *dir);
+int tb_property_merge_dir(struct tb_property_dir *parent,
+                         const struct tb_property_dir *dir,
+                         bool replace);
 struct tb_property_dir *tb_property_create_dir(const uuid_t *uuid);
 void tb_property_free_dir(struct tb_property_dir *dir);
 int tb_property_add_immediate(struct tb_property_dir *parent, const char *key,