Skip to contentSkip to conversation

gpio: mockup: refactoring + documentation

PATCH Superseded Bartosz Golaszewski 5 participants 26 messages Sep 28, 2020 – Sep 29, 2020

Subsystems (5)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

v2 cover gpio: mockup: refactoring + documentation

From: Bartosz Golaszewski <[email protected]>

These patches were part of the bigger overhaul of gpio-mockup but since the initial idea was dropped in favor of using configfs + sysfs in the future I thought I'd resent just the refactoring of the existing code
+ documentation patches. I think it's good to apply them since we don't really know when the new interface will be ready (configfs needs a new functionality - commitable items - to support mockup chip instantiation).

v1 -> v2:
- check for NULL pointer in kfree_strarray() to avoid having to always pass a zeroed string count when the array pointer is NULL
- collect review tags from Andy

Bartosz Golaszewski (9):
lib: string_helpers: provide kfree_strarray()
Documentation: gpio: add documentation for gpio-mockup
gpio: mockup: drop unneeded includes
gpio: mockup: use KBUILD_MODNAME
gpio: mockup: use pr_fmt()
gpio: mockup: remove unneeded return statement
gpio: mockup: pass the chip label as device property
gpio: mockup: use the generic 'gpio-line-names' property
gpio: mockup: refactor the module init function

 .../admin-guide/gpio/gpio-mockup.rst          |  50 ++++++
 drivers/gpio/gpio-mockup.c                    | 154 +++++++++---------
 include/linux/string_helpers.h                |   2 +
 lib/string_helpers.c                          |  25 +++
 4 files changed, 155 insertions(+), 76 deletions(-)
 create mode 100644 Documentation/admin-guide/gpio/gpio-mockup.rst
Signature · 1 line
2.26.1
#1 lore raw

PATCH v2 1/9 lib: string_helpers: provide kfree_strarray()

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

---
 include/linux/string_helpers.h |  2 ++
 lib/string_helpers.c           | 25 +++++++++++++++++++++++++
 2 files changed, 27 insertions(+)
include/linux/string_helpers.h +2 -0
index 86f150c2a6b6..55b25120a1c6 100644
@@ -94,4 +94,6 @@ char *kstrdup_quotable(const char *src, gfp_t gfp);
 char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp);
 char *kstrdup_quotable_file(struct file *file, gfp_t gfp);
 
+void kfree_strarray(char **str_array, size_t num_str);
+
 #endif
lib/string_helpers.c +25 -0
index 963050c0283e..bfa4c9f3ca0a 100644
@@ -649,3 +649,28 @@ char *kstrdup_quotable_file(struct file *file, gfp_t gfp)
 	return pathname;
 }
 EXPORT_SYMBOL_GPL(kstrdup_quotable_file);
+
+/**
+ * kfree_strarray - free a number of dynamically allocated strings contained
+ *                  in an array and the array itself
+ *
+ * @str_array: Dynamically allocated array of strings to free. If NULL - the
+ *             function does nothing.
+ * @num_str: Number of strings (starting from the beginning of the array) to
+ *           free.
+ *
+ * Passing a non-null str_array and num_str == 0 as well as NULL str_array
+ * are valid use-cases.
+ */
+void kfree_strarray(char **str_array, size_t num_str)
+{
+	unsigned int i;
+
+	if (!str_array)
+		return;
+
+	for (i = 0; i < num_str; i++)
+		kfree(str_array[i]);
+	kfree(str_array);
+}
+EXPORT_SYMBOL_GPL(kfree_strarray);
Signature · 1 line
2.26.1
#12 lore raw

PATCH v2 2/9 Documentation: gpio: add documentation for gpio-mockup

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's some documentation for gpio-mockup's debugfs interface in the driver's source but it's not much. Add proper documentation for this testing module.

---
 .../admin-guide/gpio/gpio-mockup.rst          | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 Documentation/admin-guide/gpio/gpio-mockup.rst
Documentation/admin-guide/gpio/gpio-mockup.rst new file +50 -0
new file mode 100644
index 000000000000..9fa1618b3adc
@@ -0,0 +1,50 @@
+.. SPDX-License-Identifier: GPL-2.0-only
+
+GPIO Testing Driver
+===================
+
+The GPIO Testing Driver (gpio-mockup) provides a way to create simulated GPIO
+chips for testing purposes. The lines exposed by these chips can be accessed
+using the standard GPIO character device interface as well as manipulated
+using the dedicated debugfs directory structure.
+
+Creating simulated chips using module params
+--------------------------------------------
+
+When loading the gpio-mockup driver a number of parameters can be passed to the
+module.
+
+    gpio_mockup_ranges
+
+        This parameter takes an argument in the form of an array of integer
+        pairs. Each pair defines the base GPIO number (if any) and the number
+        of lines exposed by the chip. If the base GPIO is -1, the gpiolib
+        will assign it automatically.
+
+        Example: gpio_mockup_ranges=-1,8,-1,16,405,4
+
+        The line above creates three chips. The first one will expose 8 lines,
+        the second 16 and the third 4. The base GPIO for the third chip is set
+        to 405 while for two first chips it will be assigned automatically.
+
+    gpio_named_lines
+
+        This parameter doesn't take any arguments. It lets the driver know that
+        GPIO lines exposed by it should be named.
+
+        The name format is: gpio-mockup-X-Y where X is mockup chip's ID
+        and Y is the line offset.
+
+Manipulating simulated lines
+----------------------------
+
+Each mockup chip creates its own subdirectory in /sys/kernel/debug/gpio-mockup/.
+The directory is named after the chip's label. A symlink is also created, named
+after the chip's name, which points to the label directory.
+
+Inside each subdirectory, there's a separate attribute for each GPIO line. The
+name of the attribute represents the line's offset in the chip.
+
+Reading from a line attribute returns the current value. Writing to it (0 or 1)
+changes the configuration of the simulated pull-up/pull-down resistor
+(1 - pull-up, 0 - pull-down).
Signature · 1 line
2.26.1
#14 lore raw

