diff mbox series

[v4,06/14] software node: get rid of property_set_pointer()

Message ID 20190911051231.148032-7-dmitry.torokhov@gmail.com (mailing list archive)
State Deferred, archived
Headers show
Series software node: add support for reference properties | expand

Commit Message

Dmitry Torokhov Sept. 11, 2019, 5:12 a.m. UTC 
Instead of explicitly setting values of integer types when copying
property entries lets just copy entire value union when processing
non-array values.

When handling array values assign the pointer there using the newly
introduced "raw" pointer union member. This allows us to remove
property_set_pointer().

In property_get_pointer() we do not need to handle each data type
separately, we can simply return either the raw pointer or pointer to
values union.

Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
---
 drivers/base/swnode.c    | 90 +++++++++-------------------------------
 include/linux/property.h | 12 ++----
 2 files changed, 22 insertions(+), 80 deletions(-)

Comments

Andy Shevchenko Sept. 11, 2019, 8:29 a.m. UTC | #1 
On Wed, Sep 11, 2019 at 8:15 AM Dmitry Torokhov
<dmitry.torokhov@gmail.com> wrote:
>
> Instead of explicitly setting values of integer types when copying
> property entries lets just copy entire value union when processing
> non-array values.
>
> When handling array values assign the pointer there using the newly
> introduced "raw" pointer union member. This allows us to remove
> property_set_pointer().
>
> In property_get_pointer() we do not need to handle each data type
> separately, we can simply return either the raw pointer or pointer to
> values union.

Same as before, typechecking is good thing to have for my point of view.
Others may have different opinions.
Dmitry Torokhov Sept. 11, 2019, 8:37 a.m. UTC | #2 
On Wed, Sep 11, 2019 at 11:29:10AM +0300, Andy Shevchenko wrote:
> On Wed, Sep 11, 2019 at 8:15 AM Dmitry Torokhov
> <dmitry.torokhov@gmail.com> wrote:
> >
> > Instead of explicitly setting values of integer types when copying
> > property entries lets just copy entire value union when processing
> > non-array values.
> >
> > When handling array values assign the pointer there using the newly
> > introduced "raw" pointer union member. This allows us to remove
> > property_set_pointer().
> >
> > In property_get_pointer() we do not need to handle each data type
> > separately, we can simply return either the raw pointer or pointer to
> > values union.
> 
> Same as before, typechecking is good thing to have for my point of view.
> Others may have different opinions.

OK, I'll just point out that typechecking is a red herring here as
everything was and still is accessed through void pointers, and we
trusted the type set on property. Users of static properties should use
PROPERTY_ENTRY_XXX() for initialization and do not poke into struct
property_entry directly.

I suppose it is up to Rafael to decide here.

Thanks.
Andy Shevchenko Sept. 11, 2019, 9:21 a.m. UTC | #3 
On Wed, Sep 11, 2019 at 01:37:25AM -0700, Dmitry Torokhov wrote:
> On Wed, Sep 11, 2019 at 11:29:10AM +0300, Andy Shevchenko wrote:
> > On Wed, Sep 11, 2019 at 8:15 AM Dmitry Torokhov
> > <dmitry.torokhov@gmail.com> wrote:
> > >
> > > Instead of explicitly setting values of integer types when copying
> > > property entries lets just copy entire value union when processing
> > > non-array values.
> > >
> > > When handling array values assign the pointer there using the newly
> > > introduced "raw" pointer union member. This allows us to remove
> > > property_set_pointer().
> > >
> > > In property_get_pointer() we do not need to handle each data type
> > > separately, we can simply return either the raw pointer or pointer to
> > > values union.
> > 
> > Same as before, typechecking is good thing to have for my point of view.
> > Others may have different opinions.
> 
> OK, I'll just point out that typechecking is a red herring here as
> everything was and still is accessed through void pointers, and we
> trusted the type set on property. Users of static properties should use
> PROPERTY_ENTRY_XXX() for initialization and do not poke into struct
> property_entry directly.
> 
> I suppose it is up to Rafael to decide here.

Yes, and perhaps Mika as they were the main authors of the idea and
implementation.
diff mbox series

Patch

diff --git a/drivers/base/swnode.c b/drivers/base/swnode.c
index 7bad41a8f65d..726195d334e4 100644
--- a/drivers/base/swnode.c
+++ b/drivers/base/swnode.c
@@ -103,71 +103,15 @@  property_entry_get(const struct property_entry *prop, const char *name)
 	return NULL;
 }
 