PATCH v2 4/9 gpio: mockup: use KBUILD_MODNAME

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Drop the definition for the driver name. Let's use KBUILD_MODNAME for the log format and use the "gpio-mockup" value directly in the only place where it's relevant: in the name of the device.

---
 drivers/gpio/gpio-mockup.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)
drivers/gpio/gpio-mockup.c +3 -4
index c5092773afd8..90a1d6c2775f 100644
@@ -21,7 +21,6 @@
 
 #include "gpiolib.h"
 
-#define GPIO_MOCKUP_NAME	"gpio-mockup"
 #define GPIO_MOCKUP_MAX_GC	10
 /*
  * We're storing two values per chip: the GPIO base and the number
@@ -31,7 +30,7 @@
 /* Maximum of three properties + the sentinel. */
 #define GPIO_MOCKUP_MAX_PROP	4
 
-#define gpio_mockup_err(...)	pr_err(GPIO_MOCKUP_NAME ": " __VA_ARGS__)
+#define gpio_mockup_err(...)	pr_err(KBUILD_MODNAME ": " __VA_ARGS__)
 
 /*
  * struct gpio_pin_status - structure describing a GPIO status
@@ -500,7 +499,7 @@ static int gpio_mockup_probe(struct platform_device *pdev)
 
 static struct platform_driver gpio_mockup_driver = {
 	.driver = {
-		.name = GPIO_MOCKUP_NAME,
+		.name = "gpio-mockup",
 	},
 	.probe = gpio_mockup_probe,
 };
@@ -572,7 +571,7 @@ static int __init gpio_mockup_init(void)
 			properties[prop++] = PROPERTY_ENTRY_BOOL(
 						"named-gpio-lines");
 
-		pdevinfo.name = GPIO_MOCKUP_NAME;
+		pdevinfo.name = "gpio-mockup";
 		pdevinfo.id = i;
 		pdevinfo.properties = properties;
 
Signature · 1 line
2.26.1
#16 lore raw

PATCH v2 6/9 gpio: mockup: remove unneeded return statement

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a return; at the end of a void function. This is not needed so remove it.

---
 drivers/gpio/gpio-mockup.c | 2 --
 1 file changed, 2 deletions(-)
drivers/gpio/gpio-mockup.c +0 -2
index c2b2f7d5ff34..de778b52f355 100644
@@ -372,8 +372,6 @@ static void gpio_mockup_debugfs_setup(struct device *dev,
 		debugfs_create_file(name, 0200, chip->dbg_dir, priv,
 				    &gpio_mockup_debugfs_ops);
 	}
-
-	return;
 }
 
 static int gpio_mockup_name_lines(struct device *dev,
Signature · 1 line
2.26.1
#17 lore raw

PATCH v2 7/9 gpio: mockup: pass the chip label as device property

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

While we do check the "chip-name" property in probe(), we never actually use it. Let's pass the chip label to the driver using device properties as we'll want to allow users to define their own once dynamically created chips are supported.

The property is renamed to "chip-label" to not cause any confusion with the actual chip name which is of the form: "gpiochipX".

If the "chip-label" property is missing, let's do what most devices in drivers/gpio/ do and use dev_name().

---
 drivers/gpio/gpio-mockup.c | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)
drivers/gpio/gpio-mockup.c +8 -9
index de778b52f355..5b2686f9e07d 100644
@@ -429,21 +429,14 @@ static int gpio_mockup_probe(struct platform_device *pdev)
 	if (rv)
 		return rv;
 
-	rv = device_property_read_string(dev, "chip-name", &name);
+	rv = device_property_read_string(dev, "chip-label", &name);
 	if (rv)
-		name = NULL;
+		name = dev_name(dev);
 
 	chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
 	if (!chip)
 		return -ENOMEM;
 
-	if (!name) {
-		name = devm_kasprintf(dev, GFP_KERNEL,
-				      "%s-%c", pdev->name, pdev->id + 'A');
-		if (!name)
-			return -ENOMEM;
-	}
-
 	mutex_init(&chip->lock);
 
 	gc = &chip->gc;
@@ -523,6 +516,7 @@ static int __init gpio_mockup_init(void)
 	int i, prop, num_chips, err = 0, base;
 	struct platform_device_info pdevinfo;
 	struct platform_device *pdev;
+	char chip_label[32];
 	u16 ngpio;
 
 	if ((gpio_mockup_num_ranges < 2) ||
@@ -556,6 +550,11 @@ static int __init gpio_mockup_init(void)
 		memset(&pdevinfo, 0, sizeof(pdevinfo));
 		prop = 0;
 
+		snprintf(chip_label, sizeof(chip_label),
+			 "gpio-mockup-%c", i + 'A');
+		properties[prop++] = PROPERTY_ENTRY_STRING("chip-label",
+							   chip_label);
+
 		base = gpio_mockup_range_base(i);
 		if (base >= 0)
 			properties[prop++] = PROPERTY_ENTRY_U32("gpio-base",
Signature · 1 line
2.26.1
#23 lore raw

PATCH v2 8/9 gpio: mockup: use the generic 'gpio-line-names' property

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

GPIO line names are currently created by the driver from the chip label. We'll want to support custom formats for line names (for instance: to name all lines the same) for user-space tests so create them in the module init function and pass them to the driver using the standard 'gpio-line-names' property.

---
 drivers/gpio/gpio-mockup.c | 70 +++++++++++++++++++++-----------------
 1 file changed, 38 insertions(+), 32 deletions(-)
drivers/gpio/gpio-mockup.c +38 -32
index 5b2686f9e07d..47b7de6d5ab1 100644
@@ -19,6 +19,7 @@
 #include <linux/platform_device.h>
 #include <linux/property.h>
 #include <linux/slab.h>
+#include <linux/string_helpers.h>
 #include <linux/uaccess.h>
 
 #include "gpiolib.h"
@@ -374,29 +375,6 @@ static void gpio_mockup_debugfs_setup(struct device *dev,
 	}
 }
 
-static int gpio_mockup_name_lines(struct device *dev,
-				  struct gpio_mockup_chip *chip)
-{
-	struct gpio_chip *gc = &chip->gc;
-	char **names;
-	int i;
-
-	names = devm_kcalloc(dev, gc->ngpio, sizeof(char *), GFP_KERNEL);
-	if (!names)
-		return -ENOMEM;
-
-	for (i = 0; i < gc->ngpio; i++) {
-		names[i] = devm_kasprintf(dev, GFP_KERNEL,
-					  "%s-%d", gc->label, i);
-		if (!names[i])
-			return -ENOMEM;
-	}
-
-	gc->names = (const char *const *)names;
-
-	return 0;
-}
-
 static void gpio_mockup_dispose_mappings(void *data)
 {
 	struct gpio_mockup_chip *chip = data;
@@ -464,12 +442,6 @@ static int gpio_mockup_probe(struct platform_device *pdev)
 	for (i = 0; i < gc->ngpio; i++)
 		chip->lines[i].dir = GPIO_LINE_DIRECTION_IN;
 
-	if (device_property_read_bool(dev, "named-gpio-lines")) {
-		rv = gpio_mockup_name_lines(dev, chip);
-		if (rv)
-			return rv;
-	}
-
 	chip->irq_sim_domain = devm_irq_domain_create_sim(dev, NULL,
 							  gc->ngpio);
 	if (IS_ERR(chip->irq_sim_domain))
@@ -510,6 +482,27 @@ static void gpio_mockup_unregister_pdevs(void)
 	}
 }
 
+static __init char **gpio_mockup_make_line_names(const char *label,
+						 unsigned int num_lines)
+{
+	unsigned int i;
+	char **names;
+
+	names = kcalloc(num_lines + 1, sizeof(char *), GFP_KERNEL);
+	if (!names)
+		return NULL;
+
+	for (i = 0; i < num_lines; i++) {
+		names[i] = kasprintf(GFP_KERNEL, "%s-%u", label, i);
+		if (!names[i]) {
+			kfree_strarray(names, i);
+			return NULL;
+		}
+	}
+
+	return names;
+}
+
 static int __init gpio_mockup_init(void)
 {
 	struct property_entry properties[GPIO_MOCKUP_MAX_PROP];
@@ -517,6 +510,7 @@ static int __init gpio_mockup_init(void)
 	struct platform_device_info pdevinfo;
 	struct platform_device *pdev;
 	char chip_label[32];
+	char **line_names;
 	u16 ngpio;
 
 	if ((gpio_mockup_num_ranges < 2) ||
@@ -549,6 +543,7 @@ static int __init gpio_mockup_init(void)
 		memset(properties, 0, sizeof(properties));
 		memset(&pdevinfo, 0, sizeof(pdevinfo));
 		prop = 0;
+		line_names = NULL;
 
 		snprintf(chip_label, sizeof(chip_label),
 			 "gpio-mockup-%c", i + 'A');
@@ -564,15 +559,26 @@ static int __init gpio_mockup_init(void)
 				 : gpio_mockup_range_ngpio(i) - base;
 		properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios", ngpio);
 
-		if (gpio_mockup_named_lines)
-			properties[prop++] = PROPERTY_ENTRY_BOOL(
-						"named-gpio-lines");
+		if (gpio_mockup_named_lines) {
+			line_names = gpio_mockup_make_line_names(chip_label,
+								 ngpio);
+			if (!line_names) {
+				platform_driver_unregister(&gpio_mockup_driver);
+				gpio_mockup_unregister_pdevs();
+				return -ENOMEM;
+			}
+
+			properties[prop++] = PROPERTY_ENTRY_STRING_ARRAY_LEN(
+						"gpio-line-names",
+						line_names, ngpio);
+		}
 
 		pdevinfo.name = "gpio-mockup";
 		pdevinfo.id = i;
 		pdevinfo.properties = properties;
 
 		pdev = platform_device_register_full(&pdevinfo);
+		kfree_strarray(line_names, ngpio);
 		if (IS_ERR(pdev)) {
 			pr_err("error registering device");
 			platform_driver_unregister(&gpio_mockup_driver);
Signature · 1 line
2.26.1
#25 lore raw

PATCH v2 9/9 gpio: mockup: refactor the module init function

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Let's move the code preparing the device properties into a separate routine. This has the advantage of simplifying the error handling and makes the indentation less deep.

---
 drivers/gpio/gpio-mockup.c | 96 +++++++++++++++++++-------------------
 1 file changed, 49 insertions(+), 47 deletions(-)
drivers/gpio/gpio-mockup.c +49 -47
index 47b7de6d5ab1..02eea05a09dd 100644
@@ -503,16 +503,59 @@ static __init char **gpio_mockup_make_line_names(const char *label,
 	return names;
 }
 
-static int __init gpio_mockup_init(void)
+static int __init gpio_mockup_register_chip(int idx)
 {
 	struct property_entry properties[GPIO_MOCKUP_MAX_PROP];
-	int i, prop, num_chips, err = 0, base;
 	struct platform_device_info pdevinfo;
 	struct platform_device *pdev;
+	char **line_names = NULL;
 	char chip_label[32];
-	char **line_names;
+	int prop = 0, base;
 	u16 ngpio;
 
+	memset(properties, 0, sizeof(properties));
+	memset(&pdevinfo, 0, sizeof(pdevinfo));
+
+	snprintf(chip_label, sizeof(chip_label), "gpio-mockup-%c", idx + 'A');
+	properties[prop++] = PROPERTY_ENTRY_STRING("chip-label", chip_label);
+
+	base = gpio_mockup_range_base(idx);
+	if (base >= 0)
+		properties[prop++] = PROPERTY_ENTRY_U32("gpio-base", base);
+
+	ngpio = base < 0 ? gpio_mockup_range_ngpio(idx)
+			 : gpio_mockup_range_ngpio(idx) - base;
+	properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios", ngpio);
+
+	if (gpio_mockup_named_lines) {
+		line_names = gpio_mockup_make_line_names(chip_label, ngpio);
+		if (!line_names)
+			return -ENOMEM;
+
+		properties[prop++] = PROPERTY_ENTRY_STRING_ARRAY_LEN(
+					"gpio-line-names", line_names, ngpio);
+	}
+
+	pdevinfo.name = "gpio-mockup";
+	pdevinfo.id = idx;
+	pdevinfo.properties = properties;
+
+	pdev = platform_device_register_full(&pdevinfo);
+	kfree_strarray(line_names, ngpio);
+	if (IS_ERR(pdev)) {
+		pr_err("error registering device");
+		return PTR_ERR(pdev);
+	}
+
+	gpio_mockup_pdevs[idx] = pdev;
+
+	return 0;
+}
+
+static int __init gpio_mockup_init(void)
+{
+	int i, num_chips, err;
+
 	if ((gpio_mockup_num_ranges < 2) ||
 	    (gpio_mockup_num_ranges % 2) ||
 	    (gpio_mockup_num_ranges > GPIO_MOCKUP_MAX_RANGES))
@@ -540,54 +583,13 @@ static int __init gpio_mockup_init(void)
 	}
 
 	for (i = 0; i < num_chips; i++) {
-		memset(properties, 0, sizeof(properties));
-		memset(&pdevinfo, 0, sizeof(pdevinfo));
-		prop = 0;
-		line_names = NULL;
-
-		snprintf(chip_label, sizeof(chip_label),
-			 "gpio-mockup-%c", i + 'A');
-		properties[prop++] = PROPERTY_ENTRY_STRING("chip-label",
-							   chip_label);
-
-		base = gpio_mockup_range_base(i);
-		if (base >= 0)
-			properties[prop++] = PROPERTY_ENTRY_U32("gpio-base",
-								base);
-
-		ngpio = base < 0 ? gpio_mockup_range_ngpio(i)
-				 : gpio_mockup_range_ngpio(i) - base;
-		properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios", ngpio);
-
-		if (gpio_mockup_named_lines) {
-			line_names = gpio_mockup_make_line_names(chip_label,
-								 ngpio);
-			if (!line_names) {
-				platform_driver_unregister(&gpio_mockup_driver);
-				gpio_mockup_unregister_pdevs();
-				return -ENOMEM;
-			}
-
-			properties[prop++] = PROPERTY_ENTRY_STRING_ARRAY_LEN(
-						"gpio-line-names",
-						line_names, ngpio);
-		}
-
-		pdevinfo.name = "gpio-mockup";
-		pdevinfo.id = i;
-		pdevinfo.properties = properties;
-
-		pdev = platform_device_register_full(&pdevinfo);
-		kfree_strarray(line_names, ngpio);
-		if (IS_ERR(pdev)) {
-			pr_err("error registering device");
+		err = gpio_mockup_register_chip(i);
+		if (err) {
 			platform_driver_unregister(&gpio_mockup_driver);
 			gpio_mockup_unregister_pdevs();
 			debugfs_remove_recursive(gpio_mockup_dbg_dir);
-			return PTR_ERR(pdev);
+			return err;
 		}
-
-		gpio_mockup_pdevs[i] = pdev;
 	}
 
 	return 0;
Signature · 1 line
2.26.1
#15 lore raw

PATCH v2 5/9 gpio: mockup: use pr_fmt()

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

We don't need a custom logging helper. Let's use the standard pr_fmt() macro which allows us to use all pr_*() routines with custom format.

---
 drivers/gpio/gpio-mockup.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/gpio/gpio-mockup.c +4 -4
index 90a1d6c2775f..c2b2f7d5ff34 100644
@@ -7,6 +7,8 @@
  * Copyright (C) 2017 Bartosz Golaszewski <[email protected]>
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/debugfs.h>
 #include <linux/gpio/driver.h>
 #include <linux/interrupt.h>
@@ -30,8 +32,6 @@
 /* Maximum of three properties + the sentinel. */
 #define GPIO_MOCKUP_MAX_PROP	4
 
-#define gpio_mockup_err(...)	pr_err(KBUILD_MODNAME ": " __VA_ARGS__)
-
 /*
  * struct gpio_pin_status - structure describing a GPIO status
  * @dir:       Configures direction of gpio as "in" or "out"
@@ -548,7 +548,7 @@ static int __init gpio_mockup_init(void)
 
 	err = platform_driver_register(&gpio_mockup_driver);
 	if (err) {
-		gpio_mockup_err("error registering platform driver\n");
+		pr_err("error registering platform driver\n");
 		debugfs_remove_recursive(gpio_mockup_dbg_dir);
 		return err;
 	}
@@ -577,7 +577,7 @@ static int __init gpio_mockup_init(void)
 
 		pdev = platform_device_register_full(&pdevinfo);
 		if (IS_ERR(pdev)) {
-			gpio_mockup_err("error registering device");
+			pr_err("error registering device");
 			platform_driver_unregister(&gpio_mockup_driver);
 			gpio_mockup_unregister_pdevs();
 			debugfs_remove_recursive(gpio_mockup_dbg_dir);
Signature · 1 line
2.26.1
#13 lore raw

PATCH v2 3/9 gpio: mockup: drop unneeded includes

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

This module doesn't need gpio/consumer.h - it's a provider. It also doesn't use any symbols from init.h so let's remove both includes.

---
 drivers/gpio/gpio-mockup.c | 2 --
 1 file changed, 2 deletions(-)
drivers/gpio/gpio-mockup.c +0 -2
index 1652897fdf90..c5092773afd8 100644
@@ -8,9 +8,7 @@
  */
 
 #include <linux/debugfs.h>