-static void
-property_set_pointer(struct property_entry *prop, const void *pointer)
-{
-	switch (prop->type) {
-	case DEV_PROP_U8:
-		if (prop->is_array)
-			prop->pointer.u8_data = pointer;
-		else
-			prop->value.u8_data = *((u8 *)pointer);
-		break;
-	case DEV_PROP_U16:
-		if (prop->is_array)
-			prop->pointer.u16_data = pointer;
-		else
-			prop->value.u16_data = *((u16 *)pointer);
-		break;
-	case DEV_PROP_U32:
-		if (prop->is_array)
-			prop->pointer.u32_data = pointer;
-		else
-			prop->value.u32_data = *((u32 *)pointer);
-		break;
-	case DEV_PROP_U64:
-		if (prop->is_array)
-			prop->pointer.u64_data = pointer;
-		else
-			prop->value.u64_data = *((u64 *)pointer);
-		break;
-	case DEV_PROP_STRING:
-		if (prop->is_array)
-			prop->pointer.str = pointer;
-		else
-			prop->value.str = pointer;
-		break;
-	default:
-		break;
-	}
-}
-
 static const void *property_get_pointer(const struct property_entry *prop)
 {
-	switch (prop->type) {
-	case DEV_PROP_U8:
-		if (prop->is_array)
-			return prop->pointer.u8_data;
-		return &prop->value.u8_data;
-	case DEV_PROP_U16:
-		if (prop->is_array)
-			return prop->pointer.u16_data;
-		return &prop->value.u16_data;
-	case DEV_PROP_U32:
-		if (prop->is_array)
-			return prop->pointer.u32_data;
-		return &prop->value.u32_data;
-	case DEV_PROP_U64:
-		if (prop->is_array)
-			return prop->pointer.u64_data;
-		return &prop->value.u64_data;
-	case DEV_PROP_STRING:
-		if (prop->is_array)
-			return prop->pointer.str;
-		return &prop->value.str;
-	default:
+	if (!prop->length)
 		return NULL;
-	}
+
+	if (prop->is_array)
+		return prop->pointer;
+
+	return &prop->value;
 }
 
 static const void *property_entry_find(const struct property_entry *props,
@@ -322,13 +266,15 @@  static int property_entry_read_string_array(const struct property_entry *props,
 static void property_entry_free_data(const struct property_entry *p)
 {
 	const void *pointer = property_get_pointer(p);
+	const char * const *src_str;
 	size_t i, nval;
 
 	if (p->is_array) {
-		if (p->type == DEV_PROP_STRING && p->pointer.str) {
+		if (p->type == DEV_PROP_STRING && p->pointer) {
+			src_str = p->pointer;
 			nval = p->length / sizeof(const char *);
 			for (i = 0; i < nval; i++)
-				kfree(p->pointer.str[i]);
+				kfree(src_str[i]);
 		}
 		kfree(pointer);
 	} else if (p->type == DEV_PROP_STRING) {
@@ -341,6 +287,7 @@  static const char * const *
 property_copy_string_array(const struct property_entry *src)
 {
 	const char **d;
+	const char * const *src_str = src->pointer;
 	size_t nval = src->length / sizeof(*d);
 	int i;
 
@@ -349,8 +296,8 @@  property_copy_string_array(const struct property_entry *src)
 		return NULL;
 
 	for (i = 0; i < nval; i++) {
-		d[i] = kstrdup(src->pointer.str[i], GFP_KERNEL);
-		if (!d[i] && src->pointer.str[i]) {
+		d[i] = kstrdup(src_str[i], GFP_KERNEL);
+		if (!d[i] && src_str[i]) {
 			while (--i >= 0)
 				kfree(d[i]);
 			kfree(d);
@@ -380,20 +327,21 @@  static int property_entry_copy_data(struct property_entry *dst,
 			if (!new)
 				return -ENOMEM;
 		}
+
+		dst->is_array = true;
+		dst->pointer = new;
 	} else if (src->type == DEV_PROP_STRING) {
 		new = kstrdup(src->value.str, GFP_KERNEL);
 		if (!new && src->value.str)
 			return -ENOMEM;
+
+		dst->value.str = new;
 	} else {
-		new = pointer;
+		dst->value = src->value;
 	}
 
 	dst->length = src->length;
-	dst->is_array = src->is_array;
 	dst->type = src->type;
-
-	property_set_pointer(dst, new);
-
 	dst->name = kstrdup(src->name, GFP_KERNEL);
 	if (!dst->name)
 		goto out_free_data;
diff --git a/include/linux/property.h b/include/linux/property.h
index 2c9d4d209296..ec8f84d564a8 100644
--- a/include/linux/property.h
+++ b/include/linux/property.h
@@ -233,13 +233,7 @@  struct property_entry {
 	bool is_array;
 	enum dev_prop_type type;
 	union {
-		union {
-			const u8 *u8_data;
-			const u16 *u16_data;
-			const u32 *u32_data;
-			const u64 *u64_data;
-			const char * const *str;
-		} pointer;
+		const void *pointer;
 		union {
 			u8 u8_data;
 			u16 u16_data;
@@ -262,7 +256,7 @@  struct property_entry {
 	.length = (_len_) * sizeof(_type_),				\
 	.is_array = true,						\
 	.type = DEV_PROP_##_Type_,					\
-	{ .pointer = { ._type_##_data = _val_ } },			\
+	{ .pointer = _val_ },						\
 }
 
 #define PROPERTY_ENTRY_U8_ARRAY_LEN(_name_, _val_, _len_)		\
@@ -280,7 +274,7 @@  struct property_entry {
 	.length = (_len_) * sizeof(const char *),			\
 	.is_array = true,						\
 	.type = DEV_PROP_STRING,					\
-	{ .pointer = { .str = _val_ } },				\
+	{ .pointer = _val_ },						\
 }
 
 #define PROPERTY_ENTRY_U8_ARRAY(_name_, _val_)				\