-#include <linux/gpio/consumer.h>
 #include <linux/gpio/driver.h>
-#include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/irq_sim.h>
Signature · 1 line
2.26.1
Reviewed-by on v2 1/9
#2 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

In reply to Bartosz Golaszewski
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

But see below.

Quoted 29 lines
---
 include/linux/string_helpers.h |  2 ++
 lib/string_helpers.c           | 25 +++++++++++++++++++++++++
 2 files changed, 27 insertions(+)
include/linux/string_helpers.h +2 -0
index 86f150c2a6b6..55b25120a1c6 100644
@@ -94,4 +94,6 @@ char *kstrdup_quotable(const char *src, gfp_t gfp);
 char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp);
 char *kstrdup_quotable_file(struct file *file, gfp_t gfp);
 
+void kfree_strarray(char **str_array, size_t num_str);
+
 #endif
lib/string_helpers.c +4 -0
index 963050c0283e..bfa4c9f3ca0a 100644
@@ -649,3 +649,28 @@ char *kstrdup_quotable_file(struct file *file, gfp_t gfp)
 	return pathname;
 }
 EXPORT_SYMBOL_GPL(kstrdup_quotable_file);
+
+/**
+ * kfree_strarray - free a number of dynamically allocated strings contained
+ *                  in an array and the array itself

lib/string_helpers.c char *kstrdup_quotable_file(struct file *file, gfp_t gfp) · line 665

Quoted 10 lines
lib/string_helpers.c +10 -0
+ *
+ * @str_array: Dynamically allocated array of strings to free. If NULL - the
+ *             function does nothing.
+ * @num_str: Number of strings (starting from the beginning of the array) to
+ *           free.
+ *
+ * Passing a non-null str_array and num_str == 0 as well as NULL str_array
+ * are valid use-cases.
+ */
+void kfree_strarray(char **str_array, size_t num_str)

Hmm... I have missed your answer to
str_array -> array
num_str -> n

The rationale behind dropping str is to avoid duplicates in the name of the function and its parameters. 'array' is harder to avoid, but also possible, though I leave it to you.

Quoted 14 lines
lib/string_helpers.c +11 -0
+{
+	unsigned int i;
+
+	if (!str_array)
+		return;
+
+	for (i = 0; i < num_str; i++)
+		kfree(str_array[i]);
+	kfree(str_array);
+}
+EXPORT_SYMBOL_GPL(kfree_strarray);
Signature · 1 line
2.26.1
Signature · 2 lines
With Best Regards,
Andy Shevchenko
#18 lore raw

Re: [PATCH v2 7/9] gpio: mockup: pass the chip label as device property

In reply to Bartosz Golaszewski
Quoted 12 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

While we do check the "chip-name" property in probe(), we never actually use it. Let's pass the chip label to the driver using device properties as we'll want to allow users to define their own once dynamically created chips are supported.

The property is renamed to "chip-label" to not cause any confusion with the actual chip name which is of the form: "gpiochipX".

If the "chip-label" property is missing, let's do what most devices in drivers/gpio/ do and use dev_name().

...

drivers/gpio/gpio-mockup.c static int __init gpio_mockup_init(void) · line 556

Quoted 4 lines
drivers/gpio/gpio-mockup.c +4 -0
+		snprintf(chip_label, sizeof(chip_label),
+			 "gpio-mockup-%c", i + 'A');
+		properties[prop++] = PROPERTY_ENTRY_STRING("chip-label",
+							   chip_label);

You added new property, now count is up to 4. But at the same time

	#define GPIO_MOCKUP_MAX_PROP  4

how do you avoid overflow?

Signature · 2 lines
With Best Regards,
Andy Shevchenko
Reviewed-by on v2 8/9
#24 lore raw

Re: [PATCH v2 8/9] gpio: mockup: use the generic 'gpio-line-names' property

In reply to Bartosz Golaszewski
Quoted 7 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

GPIO line names are currently created by the driver from the chip label. We'll want to support custom formats for line names (for instance: to name all lines the same) for user-space tests so create them in the module init function and pass them to the driver using the standard 'gpio-line-names' property.

Quoted 137 lines
---
 drivers/gpio/gpio-mockup.c | 70 +++++++++++++++++++++-----------------
 1 file changed, 38 insertions(+), 32 deletions(-)
drivers/gpio/gpio-mockup.c +38 -32
index 5b2686f9e07d..47b7de6d5ab1 100644
@@ -19,6 +19,7 @@
 #include <linux/platform_device.h>
 #include <linux/property.h>
 #include <linux/slab.h>
+#include <linux/string_helpers.h>
 #include <linux/uaccess.h>
 
 #include "gpiolib.h"
@@ -374,29 +375,6 @@ static void gpio_mockup_debugfs_setup(struct device *dev,
 	}
 }
 
-static int gpio_mockup_name_lines(struct device *dev,
-				  struct gpio_mockup_chip *chip)
-{
-	struct gpio_chip *gc = &chip->gc;
-	char **names;
-	int i;
-
-	names = devm_kcalloc(dev, gc->ngpio, sizeof(char *), GFP_KERNEL);
-	if (!names)
-		return -ENOMEM;
-
-	for (i = 0; i < gc->ngpio; i++) {
-		names[i] = devm_kasprintf(dev, GFP_KERNEL,
-					  "%s-%d", gc->label, i);
-		if (!names[i])
-			return -ENOMEM;
-	}
-
-	gc->names = (const char *const *)names;
-
-	return 0;
-}
-
 static void gpio_mockup_dispose_mappings(void *data)
 {
 	struct gpio_mockup_chip *chip = data;
@@ -464,12 +442,6 @@ static int gpio_mockup_probe(struct platform_device *pdev)
 	for (i = 0; i < gc->ngpio; i++)
 		chip->lines[i].dir = GPIO_LINE_DIRECTION_IN;
 
-	if (device_property_read_bool(dev, "named-gpio-lines")) {
-		rv = gpio_mockup_name_lines(dev, chip);
-		if (rv)
-			return rv;
-	}
-
 	chip->irq_sim_domain = devm_irq_domain_create_sim(dev, NULL,
 							  gc->ngpio);
 	if (IS_ERR(chip->irq_sim_domain))
@@ -510,6 +482,27 @@ static void gpio_mockup_unregister_pdevs(void)
 	}
 }
 
+static __init char **gpio_mockup_make_line_names(const char *label,
+						 unsigned int num_lines)
+{
+	unsigned int i;
+	char **names;
+
+	names = kcalloc(num_lines + 1, sizeof(char *), GFP_KERNEL);
+	if (!names)
+		return NULL;
+
+	for (i = 0; i < num_lines; i++) {
+		names[i] = kasprintf(GFP_KERNEL, "%s-%u", label, i);
+		if (!names[i]) {
+			kfree_strarray(names, i);
+			return NULL;
+		}
+	}
+
+	return names;
+}
+
 static int __init gpio_mockup_init(void)
 {
 	struct property_entry properties[GPIO_MOCKUP_MAX_PROP];
@@ -517,6 +510,7 @@ static int __init gpio_mockup_init(void)
 	struct platform_device_info pdevinfo;
 	struct platform_device *pdev;
 	char chip_label[32];
+	char **line_names;
 	u16 ngpio;
 
 	if ((gpio_mockup_num_ranges < 2) ||
@@ -549,6 +543,7 @@ static int __init gpio_mockup_init(void)
 		memset(properties, 0, sizeof(properties));
 		memset(&pdevinfo, 0, sizeof(pdevinfo));
 		prop = 0;
+		line_names = NULL;
 
 		snprintf(chip_label, sizeof(chip_label),
 			 "gpio-mockup-%c", i + 'A');
@@ -564,15 +559,26 @@ static int __init gpio_mockup_init(void)
 				 : gpio_mockup_range_ngpio(i) - base;
 		properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios", ngpio);
 
-		if (gpio_mockup_named_lines)
-			properties[prop++] = PROPERTY_ENTRY_BOOL(
-						"named-gpio-lines");
+		if (gpio_mockup_named_lines) {
+			line_names = gpio_mockup_make_line_names(chip_label,
+								 ngpio);
+			if (!line_names) {
+				platform_driver_unregister(&gpio_mockup_driver);
+				gpio_mockup_unregister_pdevs();
+				return -ENOMEM;
+			}
+
+			properties[prop++] = PROPERTY_ENTRY_STRING_ARRAY_LEN(
+						"gpio-line-names",
+						line_names, ngpio);
+		}
 
 		pdevinfo.name = "gpio-mockup";
 		pdevinfo.id = i;
 		pdevinfo.properties = properties;
 
 		pdev = platform_device_register_full(&pdevinfo);
+		kfree_strarray(line_names, ngpio);
 		if (IS_ERR(pdev)) {
 			pr_err("error registering device");
 			platform_driver_unregister(&gpio_mockup_driver);
Signature · 1 line
2.26.1
Signature · 2 lines
With Best Regards,
Andy Shevchenko
#3 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

In reply to Andy Shevchenko
Quoted 55 lines · Andy Shevchenko
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

But see below.

Quoted 29 lines
---
 include/linux/string_helpers.h |  2 ++
 lib/string_helpers.c           | 25 +++++++++++++++++++++++++
 2 files changed, 27 insertions(+)
include/linux/string_helpers.h +2 -0
index 86f150c2a6b6..55b25120a1c6 100644
@@ -94,4 +94,6 @@ char *kstrdup_quotable(const char *src, gfp_t gfp);
 char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp);
 char *kstrdup_quotable_file(struct file *file, gfp_t gfp);
 
+void kfree_strarray(char **str_array, size_t num_str);
+
 #endif
lib/string_helpers.c +4 -0
index 963050c0283e..bfa4c9f3ca0a 100644
@@ -649,3 +649,28 @@ char *kstrdup_quotable_file(struct file *file, gfp_t gfp)
      return pathname;
 }
 EXPORT_SYMBOL_GPL(kstrdup_quotable_file);
+
+/**
+ * kfree_strarray - free a number of dynamically allocated strings contained
+ *                  in an array and the array itself

lib/string_helpers.c char *kstrdup_quotable_file(struct file *file, gfp_t gfp) · line 665

Quoted 10 lines
lib/string_helpers.c +10 -0
+ *
+ * @str_array: Dynamically allocated array of strings to free. If NULL - the
+ *             function does nothing.
+ * @num_str: Number of strings (starting from the beginning of the array) to
+ *           free.
+ *
+ * Passing a non-null str_array and num_str == 0 as well as NULL str_array
+ * are valid use-cases.
+ */
+void kfree_strarray(char **str_array, size_t num_str)

Hmm... I have missed your answer to
str_array -> array
num_str -> n

Quoted 4 lines

The rationale behind dropping str is to avoid duplicates in the name of the function and its parameters. 'array' is harder to avoid, but also possible, though I leave it to you.

Are you fine with me fixing this when applying the patches?

Bart

#19 lore raw

Re: [PATCH v2 7/9] gpio: mockup: pass the chip label as device property

In reply to Andy Shevchenko
Quoted 4 lines · Andy Shevchenko
Quoted 2 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Quoted 8 lines
Quoted 8 lines

While we do check the "chip-name" property in probe(), we never actually use it. Let's pass the chip label to the driver using device properties as we'll want to allow users to define their own once dynamically created chips are supported.

The property is renamed to "chip-label" to not cause any confusion with the actual chip name which is of the form: "gpiochipX".

^^^ here, see below

Quoted 10 lines
Quoted 2 lines

If the "chip-label" property is missing, let's do what most devices in drivers/gpio/ do and use dev_name().

...

drivers/gpio/gpio-mockup.c static int __init gpio_mockup_init(void) · line 556

Quoted 4 lines
drivers/gpio/gpio-mockup.c +4 -0
+             snprintf(chip_label, sizeof(chip_label),
+                      "gpio-mockup-%c", i + 'A');
+             properties[prop++] = PROPERTY_ENTRY_STRING("chip-label",
+                                                        chip_label);
Quoted 6 lines

You added new property, now count is up to 4. But at the same time

        #define GPIO_MOCKUP_MAX_PROP  4

how do you avoid overflow?

I renamed the property, the previous "chip-name" is no longer used. In fact it was never used but was accounted for in GPIO_MOCKUP_MAX_PROP.

Bart

#4 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

In reply to Bartosz Golaszewski
Quoted 57 lines · Bartosz Golaszewski
Quoted 55 lines · Andy Shevchenko
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

But see below.

Quoted 29 lines
---
 include/linux/string_helpers.h |  2 ++
 lib/string_helpers.c           | 25 +++++++++++++++++++++++++
 2 files changed, 27 insertions(+)
include/linux/string_helpers.h +2 -0
index 86f150c2a6b6..55b25120a1c6 100644
@@ -94,4 +94,6 @@ char *kstrdup_quotable(const char *src, gfp_t gfp);
 char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp);
 char *kstrdup_quotable_file(struct file *file, gfp_t gfp);
 
+void kfree_strarray(char **str_array, size_t num_str);
+
 #endif
lib/string_helpers.c +4 -0
index 963050c0283e..bfa4c9f3ca0a 100644
@@ -649,3 +649,28 @@ char *kstrdup_quotable_file(struct file *file, gfp_t gfp)
      return pathname;
 }
 EXPORT_SYMBOL_GPL(kstrdup_quotable_file);
+
+/**
+ * kfree_strarray - free a number of dynamically allocated strings contained
+ *                  in an array and the array itself

lib/string_helpers.c char *kstrdup_quotable_file(struct file *file, gfp_t gfp) · line 665

Quoted 10 lines
lib/string_helpers.c +10 -0
+ *
+ * @str_array: Dynamically allocated array of strings to free. If NULL - the
+ *             function does nothing.
+ * @num_str: Number of strings (starting from the beginning of the array) to
+ *           free.
+ *
+ * Passing a non-null str_array and num_str == 0 as well as NULL str_array
+ * are valid use-cases.
+ */
+void kfree_strarray(char **str_array, size_t num_str)

Hmm... I have missed your answer to
str_array -> array
num_str -> n

Quoted 6 lines
Quoted 4 lines

The rationale behind dropping str is to avoid duplicates in the name of the function and its parameters. 'array' is harder to avoid, but also possible, though I leave it to you.

Are you fine with me fixing this when applying the patches?

Sure!

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#20 lore raw

Re: [PATCH v2 7/9] gpio: mockup: pass the chip label as device property

In reply to Bartosz Golaszewski
Quoted 29 lines · Bartosz Golaszewski
Quoted 4 lines · Andy Shevchenko
Quoted 2 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Quoted 8 lines
Quoted 8 lines

While we do check the "chip-name" property in probe(), we never actually use it. Let's pass the chip label to the driver using device properties as we'll want to allow users to define their own once dynamically created chips are supported.

The property is renamed to "chip-label" to not cause any confusion with the actual chip name which is of the form: "gpiochipX".

^^^ here, see below

Quoted 12 lines
Quoted 2 lines

If the "chip-label" property is missing, let's do what most devices in drivers/gpio/ do and use dev_name().

...

drivers/gpio/gpio-mockup.c static int __init gpio_mockup_init(void) · line 556

Quoted 4 lines
drivers/gpio/gpio-mockup.c +4 -0
+             snprintf(chip_label, sizeof(chip_label),
+                      "gpio-mockup-%c", i + 'A');
+             properties[prop++] = PROPERTY_ENTRY_STRING("chip-label",
+                                                        chip_label);

You added new property, now count is up to 4. But at the same time

Quoted 7 lines
Quoted 4 lines
        #define GPIO_MOCKUP_MAX_PROP  4

how do you avoid overflow?

I renamed the property, the previous "chip-name" is no longer used. In fact it was never used but was accounted for in GPIO_MOCKUP_MAX_PROP.

Either I'm missing something or...

Current code in linux-next has 3 properties to be possible

PROPERTY_ENTRY_U32("gpio-base", base);
PROPERTY_ENTRY_U16("nr-gpios", ngpio);
PROPERTY_ENTRY_BOOL("named-gpio-lines");

You adding here
PROPERTY_ENTRY_STRING("chip-label", chip_label);

Altogether after this patch is 4 which is maximum, but since array is passed by a solely pointer, the terminator is a must.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#21 lore raw

Re: [PATCH v2 7/9] gpio: mockup: pass the chip label as device property

Quoted 47 lines · Andy Shevchenko
Quoted 29 lines · Bartosz Golaszewski
Quoted 4 lines · Andy Shevchenko
Quoted 2 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Quoted 8 lines
Quoted 8 lines

While we do check the "chip-name" property in probe(), we never actually use it. Let's pass the chip label to the driver using device properties as we'll want to allow users to define their own once dynamically created chips are supported.

The property is renamed to "chip-label" to not cause any confusion with the actual chip name which is of the form: "gpiochipX".

^^^ here, see below

Quoted 12 lines
Quoted 2 lines

If the "chip-label" property is missing, let's do what most devices in drivers/gpio/ do and use dev_name().

...

drivers/gpio/gpio-mockup.c static int __init gpio_mockup_init(void) · line 556

Quoted 4 lines
drivers/gpio/gpio-mockup.c +4 -0
+             snprintf(chip_label, sizeof(chip_label),
+                      "gpio-mockup-%c", i + 'A');
+             properties[prop++] = PROPERTY_ENTRY_STRING("chip-label",
+                                                        chip_label);

You added new property, now count is up to 4. But at the same time

Quoted 7 lines
Quoted 4 lines
        #define GPIO_MOCKUP_MAX_PROP  4

how do you avoid overflow?

I renamed the property, the previous "chip-name" is no longer used. In fact it was never used but was accounted for in GPIO_MOCKUP_MAX_PROP.

Either I'm missing something or...

Current code in linux-next has 3 properties to be possible

PROPERTY_ENTRY_U32("gpio-base", base);
PROPERTY_ENTRY_U16("nr-gpios", ngpio);
PROPERTY_ENTRY_BOOL("named-gpio-lines");

Quoted 6 lines

You adding here
PROPERTY_ENTRY_STRING("chip-label", chip_label);

Altogether after this patch is 4 which is maximum, but since array is passed by a solely pointer, the terminator is a must.

Thanks for explaining my code to me. Yes you're right and I'm not sure why I missed this. :)

I'll fix this in v3.

Actually this means the code is wrong even before this series - it's just that we don't use the "chip-name" property.

Bartosz

#5 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

In reply to Bartosz Golaszewski
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

Isn't this also common for things like ring buffers? Why limit this to char *[]?

#6 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

Quoted 11 lines · Joe Perches
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

Isn't this also common for things like ring buffers? Why limit this to char *[]?

I don't want to add APIs nobody is using. What do you suggest?

Bartosz

#7 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

Quoted 8 lines · Bartosz Golaszewski
Quoted 7 lines · Joe Perches
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

Quoted 5 lines
Quoted 3 lines

Isn't this also common for things like ring buffers? Why limit this to char *[]?

I don't want to add APIs nobody is using. What do you suggest?

Change the argument to void** and call it

void kfree_array(void **array, int count);

#22 lore raw

Re: [PATCH v2 7/9] gpio: mockup: pass the chip label as device property

In reply to Bartosz Golaszewski
Quoted 6 lines · Bartosz Golaszewski
Quoted 4 lines · Andy Shevchenko
Quoted 3 lines · Bartosz Golaszewski
Quoted 1 line · Andy Shevchenko

On Mon, Sep 28, 2020 at 12:41:53PM +0200, Bartosz Golaszewski wrote:

...

Quoted 20 lines
Quoted 13 lines
Quoted 4 lines
Quoted 1 line

how do you avoid overflow?

I renamed the property, the previous "chip-name" is no longer used. In fact it was never used but was accounted for in GPIO_MOCKUP_MAX_PROP.

Either I'm missing something or...

Current code in linux-next has 3 properties to be possible

PROPERTY_ENTRY_U32("gpio-base", base);
PROPERTY_ENTRY_U16("nr-gpios", ngpio);
PROPERTY_ENTRY_BOOL("named-gpio-lines");

Quoted 6 lines

You adding here
PROPERTY_ENTRY_STRING("chip-label", chip_label);

Altogether after this patch is 4 which is maximum, but since array is passed by a solely pointer, the terminator is a must.

Quoted 7 lines

Thanks for explaining my code to me. Yes you're right and I'm not sure why I missed this. :)

I'll fix this in v3.

Actually this means the code is wrong even before this series - it's just that we don't use the "chip-name" property.

Right, you patch just exposed it.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#8 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

In reply to Joe Perches
Quoted 13 lines · Joe Perches
Quoted 12 lines · Bartosz Golaszewski
Quoted 10 lines · Joe Perches
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

Isn't this also common for things like ring buffers? Why limit this to char *[]?

Quoted 5 lines
Quoted 1 line

I don't want to add APIs nobody is using. What do you suggest?

Change the argument to void** and call it

void kfree_array(void **array, int count);

Bart, if you go for this, I'm fine. You may keep my tag.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#9 lore raw

RE: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

In reply to Joe Perches

From: Joe Perches

Quoted 15 lines

Sent: 28 September 2020 17:07

Quoted 12 lines · Bartosz Golaszewski
Quoted 10 lines · Joe Perches
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

Isn't this also common for things like ring buffers? Why limit this to char *[]?

Quoted 5 lines
Quoted 1 line

I don't want to add APIs nobody is using. What do you suggest?

Change the argument to void** and call it

void kfree_array(void **array, int count);

Does help, void doesn't work that way.

David

-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)

#10 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

Quoted 16 lines · David Laight

From: Joe Perches

Quoted 15 lines

Sent: 28 September 2020 17:07

Quoted 12 lines · Bartosz Golaszewski
Quoted 10 lines · Joe Perches
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

Isn't this also common for things like ring buffers? Why limit this to char *[]?

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

I don't want to add APIs nobody is using. What do you suggest?

Change the argument to void** and call it

void kfree_array(void **array, int count);

Does help, void doesn't work that way.

Actually good catch. void * and void ** have a big difference in the implicit casting behaviour. I was stumbled over this while playing with some experimental stuff locally.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#11 lore raw

Re: [PATCH v2 1/9] lib: string_helpers: provide kfree_strarray()

Quoted 22 lines · Andy Shevchenko
Quoted 20 lines · David Laight

From: Joe Perches

Quoted 19 lines

Sent: 28 September 2020 17:07

Quoted 8 lines · Bartosz Golaszewski
Quoted 7 lines · Joe Perches
Quoted 5 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

There's a common pattern of dynamically allocating an array of char pointers and then also dynamically allocating each string in this array. Provide a helper for freeing such a string array with one call.

Quoted 5 lines
Quoted 3 lines

Isn't this also common for things like ring buffers? Why limit this to char *[]?

I don't want to add APIs nobody is using. What do you suggest?

Change the argument to void** and call it

Quoted 8 lines
Quoted 3 lines
Quoted 1 line

void kfree_array(void **array, int count);

Does help, void doesn't work that way.

Actually good catch. void * and void ** have a big difference in the implicit casting behaviour. I was stumbled over this while playing with some experimental stuff locally.

I'll keep kfree_strarray() then.

Bart