Skip to contentSkip to conversation

gpio: rework locking and object life-time control

PATCH Superseded Bartosz Golaszewski 2 participants 50 messages Feb 5, 2024 – Feb 6, 2024

Subsystems (2)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

v2 cover gpio: rework locking and object life-time control

From: Bartosz Golaszewski <[email protected]>

This is a big rework of locking in GPIOLIB. The current serialization is pretty much useless. There is one big spinlock (gpio_lock) that "protects" both the GPIO device list, GPIO descriptor access and who knows what else.

I'm putting "protects" in quotes as in several places the lock is taken, released whenever a sleeping function is called and re-taken without regards for the "protected" state that may have changed.

First a little background on what we're dealing with in GPIOLIB. We have consumer API functions that can be called from any context explicitly (get/set value, set direction) as well as many others which will get called in atomic context implicitly (e.g. set config called in certain situations from gpiod_direction_output()).

On the other side: we have GPIO provider drivers whose callbacks may or may not sleep depending on the underlying protocol.

This makes any attempts at serialization quite complex. We typically cannot use sleeping locks - we may be called from atomic - but we also often cannot use spinlocks - provider callbacks may sleep. Moreover: we have close ties with the interrupt and pinctrl subsystems, often either calling into them or getting called from them. They use their own locking schemes which are at odds with ours (pinctrl uses mutexes, the interrupt subsystem can call GPIO helpers with spinlock taken).

There is also another significant issue: the GPIO device object contains a pointer to gpio_chip which is the implementation of the GPIO provider. This object can be removed at any point - as GPIOLIB officially supports hotplugging with all the dynamic expanders that we provide drivers for - and leave the GPIO API callbacks with a suddenly NULL pointer. This is a problem that allowed user-space processes to easily crash the kernel until we patched it with a read-write semaphore in the user-space facing code (but the problem still exists for in-kernel users). This was recognized before as evidenced by the implementation of validate_desc() but without proper serialization, simple checking for a NULL pointer is pointless and we do need a generic solution for that issue as well.

If we want to get it right - the more lockless we go, the better. This is why SRCU seems to be the right candidate for the mechanism to use. In fact it's the only mechanism we can use our read-only critical sections to be called from atomic and protecc contexts as well as call driver callbacks that may sleep (for the latter case).

We're going to use it in three places: to protect the global list of GPIO devices, to ensure consistency when dereferencing the chip pointer in GPIO device struct and finally to ensure that users can access GPIO descriptors and always see a consistent state.

We do NOT serialize all API callbacks. This means that provider callbacks may be called simultaneously and GPIO drivers need to provide their own locking if needed. This is on purpose. First: we only support exclusive GPIO usage* so there's no risk of two drivers getting in each other's way over the same GPIO. Second: with this series, we ensure enough consistency to limit the chance of drivers or user-space users crashing the kernel. With additional improvements in handling the flags field in GPIO descriptors there's very little to gain, while bitbanging drivers may care about the increased performance of going lockless.

This series brings in one somewhat significant functional change for in-kernel users, namely: GPIO API calls, for which the underlying GPIO chip is gone, will no longer return 0 and emit a log message but instead will return -ENODEV.

I know this is a lot of code to go through but the more eyes we get on it the better.

Thanks,
Bartosz

* - This is not technically true. We do provide the GPIOD_FLAGS_BIT_NONEXCLUSIVE flag. However this is just another piece of technical debt. This is a hack provided for a single use-case in the regulator framework which got out of control and is now used in many places that should have never touched it. It's utterly broken and doesn't even provide any contract as to what a "shared GPIO" is. I would argue that it's the next thing we should address by providing "reference counted GPIO enable", not just a flag allowing to request the same GPIO twice and then allow two drivers to fight over who toggles it as is the case now. For now, let's just treat users of GPIOD_FLAGS_BIT_NONEXCLUSIVE like they're consciously and deliberately choosing to risk undefined behavior.

v1 -> v2:
- fix jumping over variable initialization in sysfs code
- fix RCU-related sparse warnings
- fix a smatch complaint about uninitialized variables (even though it's a false positive coming from the fact that scoped_guard() is implemented as a for loop
- fix a potential NULL-pointer dereference in debugfs callbacks
- improve commit messages

Bartosz Golaszewski (23):
gpio: protect the list of GPIO devices with SRCU
gpio: of: assign and read the hog pointer atomically
gpio: remove unused logging helpers
gpio: provide and use gpiod_get_label()
gpio: don't set label from irq helpers
gpio: add SRCU infrastructure to struct gpio_desc
gpio: protect the descriptor label with SRCU
gpio: sysfs: use gpio_device_find() to iterate over existing devices
gpio: remove gpio_lock
gpio: reinforce desc->flags handling
gpio: remove unneeded code from gpio_device_get_desc()
gpio: sysfs: extend the critical section for unregistering sysfs
devices
gpio: sysfs: pass the GPIO device - not chip - to sysfs callbacks
gpio: cdev: replace gpiochip_get_desc() with gpio_device_get_desc()
gpio: cdev: don't access gdev->chip if it's not needed
gpio: don't dereference gdev->chip in gpiochip_setup_dev()
gpio: reduce the functionality of validate_desc()
gpio: remove unnecessary checks from gpiod_to_chip()
gpio: add the can_sleep flag to struct gpio_device
gpio: add SRCU infrastructure to struct gpio_device
gpio: protect the pointer to gpio_chip in gpio_device with SRCU
gpio: remove the RW semaphore from the GPIO device
gpio: mark unsafe gpio_chip manipulators as deprecated

 drivers/gpio/gpiolib-cdev.c  |  92 +++--
 drivers/gpio/gpiolib-of.c    |   4 +-
 drivers/gpio/gpiolib-sysfs.c | 167 +++++---
 drivers/gpio/gpiolib.c       | 760 +++++++++++++++++++----------------
 drivers/gpio/gpiolib.h       |  86 ++--
 5 files changed, 630 insertions(+), 479 deletions(-)
Signature · 1 line
2.40.1
#1 lore raw

PATCH v2 1/23 gpio: protect the list of GPIO devices with SRCU

From: Bartosz Golaszewski <[email protected]>

We're working towards removing the "multi-function" GPIO spinlock that's implemented terribly wrong. We tried using an RW-semaphore to protect the list of GPIO devices but it turned out that we still have old code using legacy GPIO calls that need to translate the global GPIO number to the address of the associated descriptor and - to that end - traverse the list while holding the lock. If we change the spinlock to a sleeping lock then we'll end up with "scheduling while atomic" bugs.

Let's allow lockless traversal of the list using SRCU and only use the mutex when modyfing the list.

While at it: let's protect the period between when we start the lookup and when we finally request the descriptor (increasing the reference count of the GPIO device) with the SRCU read lock.

---
 drivers/gpio/gpiolib.c | 220 ++++++++++++++++++++++-------------------
 1 file changed, 116 insertions(+), 104 deletions(-)
drivers/gpio/gpiolib.c +116 -104
index d50a786f8176..a14eef93ead8 100644
@@ -2,6 +2,7 @@
 
 #include <linux/acpi.h>
 #include <linux/bitmap.h>
+#include <linux/cleanup.h>
 #include <linux/compat.h>
 #include <linux/debugfs.h>
 #include <linux/device.h>
@@ -14,12 +15,14 @@
 #include <linux/irq.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
+#include <linux/lockdep.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/pinctrl/consumer.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
+#include <linux/srcu.h>
 #include <linux/string.h>
 
 #include <linux/gpio.h>
@@ -81,7 +84,12 @@ DEFINE_SPINLOCK(gpio_lock);
 
 static DEFINE_MUTEX(gpio_lookup_lock);
 static LIST_HEAD(gpio_lookup_list);
+
 LIST_HEAD(gpio_devices);
+/* Protects the GPIO device list against concurrent modifications. */
+static DEFINE_MUTEX(gpio_devices_lock);
+/* Ensures coherence during read-only accesses to the list of GPIO devices. */
+DEFINE_STATIC_SRCU(gpio_devices_srcu);
 
 static DEFINE_MUTEX(gpio_machine_hogs_mutex);
 static LIST_HEAD(gpio_machine_hogs);
@@ -113,20 +121,16 @@ static inline void desc_set_label(struct gpio_desc *d, const char *label)
 struct gpio_desc *gpio_to_desc(unsigned gpio)
 {
 	struct gpio_device *gdev;
-	unsigned long flags;
 
-	spin_lock_irqsave(&gpio_lock, flags);
-
-	list_for_each_entry(gdev, &gpio_devices, list) {
-		if (gdev->base <= gpio &&
-		    gdev->base + gdev->ngpio > gpio) {
-			spin_unlock_irqrestore(&gpio_lock, flags);
-			return &gdev->descs[gpio - gdev->base];
+	scoped_guard(srcu, &gpio_devices_srcu) {
+		list_for_each_entry_srcu(gdev, &gpio_devices, list,
+				srcu_read_lock_held(&gpio_devices_srcu)) {
+			if (gdev->base <= gpio &&
+			    gdev->base + gdev->ngpio > gpio)
+				return &gdev->descs[gpio - gdev->base];
 		}
 	}
 
-	spin_unlock_irqrestore(&gpio_lock, flags);
-
 	if (!gpio_is_valid(gpio))
 		pr_warn("invalid GPIO %d\n", gpio);
 
@@ -282,7 +286,8 @@ static int gpiochip_find_base_unlocked(int ngpio)
 	struct gpio_device *gdev;
 	int base = GPIO_DYNAMIC_BASE;
 
-	list_for_each_entry(gdev, &gpio_devices, list) {
+	list_for_each_entry_srcu(gdev, &gpio_devices, list,
+				 lockdep_is_held(&gpio_devices_lock)) {
 		/* found a free space? */
 		if (gdev->base >= base + ngpio)
 			break;
@@ -354,23 +359,25 @@ static int gpiodev_add_to_list_unlocked(struct gpio_device *gdev)
 {
 	struct gpio_device *prev, *next;
 
+	lockdep_assert_held(&gpio_devices_lock);
+
 	if (list_empty(&gpio_devices)) {
 		/* initial entry in list */
-		list_add_tail(&gdev->list, &gpio_devices);
+		list_add_tail_rcu(&gdev->list, &gpio_devices);
 		return 0;
 	}
 
 	next = list_first_entry(&gpio_devices, struct gpio_device, list);
 	if (gdev->base + gdev->ngpio <= next->base) {
 		/* add before first entry */
-		list_add(&gdev->list, &gpio_devices);
+		list_add_rcu(&gdev->list, &gpio_devices);
 		return 0;
 	}
 
 	prev = list_last_entry(&gpio_devices, struct gpio_device, list);
 	if (prev->base + prev->ngpio <= gdev->base) {
 		/* add behind last entry */
-		list_add_tail(&gdev->list, &gpio_devices);
+		list_add_tail_rcu(&gdev->list, &gpio_devices);
 		return 0;
 	}
 
@@ -382,11 +389,13 @@ static int gpiodev_add_to_list_unlocked(struct gpio_device *gdev)
 		/* add between prev and next */
 		if (prev->base + prev->ngpio <= gdev->base
 				&& gdev->base + gdev->ngpio <= next->base) {
-			list_add(&gdev->list, &prev->list);
+			list_add_rcu(&gdev->list, &prev->list);
 			return 0;
 		}
 	}
 
+	synchronize_srcu(&gpio_devices_srcu);
+
 	return -EBUSY;
 }
 
@@ -399,26 +408,21 @@ static int gpiodev_add_to_list_unlocked(struct gpio_device *gdev)
 static struct gpio_desc *gpio_name_to_desc(const char * const name)
 {
 	struct gpio_device *gdev;
-	unsigned long flags;
+	struct gpio_desc *desc;
 
 	if (!name)
 		return NULL;
 
-	spin_lock_irqsave(&gpio_lock, flags);
-
-	list_for_each_entry(gdev, &gpio_devices, list) {
-		struct gpio_desc *desc;
+	guard(srcu)(&gpio_devices_srcu);
 
+	list_for_each_entry_srcu(gdev, &gpio_devices, list,
+				 srcu_read_lock_held(&gpio_devices_srcu)) {
 		for_each_gpio_desc(gdev->chip, desc) {
-			if (desc->name && !strcmp(desc->name, name)) {
-				spin_unlock_irqrestore(&gpio_lock, flags);
+			if (desc->name && !strcmp(desc->name, name))
 				return desc;
-			}
 		}
 	}
 
-	spin_unlock_irqrestore(&gpio_lock, flags);
-
 	return NULL;
 }
 
@@ -748,7 +752,10 @@ static void gpiochip_setup_devs(void)
 	struct gpio_device *gdev;
 	int ret;
 
-	list_for_each_entry(gdev, &gpio_devices, list) {
+	guard(srcu)(&gpio_devices_srcu);
+
+	list_for_each_entry_srcu(gdev, &gpio_devices, list,
+				 srcu_read_lock_held(&gpio_devices_srcu)) {
 		ret = gpiochip_setup_dev(gdev);
 		if (ret)
 			dev_err(&gdev->dev,
@@ -813,7 +820,6 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 			       struct lock_class_key *request_key)
 {
 	struct gpio_device *gdev;
-	unsigned long flags;
 	unsigned int i;
 	int base = 0;
 	int ret = 0;
@@ -878,49 +884,47 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 
 	gdev->ngpio = gc->ngpio;
 
-	spin_lock_irqsave(&gpio_lock, flags);
-
-	/*
-	 * TODO: this allocates a Linux GPIO number base in the global
-	 * GPIO numberspace for this chip. In the long run we want to
-	 * get *rid* of this numberspace and use only descriptors, but
-	 * it may be a pipe dream. It will not happen before we get rid
-	 * of the sysfs interface anyways.
-	 */
-	base = gc->base;
-	if (base < 0) {
-		base = gpiochip_find_base_unlocked(gc->ngpio);
+	scoped_guard(mutex, &gpio_devices_lock) {
+		/*
+		 * TODO: this allocates a Linux GPIO number base in the global
+		 * GPIO numberspace for this chip. In the long run we want to
+		 * get *rid* of this numberspace and use only descriptors, but
+		 * it may be a pipe dream. It will not happen before we get rid
+		 * of the sysfs interface anyways.
+		 */
+		base = gc->base;
 		if (base < 0) {
-			spin_unlock_irqrestore(&gpio_lock, flags);
-			ret = base;
-			base = 0;
+			base = gpiochip_find_base_unlocked(gc->ngpio);
+			if (base < 0) {
+				ret = base;
+				base = 0;
+				goto err_free_label;
+			}
+
+			/*
+			 * TODO: it should not be necessary to reflect the
+			 * assigned base outside of the GPIO subsystem. Go over
+			 * drivers and see if anyone makes use of this, else
+			 * drop this and assign a poison instead.
+			 */
+			gc->base = base;
+		} else {
+			dev_warn(&gdev->dev,
+				 "Static allocation of GPIO base is deprecated, use dynamic allocation.\n");
+		}
+
+		gdev->base = base;
+
+		ret = gpiodev_add_to_list_unlocked(gdev);
+		if (ret) {
+			chip_err(gc, "GPIO integer space overlap, cannot add chip\n");
 			goto err_free_label;
 		}
-		/*
-		 * TODO: it should not be necessary to reflect the assigned
-		 * base outside of the GPIO subsystem. Go over drivers and
-		 * see if anyone makes use of this, else drop this and assign
-		 * a poison instead.
-		 */
-		gc->base = base;
-	} else {
-		dev_warn(&gdev->dev,
-			 "Static allocation of GPIO base is deprecated, use dynamic allocation.\n");
-	}
-	gdev->base = base;
-
-	ret = gpiodev_add_to_list_unlocked(gdev);
-	if (ret) {
-		spin_unlock_irqrestore(&gpio_lock, flags);
-		chip_err(gc, "GPIO integer space overlap, cannot add chip\n");
-		goto err_free_label;
 	}
 
 	for (i = 0; i < gc->ngpio; i++)
 		gdev->descs[i].gdev = gdev;
 
-	spin_unlock_irqrestore(&gpio_lock, flags);
-
 	BLOCKING_INIT_NOTIFIER_HEAD(&gdev->line_state_notifier);
 	BLOCKING_INIT_NOTIFIER_HEAD(&gdev->device_notifier);
 	init_rwsem(&gdev->sem);
@@ -1011,9 +1015,9 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 		goto err_print_message;
 	}
 err_remove_from_list:
-	spin_lock_irqsave(&gpio_lock, flags);
-	list_del(&gdev->list);
-	spin_unlock_irqrestore(&gpio_lock, flags);
+	scoped_guard(mutex, &gpio_devices_lock)
+		list_del_rcu(&gdev->list);
+	synchronize_srcu(&gpio_devices_srcu);
 err_free_label:
 	kfree_const(gdev->label);
 err_free_descs:
@@ -1076,8 +1080,9 @@ void gpiochip_remove(struct gpio_chip *gc)
 		dev_crit(&gdev->dev,
 			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
 
-	scoped_guard(spinlock_irqsave, &gpio_lock)
-		list_del(&gdev->list);
+	scoped_guard(mutex, &gpio_devices_lock)
+		list_del_rcu(&gdev->list);
+	synchronize_srcu(&gpio_devices_srcu);
 
 	/*
 	 * The gpiochip side puts its use of the device to rest here:
@@ -1125,7 +1130,7 @@ struct gpio_device *gpio_device_find(void *data,
 	 */
 	might_sleep();
 
-	guard(spinlock_irqsave)(&gpio_lock);
+	guard(srcu)(&gpio_devices_srcu);
 
 	list_for_each_entry(gdev, &gpio_devices, list) {
 		if (gdev->chip && match(gdev->chip, data))
@@ -4133,30 +4138,39 @@ static struct gpio_desc *gpiod_find_and_request(struct device *consumer,
 						bool platform_lookup_allowed)
 {
 	unsigned long lookupflags = GPIO_LOOKUP_FLAGS_DEFAULT;
-	struct gpio_desc *desc;
-	int ret;
-
-	desc = gpiod_find_by_fwnode(fwnode, consumer, con_id, idx, &flags, &lookupflags);
-	if (gpiod_not_found(desc) && platform_lookup_allowed) {
-		/*
-		 * Either we are not using DT or ACPI, or their lookup did not
-		 * return a result. In that case, use platform lookup as a
-		 * fallback.
-		 */
-		dev_dbg(consumer, "using lookup tables for GPIO lookup\n");
-		desc = gpiod_find(consumer, con_id, idx, &lookupflags);
-	}
-
-	if (IS_ERR(desc)) {
-		dev_dbg(consumer, "No GPIO consumer %s found\n", con_id);
-		return desc;
-	}
-
 	/*
-	 * If a connection label was passed use that, else attempt to use
-	 * the device name as label
+	 * scoped_guard() is implemented as a for loop, meaning static
+	 * analyzers will complain about these two not being initialized.
 	 */
-	ret = gpiod_request(desc, label);
+	struct gpio_desc *desc = NULL;
+	int ret = 0;
+
+	scoped_guard(srcu, &gpio_devices_srcu) {
+		desc = gpiod_find_by_fwnode(fwnode, consumer, con_id, idx,
+					    &flags, &lookupflags);
+		if (gpiod_not_found(desc) && platform_lookup_allowed) {
+			/*
+			 * Either we are not using DT or ACPI, or their lookup
+			 * did not return a result. In that case, use platform
+			 * lookup as a fallback.
+			 */
+			dev_dbg(consumer,
+				"using lookup tables for GPIO lookup\n");
+			desc = gpiod_find(consumer, con_id, idx, &lookupflags);
+		}
+
+		if (IS_ERR(desc)) {
+			dev_dbg(consumer, "No GPIO consumer %s found\n",
+				con_id);
+			return desc;
+		}
+
+		/*
+		 * If a connection label was passed use that, else attempt to use
+		 * the device name as label
+		 */
+		ret = gpiod_request(desc, label);
+	}
 	if (ret) {
 		if (!(ret == -EBUSY && flags & GPIOD_FLAGS_BIT_NONEXCLUSIVE))
 			return ERR_PTR(ret);
@@ -4727,35 +4741,33 @@ static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
 
 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
 {
-	unsigned long flags;
 	struct gpio_device *gdev = NULL;
 	loff_t index = *pos;
 
 	s->private = "";
 
-	spin_lock_irqsave(&gpio_lock, flags);
-	list_for_each_entry(gdev, &gpio_devices, list)
-		if (index-- == 0) {
-			spin_unlock_irqrestore(&gpio_lock, flags);
+	guard(srcu)(&gpio_devices_srcu);
+
+	list_for_each_entry(gdev, &gpio_devices, list) {
+		if (index-- == 0)
 			return gdev;
-		}
-	spin_unlock_irqrestore(&gpio_lock, flags);
+	}
 
 	return NULL;
 }
 
 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
 {
-	unsigned long flags;
 	struct gpio_device *gdev = v;
 	void *ret = NULL;
 
-	spin_lock_irqsave(&gpio_lock, flags);
-	if (list_is_last(&gdev->list, &gpio_devices))
-		ret = NULL;
-	else
-		ret = list_first_entry(&gdev->list, struct gpio_device, list);
-	spin_unlock_irqrestore(&gpio_lock, flags);
+	scoped_guard(srcu, &gpio_devices_srcu) {
+		if (list_is_last(&gdev->list, &gpio_devices))
+			ret = NULL;
+		else
+			ret = list_first_entry(&gdev->list, struct gpio_device,
+					       list);
+	}
 
 	s->private = "\n";
 	++*pos;
Signature · 1 line
2.40.1
#2 lore raw

PATCH v2 2/23 gpio: of: assign and read the hog pointer atomically

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

The device nodes representing GPIO hogs cannot be deleted without unregistering the GPIO chip so there's no need to serialize their access. However we must ensure that users can get the right address so write and read it atomically.

---
 drivers/gpio/gpiolib-of.c | 4 ++--
 drivers/gpio/gpiolib.c    | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
drivers/gpio/gpiolib-of.c +2 -2
index 77509aa19900..bd6b8702c790 100644
@@ -800,7 +800,7 @@ static int of_gpiochip_add_hog(struct gpio_chip *chip, struct device_node *hog)
 			return ret;
 
 #ifdef CONFIG_OF_DYNAMIC
-		desc->hog = hog;
+		WRITE_ONCE(desc->hog, hog);
 #endif
 	}
 
@@ -848,7 +848,7 @@ static void of_gpiochip_remove_hog(struct gpio_chip *chip,
 	struct gpio_desc *desc;
 
 	for_each_gpio_desc_with_flag(chip, desc, FLAG_IS_HOGGED)
-		if (desc->hog == hog)
+		if (READ_ONCE(desc->hog) == hog)
 			gpiochip_free_own_desc(desc);
 }
 
drivers/gpio/gpiolib.c +1 -1
index a14eef93ead8..4c18b693d06c 100644
@@ -2324,7 +2324,7 @@ static bool gpiod_free_commit(struct gpio_desc *desc)
 		clear_bit(FLAG_EDGE_FALLING, &desc->flags);
 		clear_bit(FLAG_IS_HOGGED, &desc->flags);
 #ifdef CONFIG_OF_DYNAMIC
-		desc->hog = NULL;
+		WRITE_ONCE(desc->hog, NULL);
 #endif
 		ret = true;
 	}
Signature · 1 line
2.40.1
#3 lore raw

PATCH v2 3/23 gpio: remove unused logging helpers

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

The general rule of the kernel is to not provide symbols that have no users upstream. Let's remove logging helpers that are not used anywhere.

This will save us work later when we'll be modifying them to use the upcoming SRCU infrastructure.

---
 drivers/gpio/gpiolib.h | 13 -------------
 1 file changed, 13 deletions(-)
drivers/gpio/gpiolib.h +0 -13
index a4a2520b5f31..c3ae5bfa3f2e 100644
@@ -219,31 +219,18 @@ static inline int gpio_chip_hwgpio(const struct gpio_desc *desc)
 
 /* With descriptor prefix */
 
-#define gpiod_emerg(desc, fmt, ...)					       \
-	pr_emerg("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
-		 ##__VA_ARGS__)
-#define gpiod_crit(desc, fmt, ...)					       \
-	pr_crit("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
-		 ##__VA_ARGS__)
 #define gpiod_err(desc, fmt, ...)					       \
 	pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",  \
 		 ##__VA_ARGS__)
 #define gpiod_warn(desc, fmt, ...)					       \
 	pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
 		 ##__VA_ARGS__)
-#define gpiod_info(desc, fmt, ...)					       \
-	pr_info("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
-		 ##__VA_ARGS__)
 #define gpiod_dbg(desc, fmt, ...)					       \
 	pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
 		 ##__VA_ARGS__)
 
 /* With chip prefix */
 
-#define chip_emerg(gc, fmt, ...)					\
-	dev_emerg(&gc->gpiodev->dev, "(%s): " fmt, gc->label, ##__VA_ARGS__)
-#define chip_crit(gc, fmt, ...)					\
-	dev_crit(&gc->gpiodev->dev, "(%s): " fmt, gc->label, ##__VA_ARGS__)
 #define chip_err(gc, fmt, ...)					\
 	dev_err(&gc->gpiodev->dev, "(%s): " fmt, gc->label, ##__VA_ARGS__)
 #define chip_warn(gc, fmt, ...)					\
Signature · 1 line
2.40.1
#4 lore raw

PATCH v2 4/23 gpio: provide and use gpiod_get_label()

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

We will soon serialize access to the descriptor label using SRCU. The write-side of the protection will require calling synchronize_srcu() which must not be called from atomic context. We have two irq helpers:
gpiochip_lock_as_irq() and gpiochip_unlock_as_irq() that set the label if the GPIO is not requested but is being used as interrupt. They are called with a spinlock held from the interrupt subsystem.

They must not do it if we are to use SRCU so instead let's move the special corner case to a dedicated getter.

First: let's implement and use the getter where it's applicable.

---
 drivers/gpio/gpiolib-cdev.c | 4 ++--
 drivers/gpio/gpiolib.c      | 9 +++++++--
 drivers/gpio/gpiolib.h      | 1 +
 3 files changed, 10 insertions(+), 4 deletions(-)
drivers/gpio/gpiolib-cdev.c +2 -2
index 34d6712fa07c..2c0a0700762d 100644
@@ -2305,8 +2305,8 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
 		if (desc->name)
 			strscpy(info->name, desc->name, sizeof(info->name));
 
-		if (desc->label)
-			strscpy(info->consumer, desc->label,
+		if (gpiod_get_label(desc))
+			strscpy(info->consumer, gpiod_get_label(desc),
 				sizeof(info->consumer));
 
 		dflags = READ_ONCE(desc->flags);
drivers/gpio/gpiolib.c +7 -2
index 4c18b693d06c..cfd311ec5dda 100644
@@ -105,6 +105,11 @@ static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gc);
 
 static bool gpiolib_initialized;
 
+const char *gpiod_get_label(struct gpio_desc *desc)
+{
+	return desc->label;
+}
+
 static inline void desc_set_label(struct gpio_desc *d, const char *label)
 {
 	d->label = label;
@@ -2385,7 +2390,7 @@ char *gpiochip_dup_line_label(struct gpio_chip *gc, unsigned int offset)
 	 *
 	 * Until this happens, this allocation needs to be atomic.
 	 */
-	label = kstrdup(desc->label, GFP_ATOMIC);
+	label = kstrdup(gpiod_get_label(desc), GFP_ATOMIC);
 	if (!label)
 		return ERR_PTR(-ENOMEM);
 
@@ -4726,7 +4731,7 @@ static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
 			is_irq = test_bit(FLAG_USED_AS_IRQ, &desc->flags);
 			active_low = test_bit(FLAG_ACTIVE_LOW, &desc->flags);
 			seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s%s\n",
-				   gpio, desc->name ?: "", desc->label,
+				   gpio, desc->name ?: "", gpiod_get_label(desc),
 				   is_out ? "out" : "in ",
 				   value >= 0 ? (value ? "hi" : "lo") : "?  ",
 				   is_irq ? "IRQ " : "",
drivers/gpio/gpiolib.h +1 -0
index c3ae5bfa3f2e..1058f326fe2b 100644
@@ -208,6 +208,7 @@ int gpio_set_debounce_timeout(struct gpio_desc *desc, unsigned int debounce);
 int gpiod_hog(struct gpio_desc *desc, const char *name,
 		unsigned long lflags, enum gpiod_flags dflags);
 int gpiochip_get_ngpios(struct gpio_chip *gc, struct device *dev);
+const char *gpiod_get_label(struct gpio_desc *desc);
 
 /*
  * Return the GPIO number of the passed descriptor relative to its chip
Signature · 1 line
2.40.1
#5 lore raw

PATCH v2 5/23 gpio: don't set label from irq helpers

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

We will soon serialize access to the descriptor label using SRCU. The write-side of the protection will require calling synchronize_srcu() which must not be called from atomic context. We have two irq helpers:
gpiochip_lock_as_irq() and gpiochip_unlock_as_irq() that set the label if the GPIO is not requested but is being used as interrupt. They are called with a spinlock held from the interrupt subsystem.

They must not do it if we are to use SRCU so instead let's move the special corner case to a dedicated getter.

Don't actually set the label to "interrupt" in the above case but rather use the newly added gpiod_get_label() helper to hide the logic that atomically checks the descriptor flags and returns the address of a static "interrupt" string.

---
 drivers/gpio/gpiolib.c | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)
drivers/gpio/gpiolib.c +8 -13
index cfd311ec5dda..5c041d57077b 100644
@@ -107,7 +107,14 @@ static bool gpiolib_initialized;
 
 const char *gpiod_get_label(struct gpio_desc *desc)
 {
-	return desc->label;
+	unsigned long flags;
+
+	flags = READ_ONCE(desc->flags);
+	if (test_bit(FLAG_USED_AS_IRQ, &flags) &&
+	    !test_bit(FLAG_REQUESTED, &flags))
+		return "interrupt";
+
+	return test_bit(FLAG_REQUESTED, &flags) ? desc->label : NULL;
 }
 
 static inline void desc_set_label(struct gpio_desc *d, const char *label)
@@ -3593,14 +3600,6 @@ int gpiochip_lock_as_irq(struct gpio_chip *gc, unsigned int offset)
 	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
 	set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
 
-	/*
-	 * If the consumer has not set up a label (such as when the
-	 * IRQ is referenced from .to_irq()) we set up a label here
-	 * so it is clear this is used as an interrupt.
-	 */
-	if (!desc->label)
-		desc_set_label(desc, "interrupt");
-
 	return 0;
 }
 EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
@@ -3623,10 +3622,6 @@ void gpiochip_unlock_as_irq(struct gpio_chip *gc, unsigned int offset)
 
 	clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
 	clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
-
-	/* If we only had this marking, erase it */
-	if (desc->label && !strcmp(desc->label, "interrupt"))
-		desc_set_label(desc, NULL);
 }
 EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
 
Signature · 1 line
2.40.1
#6 lore raw

PATCH v2 6/23 gpio: add SRCU infrastructure to struct gpio_desc

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Extend the GPIO descriptor with an SRCU structure in order to serialize the access to the label. Initialize and clean it up where applicable.

---
 drivers/gpio/gpiolib.c | 18 ++++++++++++++++--
 drivers/gpio/gpiolib.h |  3 +++
 2 files changed, 19 insertions(+), 2 deletions(-)
drivers/gpio/gpiolib.c +16 -2
index 5c041d57077b..ea0c0158faaf 100644
@@ -672,6 +672,10 @@ EXPORT_SYMBOL_GPL(gpiochip_line_is_valid);
 static void gpiodev_release(struct device *dev)
 {
 	struct gpio_device *gdev = to_gpio_device(dev);
+	unsigned int i;
+
+	for (i = 0; i < gdev->ngpio; i++)
+		cleanup_srcu_struct(&gdev->descs[i].srcu);
 
 	ida_free(&gpio_ida, gdev->id);
 	kfree_const(gdev->label);
@@ -832,7 +836,7 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 			       struct lock_class_key *request_key)
 {
 	struct gpio_device *gdev;
-	unsigned int i;
+	unsigned int i, j;
 	int base = 0;
 	int ret = 0;
 
@@ -965,6 +969,13 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 	for (i = 0; i < gc->ngpio; i++) {
 		struct gpio_desc *desc = &gdev->descs[i];
 
+		ret = init_srcu_struct(&desc->srcu);
+		if (ret) {
+			for (j = 0; j < i; j++)
+				cleanup_srcu_struct(&desc->srcu);
+			goto err_remove_of_chip;
+		}
+
 		if (gc->get_direction && gpiochip_line_is_valid(gc, i)) {
 			assign_bit(FLAG_IS_OUT,
 				   &desc->flags, !gc->get_direction(gc, i));
@@ -976,7 +987,7 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 
 	ret = gpiochip_add_pin_ranges(gc);
 	if (ret)
-		goto err_remove_of_chip;
+		goto err_cleanup_desc_srcu;
 
 	acpi_gpiochip_add(gc);
 
@@ -1015,6 +1026,9 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 	gpiochip_irqchip_free_valid_mask(gc);
 err_remove_acpi_chip:
 	acpi_gpiochip_remove(gc);
+err_cleanup_desc_srcu:
+	for (i = 0; i < gdev->ngpio; i++)
+		cleanup_srcu_struct(&gdev->descs[i].srcu);
 err_remove_of_chip:
 	gpiochip_free_hogs(gc);
 	of_gpiochip_remove(gc);
drivers/gpio/gpiolib.h +3 -0
index 1058f326fe2b..6e14b629c48b 100644
@@ -17,6 +17,7 @@
 #include <linux/module.h>
 #include <linux/notifier.h>
 #include <linux/rwsem.h>
+#include <linux/srcu.h>
 
 #define GPIOCHIP_NAME	"gpiochip"
 
@@ -147,6 +148,7 @@ void gpiod_line_state_notify(struct gpio_desc *desc, unsigned long action);
  * @label:		Name of the consumer
  * @name:		Line name
  * @hog:		Pointer to the device node that hogs this line (if any)
+ * @srcu:		SRCU struct protecting the label pointer.
  *
  * These are obtained using gpiod_get() and are preferable to the old
  * integer-based handles.
@@ -184,6 +186,7 @@ struct gpio_desc {
 #ifdef CONFIG_OF_DYNAMIC
 	struct device_node	*hog;
 #endif
+	struct srcu_struct	srcu;
 };
 
 #define gpiod_not_found(desc)		(IS_ERR(desc) && PTR_ERR(desc) == -ENOENT)
Signature · 1 line
2.40.1
#7 lore raw

Re: [PATCH v2 06/23] gpio: add SRCU infrastructure to struct gpio_desc

Quoted 4 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Extend the GPIO descriptor with an SRCU structure in order to serialize the access to the label. Initialize and clean it up where applicable.

...

Review

Quoted 2 lines
(quoted diff) +2 -0
+	for (i = 0; i < gdev->ngpio; i++)
+		cleanup_srcu_struct(&gdev->descs[i].srcu);

for_each_gpio_desc()?

(It might be that the latter should be reworked a bit first, dunno)

...

drivers/gpio/gpiolib.c int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, · line 975

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+			for (j = 0; j < i; j++)
+				cleanup_srcu_struct(&desc->srcu);

What does this loop mean?

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+			goto err_remove_of_chip;
+		}

...

drivers/gpio/gpiolib.c int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, · line 1031

Quoted 3 lines
drivers/gpio/gpiolib.c +3 -0
+err_cleanup_desc_srcu:
+	for (i = 0; i < gdev->ngpio; i++)
+		cleanup_srcu_struct(&gdev->descs[i].srcu);

As per above (use existing for_each macro),

...

drivers/gpio/gpiolib.h struct gpio_desc { · line 190

Quoted 2 lines
drivers/gpio/gpiolib.h +1 -0
+	struct srcu_struct	srcu;
 };

I am wondering if moving it to the top of the struct will give a more performant code.

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

Re: [PATCH v2 06/23] gpio: add SRCU infrastructure to struct gpio_desc

Quoted 7 lines · Andy Shevchenko
Quoted 4 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Extend the GPIO descriptor with an SRCU structure in order to serialize the access to the label. Initialize and clean it up where applicable.

Quoted 6 lines

...

Review

Quoted 2 lines
(quoted diff) +2 -0
+     for (i = 0; i < gdev->ngpio; i++)
+             cleanup_srcu_struct(&gdev->descs[i].srcu);

for_each_gpio_desc()?

That works with chips not devices, we'd need to add a variant for gpio_device, but see below:

Quoted 9 lines

(It might be that the latter should be reworked a bit first, dunno)

...

drivers/gpio/gpiolib.c int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, · line 975

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     for (j = 0; j < i; j++)
+                             cleanup_srcu_struct(&desc->srcu);

What does this loop mean?

I open-coded it because I want to store the value of i to go back and destroy the SRCU structs on failure.

Quoted 12 lines
Quoted 3 lines
drivers/gpio/gpiolib.c +2 -0
+                     goto err_remove_of_chip;
+             }

...

drivers/gpio/gpiolib.c int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, · line 1031

Quoted 3 lines
drivers/gpio/gpiolib.c +3 -0
+err_cleanup_desc_srcu:
+     for (i = 0; i < gdev->ngpio; i++)
+             cleanup_srcu_struct(&gdev->descs[i].srcu);

As per above (use existing for_each macro),

Quoted 8 lines

...

Quoted 2 lines

+ struct srcu_struct srcu;
};

I am wondering if moving it to the top of the struct will give a more performant code.

Nah, that would be strictly theoretical. It could matter with container_of() but not with a simple pointer dereference.

Bart

Quoted 5 lines

--
With Best Regards,
Andy Shevchenko

#9 lore raw

Re: [PATCH v2 06/23] gpio: add SRCU infrastructure to struct gpio_desc

Quoted 3 lines · Bartosz Golaszewski
Quoted 1 line · Andy Shevchenko

On Mon, Feb 05, 2024 at 10:34:01AM +0100, Bartosz Golaszewski wrote:

...

Quoted 7 lines
Quoted 4 lines

drivers/gpio/gpiolib.c int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, · line 975

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     for (j = 0; j < i; j++)
+                             cleanup_srcu_struct(&desc->srcu);

What does this loop mean?

I open-coded it because I want to store the value of i to go back and destroy the SRCU structs on failure.

Where/how is j being used?

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     goto err_remove_of_chip;
+             }
Signature · 2 lines
With Best Regards,
Andy Shevchenko
#10 lore raw

Re: [PATCH v2 06/23] gpio: add SRCU infrastructure to struct gpio_desc

Quoted 10 lines · Andy Shevchenko
Quoted 3 lines · Bartosz Golaszewski
Quoted 1 line · Andy Shevchenko

On Mon, Feb 05, 2024 at 10:34:01AM +0100, Bartosz Golaszewski wrote:

...

Quoted 3 lines
Quoted 3 lines
Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     for (j = 0; j < i; j++)
+                             cleanup_srcu_struct(&desc->srcu);
Quoted 7 lines
Quoted 4 lines
Quoted 1 line

What does this loop mean?

I open-coded it because I want to store the value of i to go back and destroy the SRCU structs on failure.

Where/how is j being used?

In this bit:

        for (i = 0; i < gc->ngpio; i++) {
                struct gpio_desc *desc = &gdev->descs[i];

                ret = init_srcu_struct(&desc->srcu);
                if (ret) {
                        for (j = 0; j < i; j++)
                                cleanup_srcu_struct(&desc->srcu);
                        goto err_remove_of_chip;
                }

Bart

Quoted 9 lines
Quoted 2 lines
Quoted 2 lines

drivers/gpio/gpiolib.c int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, · line 977

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     goto err_remove_of_chip;
+             }

--
With Best Regards,
Andy Shevchenko

#11 lore raw

Re: [PATCH v2 06/23] gpio: add SRCU infrastructure to struct gpio_desc

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

On Mon, Feb 05, 2024 at 10:34:01AM +0100, Bartosz Golaszewski wrote:

...

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 4 lines

drivers/gpio/gpiolib.c int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, · line 975

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     for (j = 0; j < i; j++)
+                             cleanup_srcu_struct(&desc->srcu);

What does this loop mean?

Quoted 7 lines
Quoted 5 lines
Quoted 2 lines

I open-coded it because I want to store the value of i to go back and destroy the SRCU structs on failure.

Where/how is j being used?

In this bit:

I am sorry, but I don't see how...

Quoted 7 lines
        for (i = 0; i < gc->ngpio; i++) {
                struct gpio_desc *desc = &gdev->descs[i];

                ret = init_srcu_struct(&desc->srcu);
                if (ret) {
                        for (j = 0; j < i; j++)
                                cleanup_srcu_struct(&desc->srcu);

So, you call the same several times, why?

Quoted 5 lines
                        goto err_remove_of_chip;
                }
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     goto err_remove_of_chip;
+             }
Signature · 2 lines
With Best Regards,
Andy Shevchenko
#12 lore raw

Re: [PATCH v2 06/23] gpio: add SRCU infrastructure to struct gpio_desc

Quoted 29 lines · Andy Shevchenko
Quoted 6 lines · Bartosz Golaszewski
Quoted 4 lines · Andy Shevchenko
Quoted 3 lines · Bartosz Golaszewski
Quoted 1 line · Andy Shevchenko

On Mon, Feb 05, 2024 at 10:34:01AM +0100, Bartosz Golaszewski wrote:

...

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 4 lines

drivers/gpio/gpiolib.c int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data, · line 975

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     for (j = 0; j < i; j++)
+                             cleanup_srcu_struct(&desc->srcu);

What does this loop mean?

Quoted 7 lines
Quoted 5 lines
Quoted 2 lines

I open-coded it because I want to store the value of i to go back and destroy the SRCU structs on failure.

Where/how is j being used?

In this bit:

I am sorry, but I don't see how...

Quoted 3 lines
        for (i = 0; i < gc->ngpio; i++) {
                struct gpio_desc *desc = &gdev->descs[i];
Quoted 6 lines
Quoted 4 lines
                ret = init_srcu_struct(&desc->srcu);
                if (ret) {
                        for (j = 0; j < i; j++)
                                cleanup_srcu_struct(&desc->srcu);

So, you call the same several times, why?

Ah, now I feel stupid. You're right of course, I'll fix it.

Bart

Quoted 12 lines
Quoted 6 lines
                        goto err_remove_of_chip;
                }
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                     goto err_remove_of_chip;
+             }

--
With Best Regards,
Andy Shevchenko

#13 lore raw

PATCH v2 7/23 gpio: protect the descriptor label with SRCU

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

In order to ensure that the label is not freed while it's being accessed, let's protect it with SRCU and synchronize it everytime it's changed.

Let's modify desc_set_label() to manage the memory used for the label as it can only be freed once synchronize_srcu() returns.

---
 drivers/gpio/gpiolib-cdev.c | 10 +++++---
 drivers/gpio/gpiolib.c      | 47 +++++++++++++++++++++++--------------
 drivers/gpio/gpiolib.h      | 34 +++++++++++++++++++--------
 3 files changed, 61 insertions(+), 30 deletions(-)
drivers/gpio/gpiolib-cdev.c +7 -3
index 2c0a0700762d..75f4912339a6 100644
@@ -2297,6 +2297,7 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
 {
 	struct gpio_chip *gc = desc->gdev->chip;
 	unsigned long dflags;
+	const char *label;
 
 	memset(info, 0, sizeof(*info));
 	info->offset = gpio_chip_hwgpio(desc);
@@ -2305,9 +2306,12 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
 		if (desc->name)
 			strscpy(info->name, desc->name, sizeof(info->name));
 
-		if (gpiod_get_label(desc))
-			strscpy(info->consumer, gpiod_get_label(desc),
-				sizeof(info->consumer));
+		scoped_guard(srcu, &desc->srcu) {
+			label = gpiod_get_label(desc);
+			if (label)
+				strscpy(info->consumer, label,
+					sizeof(info->consumer));
+		}
 
 		dflags = READ_ONCE(desc->flags);
 	}
drivers/gpio/gpiolib.c +30 -17

99 lines not on this page · raw message

drivers/gpio/gpiolib.h +24 -10
index 6e14b629c48b..d2e73eea9e92 100644
@@ -180,7 +180,7 @@ struct gpio_desc {
 #define FLAG_EVENT_CLOCK_HTE		19 /* GPIO CDEV reports hardware timestamps in events */
 
 	/* Connection label */
-	const char		*label;
+	const char __rcu	*label;
 	/* Name of the GPIO */
 	const char		*name;
 #ifdef CONFIG_OF_DYNAMIC
@@ -223,15 +223,29 @@ static inline int gpio_chip_hwgpio(const struct gpio_desc *desc)
 
 /* With descriptor prefix */
 
-#define gpiod_err(desc, fmt, ...)					       \
-	pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",  \
-		 ##__VA_ARGS__)
-#define gpiod_warn(desc, fmt, ...)					       \
-	pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
-		 ##__VA_ARGS__)
-#define gpiod_dbg(desc, fmt, ...)					       \
-	pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
-		 ##__VA_ARGS__)
+#define gpiod_err(desc, fmt, ...) \
+do { \
+	scoped_guard(srcu, &desc->srcu) { \
+		pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), \
+		       gpiod_get_label(desc) ? : "?", ##__VA_ARGS__); \
+	} \
+} while (0)
+
+#define gpiod_warn(desc, fmt, ...) \
+do { \
+	scoped_guard(srcu, &desc->srcu) { \
+		pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), \
+			gpiod_get_label(desc) ? : "?", ##__VA_ARGS__); \
+	} \
+} while (0)
+
+#define gpiod_dbg(desc, fmt, ...) \
+do { \
+	scoped_guard(srcu, &desc->srcu) { \
+		pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), \
+			 gpiod_get_label(desc) ? : "?", ##__VA_ARGS__); \
+	} \
+} while (0)
 
 /* With chip prefix */
 
Signature · 1 line
2.40.1
#14 lore raw

PATCH v2 8/23 gpio: sysfs: use gpio_device_find() to iterate over existing devices

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

With the list of GPIO devices now protected with SRCU we can use gpio_device_find() to traverse it from sysfs.

---
 drivers/gpio/gpiolib-sysfs.c | 41 ++++++++++++++++--------------------
 drivers/gpio/gpiolib.c       |  2 +-
 drivers/gpio/gpiolib.h       |  1 -
 3 files changed, 19 insertions(+), 25 deletions(-)
drivers/gpio/gpiolib-sysfs.c +18 -23
index 6bf5332136e5..3c3b8559cff5 100644
@@ -790,11 +790,24 @@ void gpiochip_sysfs_unregister(struct gpio_device *gdev)
 	}
 }
 
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+	struct gpio_device *gdev = gc->gpiodev;
+	int ret;
+
+	if (gdev->mockdev)
+		return 0;
+
+	ret = gpiochip_sysfs_register(gdev);
+	if (ret)
+		chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
+
+	return 0;
+}
+
 static int __init gpiolib_sysfs_init(void)
 {
-	int		status;
-	unsigned long	flags;
-	struct gpio_device *gdev;
+	int status;
 
 	status = class_register(&gpio_class);
 	if (status < 0)
@@ -806,26 +819,8 @@ static int __init gpiolib_sysfs_init(void)
 	 * We run before arch_initcall() so chip->dev nodes can have
 	 * registered, and so arch_initcall() can always gpiod_export().
 	 */
-	spin_lock_irqsave(&gpio_lock, flags);
-	list_for_each_entry(gdev, &gpio_devices, list) {
-		if (gdev->mockdev)
-			continue;
+	gpio_device_find(NULL, gpiofind_sysfs_register);
 
-		/*
-		 * TODO we yield gpio_lock here because
-		 * gpiochip_sysfs_register() acquires a mutex. This is unsafe
-		 * and needs to be fixed.
-		 *
-		 * Also it would be nice to use gpio_device_find() here so we
-		 * can keep gpio_chips local to gpiolib.c, but the yield of
-		 * gpio_lock prevents us from doing this.
-		 */
-		spin_unlock_irqrestore(&gpio_lock, flags);
-		status = gpiochip_sysfs_register(gdev);
-		spin_lock_irqsave(&gpio_lock, flags);
-	}
-	spin_unlock_irqrestore(&gpio_lock, flags);
-
-	return status;
+	return 0;
 }
 postcore_initcall(gpiolib_sysfs_init);
drivers/gpio/gpiolib.c +1 -1
index f425e0264b7e..6cfb75ee739d 100644
@@ -85,7 +85,7 @@ DEFINE_SPINLOCK(gpio_lock);
 static DEFINE_MUTEX(gpio_lookup_lock);
 static LIST_HEAD(gpio_lookup_list);
 
-LIST_HEAD(gpio_devices);
+static LIST_HEAD(gpio_devices);
 /* Protects the GPIO device list against concurrent modifications. */
 static DEFINE_MUTEX(gpio_devices_lock);
 /* Ensures coherence during read-only accesses to the list of GPIO devices. */
drivers/gpio/gpiolib.h +0 -1
index d2e73eea9e92..2bf3f9e13ae4 100644
@@ -136,7 +136,6 @@ int gpiod_set_array_value_complex(bool raw, bool can_sleep,
 int gpiod_set_transitory(struct gpio_desc *desc, bool transitory);
 
 extern spinlock_t gpio_lock;
-extern struct list_head gpio_devices;
 
 void gpiod_line_state_notify(struct gpio_desc *desc, unsigned long action);
 
Signature · 1 line
2.40.1
#15 lore raw

Re: [PATCH v2 08/23] gpio: sysfs: use gpio_device_find() to iterate over existing devices

Quoted 4 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

With the list of GPIO devices now protected with SRCU we can use gpio_device_find() to traverse it from sysfs.

...

drivers/gpio/gpiolib-sysfs.c void gpiochip_sysfs_unregister(struct gpio_device *gdev)

Quoted 13 lines
drivers/gpio/gpiolib-sysfs.c +12 -0
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+	struct gpio_device *gdev = gc->gpiodev;
+	int ret;
+
+	if (gdev->mockdev)
+		return 0;
+
+	ret = gpiochip_sysfs_register(gdev);
+	if (ret)
+		chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
 
+	return 0;

???

Quoted 1 line

+}

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

Re: [PATCH v2 08/23] gpio: sysfs: use gpio_device_find() to iterate over existing devices

Quoted 21 lines · Andy Shevchenko
Quoted 4 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

With the list of GPIO devices now protected with SRCU we can use gpio_device_find() to traverse it from sysfs.

...

Quoted 11 lines
drivers/gpio/gpiolib-sysfs.c +11 -0
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+     struct gpio_device *gdev = gc->gpiodev;
+     int ret;
+
+     if (gdev->mockdev)
+             return 0;
+
+     ret = gpiochip_sysfs_register(gdev);
+     if (ret)
+             chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
Quoted 4 lines
Quoted 1 line

+ return 0;

???

Not sure what the ... and ??? mean? The commit message should have read "... traverse it from gpiofind_sysfs_register()" I agree but the latter?

Bart

Quoted 7 lines
Quoted 1 line

+}

--
With Best Regards,
Andy Shevchenko

#17 lore raw

Re: [PATCH v2 08/23] gpio: sysfs: use gpio_device_find() to iterate over existing devices

Quoted 7 lines · Bartosz Golaszewski
Quoted 5 lines · Andy Shevchenko
Quoted 4 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

With the list of GPIO devices now protected with SRCU we can use gpio_device_find() to traverse it from sysfs.

...

Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
drivers/gpio/gpiolib-sysfs.c +11 -0
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+     struct gpio_device *gdev = gc->gpiodev;
+     int ret;
+
+     if (gdev->mockdev)
+             return 0;
+
+     ret = gpiochip_sysfs_register(gdev);
+     if (ret)
+             chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
Quoted 3 lines
Quoted 3 lines
Quoted 1 line

+ return 0;

???

What the point of function to be int if you effectively ignore this by always returning 0?

Quoted 3 lines

Not sure what the ... and ??? mean? The commit message should have read "... traverse it from gpiofind_sysfs_register()" I agree but the latter?

I didn't realize this may not be obvious :-(.

Quoted 1 line
Quoted 1 line
Quoted 1 line

+}

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

Re: [PATCH v2 08/23] gpio: sysfs: use gpio_device_find() to iterate over existing devices

Quoted 24 lines · Andy Shevchenko
Quoted 7 lines · Bartosz Golaszewski
Quoted 5 lines · Andy Shevchenko
Quoted 4 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

With the list of GPIO devices now protected with SRCU we can use gpio_device_find() to traverse it from sysfs.

...

Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
drivers/gpio/gpiolib-sysfs.c +11 -0
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+     struct gpio_device *gdev = gc->gpiodev;
+     int ret;
+
+     if (gdev->mockdev)
+             return 0;
+
+     ret = gpiochip_sysfs_register(gdev);
+     if (ret)
+             chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
Quoted 1 line

+ return 0;

???

What the point of function to be int if you effectively ignore this by always returning 0?

Because the signature of the callback expects an int to be returned?

Bart

Quoted 13 lines
Quoted 3 lines

Not sure what the ... and ??? mean? The commit message should have read "... traverse it from gpiofind_sysfs_register()" I agree but the latter?

I didn't realize this may not be obvious :-(.

Quoted 1 line
Quoted 1 line
Quoted 1 line

+}

--
With Best Regards,
Andy Shevchenko

#19 lore raw

Re: [PATCH v2 08/23] gpio: sysfs: use gpio_device_find() to iterate over existing devices

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

On Mon, Feb 05, 2024 at 10:34:03AM +0100, Bartosz Golaszewski wrote:

...

Quoted 14 lines
Quoted 14 lines
Quoted 14 lines
Quoted 14 lines
Quoted 13 lines
drivers/gpio/gpiolib-sysfs.c +12 -0
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+     struct gpio_device *gdev = gc->gpiodev;
+     int ret;
+
+     if (gdev->mockdev)
+             return 0;
+
+     ret = gpiochip_sysfs_register(gdev);
+     if (ret)
+             chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
 
+     return 0;
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
Quoted 1 line

???

What the point of function to be int if you effectively ignore this by always returning 0?

Because the signature of the callback expects an int to be returned?

But why do you return 0 instead of ret?

Quoted 7 lines
Quoted 7 lines
Quoted 3 lines

Not sure what the ... and ??? mean? The commit message should have read "... traverse it from gpiofind_sysfs_register()" I agree but the latter?

I didn't realize this may not be obvious :-(.

Quoted 1 line
Quoted 1 line
Quoted 1 line

+}

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

Re: [PATCH v2 08/23] gpio: sysfs: use gpio_device_find() to iterate over existing devices

Quoted 27 lines · Andy Shevchenko
Quoted 6 lines · Bartosz Golaszewski
Quoted 4 lines · Andy Shevchenko
Quoted 3 lines · Bartosz Golaszewski
Quoted 1 line · Andy Shevchenko

On Mon, Feb 05, 2024 at 10:34:03AM +0100, Bartosz Golaszewski wrote:

...

Quoted 16 lines
Quoted 16 lines
Quoted 15 lines
Quoted 15 lines

drivers/gpio/gpiolib-sysfs.c void gpiochip_sysfs_unregister(struct gpio_device *gdev)

Quoted 13 lines
drivers/gpio/gpiolib-sysfs.c +12 -0
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+     struct gpio_device *gdev = gc->gpiodev;
+     int ret;
+
+     if (gdev->mockdev)
+             return 0;
+
+     ret = gpiochip_sysfs_register(gdev);
+     if (ret)
+             chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
 
+     return 0;

???

Quoted 8 lines
Quoted 5 lines
Quoted 3 lines

What the point of function to be int if you effectively ignore this by always returning 0?

Because the signature of the callback expects an int to be returned?

But why do you return 0 instead of ret?

Because we don't want to *find* a device really. We just want to iterate over all of them and call a callback. Any value other than 0 will be interpreted as a match. Besides: failure to register one GPIO sysfs entry shouldn't maybe cause a failure for all subsequent devices?

Bart

Quoted 13 lines
Quoted 7 lines
Quoted 7 lines
Quoted 3 lines

Not sure what the ... and ??? mean? The commit message should have read "... traverse it from gpiofind_sysfs_register()" I agree but the latter?

I didn't realize this may not be obvious :-(.

Quoted 1 line
Quoted 1 line
Quoted 1 line

+}

--
With Best Regards,
Andy Shevchenko

#21 lore raw

Re: [PATCH v2 08/23] gpio: sysfs: use gpio_device_find() to iterate over existing devices

Quoted 9 lines · Bartosz Golaszewski
Quoted 7 lines · Andy Shevchenko
Quoted 6 lines · Bartosz Golaszewski
Quoted 4 lines · Andy Shevchenko
Quoted 3 lines · Bartosz Golaszewski
Quoted 1 line · Andy Shevchenko

On Mon, Feb 05, 2024 at 10:34:03AM +0100, Bartosz Golaszewski wrote:

...

Quoted 21 lines
Quoted 21 lines
Quoted 20 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
(quoted diff) +11 -0
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+     struct gpio_device *gdev = gc->gpiodev;
+     int ret;
+
+     if (gdev->mockdev)
+             return 0;
+
+     ret = gpiochip_sysfs_register(gdev);
+     if (ret)
+             chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
Quoted 6 lines
Quoted 3 lines
Quoted 3 lines
Quoted 1 line

+ return 0;

???

What the point of function to be int if you effectively ignore this by always returning 0?

Because the signature of the callback expects an int to be returned?

Quoted 8 lines
Quoted 2 lines

But why do you return 0 instead of ret?

Because we don't want to *find* a device really. We just want to iterate over all of them and call a callback. Any value other than 0 will be interpreted as a match. Besides: failure to register one GPIO sysfs entry shouldn't maybe cause a failure for all subsequent devices?

To me it's not obvious, hence I would like to see a comment before return 0.

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 3 lines

Not sure what the ... and ??? mean? The commit message should have read "... traverse it from gpiofind_sysfs_register()" I agree but the latter?

I didn't realize this may not be obvious :-(.

Quoted 1 line
Quoted 1 line
Quoted 1 line

+}

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

Re: [PATCH v2 08/23] gpio: sysfs: use gpio_device_find() to iterate over existing devices

Quoted 38 lines · Andy Shevchenko
Quoted 9 lines · Bartosz Golaszewski
Quoted 7 lines · Andy Shevchenko
Quoted 6 lines · Bartosz Golaszewski
Quoted 4 lines · Andy Shevchenko
Quoted 3 lines · Bartosz Golaszewski
Quoted 1 line · Andy Shevchenko

On Mon, Feb 05, 2024 at 10:34:03AM +0100, Bartosz Golaszewski wrote:

...

Quoted 24 lines
Quoted 23 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
(quoted diff) +11 -0
+static int gpiofind_sysfs_register(struct gpio_chip *gc, void *data)
+{
+     struct gpio_device *gdev = gc->gpiodev;
+     int ret;
+
+     if (gdev->mockdev)
+             return 0;
+
+     ret = gpiochip_sysfs_register(gdev);
+     if (ret)
+             chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
Quoted 3 lines
Quoted 1 line

+ return 0;

???

What the point of function to be int if you effectively ignore this by always returning 0?

Because the signature of the callback expects an int to be returned?

But why do you return 0 instead of ret?

Quoted 8 lines
Quoted 5 lines

Because we don't want to *find* a device really. We just want to iterate over all of them and call a callback. Any value other than 0 will be interpreted as a match. Besides: failure to register one GPIO sysfs entry shouldn't maybe cause a failure for all subsequent devices?

To me it's not obvious, hence I would like to see a comment before return 0.

I'll add it for v3.

Bart

Quoted 13 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 3 lines

Not sure what the ... and ??? mean? The commit message should have read "... traverse it from gpiofind_sysfs_register()" I agree but the latter?

I didn't realize this may not be obvious :-(.

Quoted 1 line
Quoted 1 line
Quoted 1 line

+}

--
With Best Regards,
Andy Shevchenko

#23 lore raw

PATCH v2 9/23 gpio: remove gpio_lock

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

The "multi-function" gpio_lock is pretty much useless with how it's used in GPIOLIB currently. Because many GPIO API calls can be called from all contexts but may also call into sleeping driver callbacks, there are many places with utterly broken workarounds like yielding the lock to call a possibly sleeping function and then re-acquiring it again without taking into account that the protected state may have changed.

It was also used to protect several unrelated things: like individual descriptors AND the GPIO device list. We now serialize access to these two with SRCU and so can finally remove the spinlock.

There is of course the question of consistency of lockless access to GPIO descriptors. Because we only support exclusive access to GPIOs (officially anyway, I'm looking at you broken GPIOD_FLAGS_BIT_NONEXCLUSIVE bit...) and the API contract with providers does not guarantee serialization, it's enough to ensure we cannot accidentally dereference an invalid pointer and that the state we present to both users and providers remains consistent. To achieve that: read the flags field atomically except for a few special cases. Read their current value before executing callback code and use this value for any subsequent logic. Modifying the flags depends on the particular use-case and can differ. For instance: when requesting a GPIO, we need to set the REQUESTED bit immediately so that the next user trying to request the same line sees -EBUSY.

While at it: the allocations that used GFP_ATOMIC until this point can now switch to GFP_KERNEL.

---
 drivers/gpio/gpiolib-cdev.c  |  18 +++---
 drivers/gpio/gpiolib-sysfs.c |  17 ++----
 drivers/gpio/gpiolib.c       | 106 +++++++++++------------------------
 drivers/gpio/gpiolib.h       |   2 -
 4 files changed, 46 insertions(+), 97 deletions(-)
drivers/gpio/gpiolib-cdev.c +8 -10
index 75f4912339a6..3588aaf90e45 100644
@@ -2302,18 +2302,16 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
 	memset(info, 0, sizeof(*info));
 	info->offset = gpio_chip_hwgpio(desc);
 
-	scoped_guard(spinlock_irqsave, &gpio_lock) {
-		if (desc->name)
-			strscpy(info->name, desc->name, sizeof(info->name));
+	if (desc->name)
+		strscpy(info->name, desc->name, sizeof(info->name));
 
-		scoped_guard(srcu, &desc->srcu) {
-			label = gpiod_get_label(desc);
-			if (label)
-				strscpy(info->consumer, label,
-					sizeof(info->consumer));
-		}
+	dflags = READ_ONCE(desc->flags);
 
-		dflags = READ_ONCE(desc->flags);
+	scoped_guard(srcu, &desc->srcu) {
+		label = gpiod_get_label(desc);
+		if (label && test_bit(FLAG_REQUESTED, &dflags))
+			strscpy(info->consumer, label,
+				sizeof(info->consumer));
 	}
 
 	/*
drivers/gpio/gpiolib-sysfs.c +6 -11
index 3c3b8559cff5..1cc707685f87 100644
@@ -563,7 +563,6 @@ int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 	struct gpio_device *gdev;
 	struct gpiod_data *data;
 	struct gpio_chip *chip;
-	unsigned long flags;
 	struct device *dev;
 	int status, offset;
 
@@ -578,6 +577,9 @@ int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 		return -EINVAL;
 	}
 
+	if (!test_and_set_bit(FLAG_EXPORT, &desc->flags))
+		return -EPERM;
+
 	gdev = desc->gdev;
 	chip = gdev->chip;
 
@@ -589,18 +591,11 @@ int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 		goto err_unlock;
 	}
 
-	spin_lock_irqsave(&gpio_lock, flags);
-	if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
-	     test_bit(FLAG_EXPORT, &desc->flags)) {
-		spin_unlock_irqrestore(&gpio_lock, flags);
-		gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
-				__func__,
-				test_bit(FLAG_REQUESTED, &desc->flags),
-				test_bit(FLAG_EXPORT, &desc->flags));
+	if (!test_bit(FLAG_REQUESTED, &desc->flags)) {
+		gpiod_dbg(desc, "%s: unavailable (not requested)\n", __func__);
 		status = -EPERM;
 		goto err_unlock;
 	}
-	spin_unlock_irqrestore(&gpio_lock, flags);
 
 	data = kzalloc(sizeof(*data), GFP_KERNEL);
 	if (!data) {
@@ -628,7 +623,6 @@ int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 		goto err_free_data;
 	}
 
-	set_bit(FLAG_EXPORT, &desc->flags);
 	mutex_unlock(&sysfs_lock);
 	return 0;
 
@@ -636,6 +630,7 @@ int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 	kfree(data);
 err_unlock:
 	mutex_unlock(&sysfs_lock);
+	clear_bit(FLAG_EXPORT, &desc->flags);
 	gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 	return status;
 }
drivers/gpio/gpiolib.c +32 -74

190 lines not on this page · raw message

drivers/gpio/gpiolib.h +0 -2
index 2bf3f9e13ae4..9b7afe87f1bd 100644
@@ -135,8 +135,6 @@ int gpiod_set_array_value_complex(bool raw, bool can_sleep,
 
 int gpiod_set_transitory(struct gpio_desc *desc, bool transitory);
 
-extern spinlock_t gpio_lock;
-
 void gpiod_line_state_notify(struct gpio_desc *desc, unsigned long action);
 
 /**
Signature · 1 line
2.40.1
#24 lore raw

PATCH v2 10/23 gpio: reinforce desc->flags handling

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

We now removed the gpio_lock spinlock and modified the places previously protected by it to handle desc->flags access in a consistent way. Let's improve other places that were previously unprotected by reading the flags field of gpio_desc once and using the stored value for logic consistency. If we need to modify the field, let's also write it back once with a consistent value resulting from the function's logic.

---
 drivers/gpio/gpiolib.c | 42 +++++++++++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 17 deletions(-)
drivers/gpio/gpiolib.c +25 -17
index 5ed5b71590ab..d49f84d692ce 100644
@@ -336,18 +336,20 @@ static int gpiochip_find_base_unlocked(int ngpio)
 int gpiod_get_direction(struct gpio_desc *desc)
 {
 	struct gpio_chip *gc;
+	unsigned long flags;
 	unsigned int offset;
 	int ret;
 
 	gc = gpiod_to_chip(desc);
 	offset = gpio_chip_hwgpio(desc);
+	flags = READ_ONCE(desc->flags);
 
 	/*
 	 * Open drain emulation using input mode may incorrectly report
 	 * input here, fix that up.
 	 */
-	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) &&
-	    test_bit(FLAG_IS_OUT, &desc->flags))
+	if (test_bit(FLAG_OPEN_DRAIN, &flags) &&
+	    test_bit(FLAG_IS_OUT, &flags))
 		return 0;
 
 	if (!gc->get_direction)
@@ -361,7 +363,8 @@ int gpiod_get_direction(struct gpio_desc *desc)
 	if (ret > 0)
 		ret = 1;
 
-	assign_bit(FLAG_IS_OUT, &desc->flags, !ret);
+	assign_bit(FLAG_IS_OUT, &flags, !ret);
+	WRITE_ONCE(desc->flags, flags);
 
 	return ret;
 }
@@ -747,9 +750,6 @@ static void gpiochip_machine_hog(struct gpio_chip *gc, struct gpiod_hog *hog)
 		return;
 	}
 
-	if (test_bit(FLAG_IS_HOGGED, &desc->flags))
-		return;
-
 	rv = gpiod_hog(desc, hog->line_name, hog->lflags, hog->dflags);
 	if (rv)
 		gpiod_err(desc, "%s: unable to hog GPIO line (%s:%u): %d\n",
@@ -2522,13 +2522,16 @@ static int gpio_set_config(struct gpio_desc *desc, enum pin_config_param mode)
 static int gpio_set_bias(struct gpio_desc *desc)
 {
 	enum pin_config_param bias;
+	unsigned long flags;
 	unsigned int arg;
 
-	if (test_bit(FLAG_BIAS_DISABLE, &desc->flags))
+	flags = READ_ONCE(desc->flags);
+
+	if (test_bit(FLAG_BIAS_DISABLE, &flags))
 		bias = PIN_CONFIG_BIAS_DISABLE;
-	else if (test_bit(FLAG_PULL_UP, &desc->flags))
+	else if (test_bit(FLAG_PULL_UP, &flags))
 		bias = PIN_CONFIG_BIAS_PULL_UP;
-	else if (test_bit(FLAG_PULL_DOWN, &desc->flags))
+	else if (test_bit(FLAG_PULL_DOWN, &flags))
 		bias = PIN_CONFIG_BIAS_PULL_DOWN;
 	else
 		return 0;
@@ -2694,24 +2697,28 @@ EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
  */
 int gpiod_direction_output(struct gpio_desc *desc, int value)
 {
+	unsigned long flags;
 	int ret;
 
 	VALIDATE_DESC(desc);
-	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
+
+	flags = READ_ONCE(desc->flags);
+
+	if (test_bit(FLAG_ACTIVE_LOW, &flags))
 		value = !value;
 	else
 		value = !!value;
 
 	/* GPIOs used for enabled IRQs shall not be set as output */
-	if (test_bit(FLAG_USED_AS_IRQ, &desc->flags) &&
-	    test_bit(FLAG_IRQ_IS_ENABLED, &desc->flags)) {
+	if (test_bit(FLAG_USED_AS_IRQ, &flags) &&
+	    test_bit(FLAG_IRQ_IS_ENABLED, &flags)) {
 		gpiod_err(desc,
 			  "%s: tried to set a GPIO tied to an IRQ as output\n",
 			  __func__);
 		return -EIO;
 	}
 
-	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
+	if (test_bit(FLAG_OPEN_DRAIN, &flags)) {
 		/* First see if we can enable open drain in hardware */
 		ret = gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_DRAIN);
 		if (!ret)
@@ -2721,7 +2728,7 @@ int gpiod_direction_output(struct gpio_desc *desc, int value)
 			ret = gpiod_direction_input(desc);
 			goto set_output_flag;
 		}
-	} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
+	} else if (test_bit(FLAG_OPEN_SOURCE, &flags)) {
 		ret = gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_SOURCE);
 		if (!ret)
 			goto set_output_value;
@@ -4418,21 +4425,22 @@ int gpiod_hog(struct gpio_desc *desc, const char *name,
 	int hwnum;
 	int ret;
 
+	if (test_and_set_bit(FLAG_IS_HOGGED, &desc->flags))
+		return 0;
+
 	gc = gpiod_to_chip(desc);
 	hwnum = gpio_chip_hwgpio(desc);
 
 	local_desc = gpiochip_request_own_desc(gc, hwnum, name,
 					       lflags, dflags);
 	if (IS_ERR(local_desc)) {
+		clear_bit(FLAG_IS_HOGGED, &desc->flags);
 		ret = PTR_ERR(local_desc);
 		pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n",
 		       name, gc->label, hwnum, ret);
 		return ret;
 	}
 
-	/* Mark GPIO as hogged so it can be identified and removed later */
-	set_bit(FLAG_IS_HOGGED, &desc->flags);
-
 	gpiod_dbg(desc, "hogged as %s%s\n",
 		(dflags & GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
 		(dflags & GPIOD_FLAGS_BIT_DIR_OUT) ?
Signature · 1 line
2.40.1
#25 lore raw

PATCH v2 11/23 gpio: remove unneeded code from gpio_device_get_desc()

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

The GPIO chip pointer is unused. Let's remove it.

---
 drivers/gpio/gpiolib.c | 10 ----------
 1 file changed, 10 deletions(-)
drivers/gpio/gpiolib.c +0 -10
index d49f84d692ce..f77f919dbad9 100644
@@ -184,16 +184,6 @@ EXPORT_SYMBOL_GPL(gpiochip_get_desc);
 struct gpio_desc *
 gpio_device_get_desc(struct gpio_device *gdev, unsigned int hwnum)
 {
-	struct gpio_chip *gc;
-
-	/*
-	 * FIXME: This will be locked once we protect gdev->chip everywhere
-	 * with SRCU.
-	 */
-	gc = gdev->chip;
-	if (!gc)
-		return ERR_PTR(-ENODEV);
-
 	if (hwnum >= gdev->ngpio)
 		return ERR_PTR(-EINVAL);
 
Signature · 1 line
2.40.1
#26 lore raw

PATCH v2 12/23 gpio: sysfs: extend the critical section for unregistering sysfs devices

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Checking the gdev->mockdev pointer for NULL must be part of the critical section.

---
 drivers/gpio/gpiolib-sysfs.c | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)
drivers/gpio/gpiolib-sysfs.c +8 -7
index 1cc707685f87..5da316ea9cc7 100644
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0
 
 #include <linux/bitops.h>
+#include <linux/cleanup.h>
 #include <linux/device.h>
 #include <linux/idr.h>
 #include <linux/init.h>
@@ -768,15 +769,15 @@ void gpiochip_sysfs_unregister(struct gpio_device *gdev)
 	struct gpio_desc *desc;
 	struct gpio_chip *chip = gdev->chip;
 
-	if (!gdev->mockdev)
-		return;
+	scoped_guard(mutex, &sysfs_lock) {
+		if (!gdev->mockdev)
+			return;
 
-	device_unregister(gdev->mockdev);
+		device_unregister(gdev->mockdev);
 
-	/* prevent further gpiod exports */
-	mutex_lock(&sysfs_lock);
-	gdev->mockdev = NULL;
-	mutex_unlock(&sysfs_lock);
+		/* prevent further gpiod exports */
+		gdev->mockdev = NULL;
+	}
 
 	/* unregister gpiod class devices owned by sysfs */
 	for_each_gpio_desc_with_flag(chip, desc, FLAG_SYSFS) {
Signature · 1 line
2.40.1
#27 lore raw

PATCH v2 13/23 gpio: sysfs: pass the GPIO device - not chip - to sysfs callbacks

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

We're working towards protecting the chip pointer in struct gpio_device with SRCU. In order to use it in sysfs callbacks we must pass the pointer to the GPIO device that wraps the chip instead of the address of the chip itself as the user data.

---
 drivers/gpio/gpiolib-sysfs.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)
drivers/gpio/gpiolib-sysfs.c +7 -7
index 5da316ea9cc7..654a5bc53047 100644
@@ -401,27 +401,27 @@ static const struct attribute_group *gpio_groups[] = {
 static ssize_t base_show(struct device *dev,
 			       struct device_attribute *attr, char *buf)
 {
-	const struct gpio_chip *chip = dev_get_drvdata(dev);
+	const struct gpio_device *gdev = dev_get_drvdata(dev);
 
-	return sysfs_emit(buf, "%d\n", chip->base);
+	return sysfs_emit(buf, "%d\n", gdev->chip->base);
 }
 static DEVICE_ATTR_RO(base);
 
 static ssize_t label_show(struct device *dev,
 			       struct device_attribute *attr, char *buf)
 {
-	const struct gpio_chip *chip = dev_get_drvdata(dev);
+	const struct gpio_device *gdev = dev_get_drvdata(dev);
 
-	return sysfs_emit(buf, "%s\n", chip->label ?: "");
+	return sysfs_emit(buf, "%s\n", gdev->chip->label ?: "");
 }
 static DEVICE_ATTR_RO(label);
 
 static ssize_t ngpio_show(struct device *dev,
 			       struct device_attribute *attr, char *buf)
 {
-	const struct gpio_chip *chip = dev_get_drvdata(dev);
+	const struct gpio_device *gdev = dev_get_drvdata(dev);
 
-	return sysfs_emit(buf, "%u\n", chip->ngpio);
+	return sysfs_emit(buf, "%u\n", gdev->chip->ngpio);
 }
 static DEVICE_ATTR_RO(ngpio);
 
@@ -751,7 +751,7 @@ int gpiochip_sysfs_register(struct gpio_device *gdev)
 		parent = &gdev->dev;
 
 	/* use chip->base for the ID; it's already known to be unique */
-	dev = device_create_with_groups(&gpio_class, parent, MKDEV(0, 0), chip,
+	dev = device_create_with_groups(&gpio_class, parent, MKDEV(0, 0), gdev,
 					gpiochip_groups, GPIOCHIP_NAME "%d",
 					chip->base);
 	if (IS_ERR(dev))
Signature · 1 line
2.40.1
#28 lore raw

PATCH v2 14/23 gpio: cdev: replace gpiochip_get_desc() with gpio_device_get_desc()

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

gpio_device_get_desc() is the safer alternative to gpiochip_get_desc(). As we don't really need to dereference the chip pointer to retrieve the descriptors in character device code, let's use it.

---
 drivers/gpio/gpiolib-cdev.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)
drivers/gpio/gpiolib-cdev.c +5 -5
index 3588aaf90e45..8e37e3befa08 100644
@@ -332,7 +332,7 @@ static int linehandle_create(struct gpio_device *gdev, void __user *ip)
 	/* Request each GPIO */
 	for (i = 0; i < handlereq.lines; i++) {
 		u32 offset = handlereq.lineoffsets[i];
-		struct gpio_desc *desc = gpiochip_get_desc(gdev->chip, offset);
+		struct gpio_desc *desc = gpio_device_get_desc(gdev, offset);
 
 		if (IS_ERR(desc)) {
 			ret = PTR_ERR(desc);
@@ -1739,7 +1739,7 @@ static int linereq_create(struct gpio_device *gdev, void __user *ip)
 	/* Request each GPIO */
 	for (i = 0; i < ulr.num_lines; i++) {
 		u32 offset = ulr.offsets[i];
-		struct gpio_desc *desc = gpiochip_get_desc(gdev->chip, offset);
+		struct gpio_desc *desc = gpio_device_get_desc(gdev, offset);
 
 		if (IS_ERR(desc)) {
 			ret = PTR_ERR(desc);
@@ -2123,7 +2123,7 @@ static int lineevent_create(struct gpio_device *gdev, void __user *ip)
 	lflags = eventreq.handleflags;
 	eflags = eventreq.eventflags;
 
-	desc = gpiochip_get_desc(gdev->chip, offset);
+	desc = gpio_device_get_desc(gdev, offset);
 	if (IS_ERR(desc))
 		return PTR_ERR(desc);
 
@@ -2419,7 +2419,7 @@ static int lineinfo_get_v1(struct gpio_chardev_data *cdev, void __user *ip,
 		return -EFAULT;
 
 	/* this doubles as a range check on line_offset */
-	desc = gpiochip_get_desc(cdev->gdev->chip, lineinfo.line_offset);
+	desc = gpio_device_get_desc(cdev->gdev, lineinfo.line_offset);
 	if (IS_ERR(desc))
 		return PTR_ERR(desc);
 
@@ -2456,7 +2456,7 @@ static int lineinfo_get(struct gpio_chardev_data *cdev, void __user *ip,
 	if (memchr_inv(lineinfo.padding, 0, sizeof(lineinfo.padding)))
 		return -EINVAL;
 
-	desc = gpiochip_get_desc(cdev->gdev->chip, lineinfo.offset);
+	desc = gpio_device_get_desc(cdev->gdev, lineinfo.offset);
 	if (IS_ERR(desc))
 		return PTR_ERR(desc);
 
Signature · 1 line
2.40.1
#29 lore raw

PATCH v2 15/23 gpio: cdev: don't access gdev->chip if it's not needed

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

The variable holding the number of GPIO lines is duplicated in GPIO device so read it instead of unnecessarily dereferencing the chip pointer.

---
 drivers/gpio/gpiolib-cdev.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpio/gpiolib-cdev.c +1 -1
index 8e37e3befa08..e993c6a7215a 100644
@@ -2701,7 +2701,7 @@ static int gpio_chrdev_open(struct inode *inode, struct file *file)
 	if (!cdev)
 		return -ENODEV;
 
-	cdev->watched_lines = bitmap_zalloc(gdev->chip->ngpio, GFP_KERNEL);
+	cdev->watched_lines = bitmap_zalloc(gdev->ngpio, GFP_KERNEL);
 	if (!cdev->watched_lines)
 		goto out_free_cdev;
 
Signature · 1 line
2.40.1
#30 lore raw

PATCH v2 16/23 gpio: don't dereference gdev->chip in gpiochip_setup_dev()

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

We don't need to dereference gdev->chip in gpiochip_setup_dev() as at the time it's called, the label in the associated struct gpio_device is already set.

---
 drivers/gpio/gpiolib.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpio/gpiolib.c +1 -1
index f77f919dbad9..f8d53ebbf25b 100644
@@ -719,7 +719,7 @@ static int gpiochip_setup_dev(struct gpio_device *gdev)
 		goto err_remove_device;
 
 	dev_dbg(&gdev->dev, "registered GPIOs %d to %d on %s\n", gdev->base,
-		gdev->base + gdev->ngpio - 1, gdev->chip->label ? : "generic");
+		gdev->base + gdev->ngpio - 1, gdev->label);
 
 	return 0;
 
Signature · 1 line
2.40.1
#31 lore raw

PATCH v2 17/23 gpio: reduce the functionality of validate_desc()

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Checking desc->gdev->chip for NULL without holding it in place with some serializing mechanism is pointless. Remove this check. Also don't check desc->gdev for NULL as it can never happen. We'll be protecting gdev->chip with SRCU soon but we will provide a dedicated, automatic class for that.

---
 drivers/gpio/gpiolib.c | 18 +++---------------
 1 file changed, 3 insertions(+), 15 deletions(-)
drivers/gpio/gpiolib.c +3 -15
index f8d53ebbf25b..7d897c807e95 100644
@@ -2251,19 +2251,12 @@ static int validate_desc(const struct gpio_desc *desc, const char *func)
 {
 	if (!desc)
 		return 0;
+
 	if (IS_ERR(desc)) {
 		pr_warn("%s: invalid GPIO (errorpointer)\n", func);
 		return PTR_ERR(desc);
 	}
-	if (!desc->gdev) {
-		pr_warn("%s: invalid GPIO (no device)\n", func);
-		return -EINVAL;
-	}
-	if (!desc->gdev->chip) {
-		dev_warn(&desc->gdev->dev,
-			 "%s: backing chip is gone\n", func);
-		return 0;
-	}
+
 	return 1;
 }
 
@@ -2339,12 +2332,7 @@ static bool gpiod_free_commit(struct gpio_desc *desc)
 
 void gpiod_free(struct gpio_desc *desc)
 {
-	/*
-	 * We must not use VALIDATE_DESC_VOID() as the underlying gdev->chip
-	 * may already be NULL but we still want to put the references.
-	 */
-	if (!desc)
-		return;
+	VALIDATE_DESC_VOID(desc);
 
 	if (!gpiod_free_commit(desc))
 		WARN_ON(1);
Signature · 1 line
2.40.1
#32 lore raw

Re: [PATCH v2 17/23] gpio: reduce the functionality of validate_desc()

Quoted 7 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Checking desc->gdev->chip for NULL without holding it in place with some serializing mechanism is pointless. Remove this check. Also don't check desc->gdev for NULL as it can never happen. We'll be protecting gdev->chip with SRCU soon but we will provide a dedicated, automatic class for that.

...

drivers/gpio/gpiolib.c static bool gpiod_free_commit(struct gpio_desc *desc) · line 2335

Quoted 9 lines

void gpiod_free(struct gpio_desc *desc)
{

drivers/gpio/gpiolib.c +1 -6
-	/*
-	 * We must not use VALIDATE_DESC_VOID() as the underlying gdev->chip
-	 * may already be NULL but we still want to put the references.
-	 */
-	if (!desc)
-		return;
+	VALIDATE_DESC_VOID(desc);

IIRC we (used to) have two cases like this (you added one in some code like last year).

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

Re: [PATCH v2 17/23] gpio: reduce the functionality of validate_desc()

Quoted 22 lines · Andy Shevchenko
Quoted 7 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Checking desc->gdev->chip for NULL without holding it in place with some serializing mechanism is pointless. Remove this check. Also don't check desc->gdev for NULL as it can never happen. We'll be protecting gdev->chip with SRCU soon but we will provide a dedicated, automatic class for that.

...

drivers/gpio/gpiolib.c static bool gpiod_free_commit(struct gpio_desc *desc) · line 2335

Quoted 9 lines

void gpiod_free(struct gpio_desc *desc)
{

drivers/gpio/gpiolib.c +1 -6
-     /*
-      * We must not use VALIDATE_DESC_VOID() as the underlying gdev->chip
-      * may already be NULL but we still want to put the references.
-      */
-     if (!desc)
-             return;
+     VALIDATE_DESC_VOID(desc);
Quoted 3 lines

IIRC we (used to) have two cases like this (you added one in some code like last year).

None of the consumer-facing functions does it anymore. Not sure about this, maybe it was removed earlier.

Bart

#34 lore raw

Re: [PATCH v2 17/23] gpio: reduce the functionality of validate_desc()

Quoted 3 lines · Bartosz Golaszewski
Quoted 1 line · Andy Shevchenko

On Mon, Feb 05, 2024 at 10:34:12AM +0100, Bartosz Golaszewski wrote:

...

Quoted 10 lines
Quoted 10 lines
Quoted 9 lines

void gpiod_free(struct gpio_desc *desc)
{

drivers/gpio/gpiolib.c +1 -6
-     /*
-      * We must not use VALIDATE_DESC_VOID() as the underlying gdev->chip
-      * may already be NULL but we still want to put the references.
-      */
-     if (!desc)
-             return;
+     VALIDATE_DESC_VOID(desc);
Quoted 6 lines
Quoted 3 lines

IIRC we (used to) have two cases like this (you added one in some code like last year).

None of the consumer-facing functions does it anymore. Not sure about this, maybe it was removed earlier.

Okay, the only place that might be considered is gpiod_to_gpio_device().

But that API seems new, I don't know if VALIDATE_DESC_VOID() is okay to use there, maybe it should be commented if not. Also there is a typo in the kernel doc — 'the users already holds' --> 'the user already holds'.

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

PATCH v2 18/23 gpio: remove unnecessary checks from gpiod_to_chip()

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

We don't need to check the gdev pointer in struct gpio_desc - it's always assigned and never cleared. It's also pointless to check gdev->chip before we actually serialize access to it.

---
 drivers/gpio/gpiolib.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpio/gpiolib.c +2 -2
index 7d897c807e95..95b480f01fca 100644
@@ -214,7 +214,7 @@ EXPORT_SYMBOL_GPL(desc_to_gpio);
  */
 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
 {
-	if (!desc || !desc->gdev)
+	if (!desc)
 		return NULL;
 	return desc->gdev->chip;
 }
@@ -3499,7 +3499,7 @@ int gpiod_to_irq(const struct gpio_desc *desc)
 	 * requires this function to not return zero on an invalid descriptor
 	 * but rather a negative error number.
 	 */
-	if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
+	if (!desc || IS_ERR(desc))
 		return -EINVAL;
 
 	gc = desc->gdev->chip;
Signature · 1 line
2.40.1
#36 lore raw

PATCH v2 19/23 gpio: add the can_sleep flag to struct gpio_device

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Duplicating the can_sleep value in GPIO device will allow us to not needlessly dereference the chip pointer in several places and reduce the number of SRCU read-only critical sections.

---
 drivers/gpio/gpiolib.c | 11 ++++++-----
 drivers/gpio/gpiolib.h |  3 +++
 2 files changed, 9 insertions(+), 5 deletions(-)
drivers/gpio/gpiolib.c +6 -5
index 95b480f01fca..2f78fa9f8dbf 100644
@@ -896,6 +896,7 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 	}
 
 	gdev->ngpio = gc->ngpio;
+	gdev->can_sleep = gc->can_sleep;
 
 	scoped_guard(mutex, &gpio_devices_lock) {
 		/*
@@ -3066,7 +3067,7 @@ int gpiod_get_raw_value(const struct gpio_desc *desc)
 {
 	VALIDATE_DESC(desc);
 	/* Should be using gpiod_get_raw_value_cansleep() */
-	WARN_ON(desc->gdev->chip->can_sleep);
+	WARN_ON(desc->gdev->can_sleep);
 	return gpiod_get_raw_value_commit(desc);
 }
 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
@@ -3087,7 +3088,7 @@ int gpiod_get_value(const struct gpio_desc *desc)
 
 	VALIDATE_DESC(desc);
 	/* Should be using gpiod_get_value_cansleep() */
-	WARN_ON(desc->gdev->chip->can_sleep);
+	WARN_ON(desc->gdev->can_sleep);
 
 	value = gpiod_get_raw_value_commit(desc);
 	if (value < 0)
@@ -3360,7 +3361,7 @@ void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 {
 	VALIDATE_DESC_VOID(desc);
 	/* Should be using gpiod_set_raw_value_cansleep() */
-	WARN_ON(desc->gdev->chip->can_sleep);
+	WARN_ON(desc->gdev->can_sleep);
 	gpiod_set_raw_value_commit(desc, value);
 }
 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
@@ -3401,7 +3402,7 @@ void gpiod_set_value(struct gpio_desc *desc, int value)
 {
 	VALIDATE_DESC_VOID(desc);
 	/* Should be using gpiod_set_value_cansleep() */
-	WARN_ON(desc->gdev->chip->can_sleep);
+	WARN_ON(desc->gdev->can_sleep);
 	gpiod_set_value_nocheck(desc, value);
 }
 EXPORT_SYMBOL_GPL(gpiod_set_value);
@@ -3465,7 +3466,7 @@ EXPORT_SYMBOL_GPL(gpiod_set_array_value);
 int gpiod_cansleep(const struct gpio_desc *desc)
 {
 	VALIDATE_DESC(desc);
-	return desc->gdev->chip->can_sleep;
+	return desc->gdev->can_sleep;
 }
 EXPORT_SYMBOL_GPL(gpiod_cansleep);
 
drivers/gpio/gpiolib.h +3 -0
index 9b7afe87f1bd..43ff4931e2c3 100644
@@ -34,6 +34,8 @@
  * @descs: array of ngpio descriptors.
  * @ngpio: the number of GPIO lines on this GPIO device, equal to the size
  * of the @descs array.
+ * @can_sleep: indicate whether the GPIO chip driver's callbacks can sleep
+ * implying that they cannot be used from atomic context
  * @base: GPIO base in the DEPRECATED global Linux GPIO numberspace, assigned
  * at device creation time.
  * @label: a descriptive name for the GPIO device, such as the part number
@@ -64,6 +66,7 @@ struct gpio_device {
 	struct gpio_desc	*descs;
 	int			base;
 	u16			ngpio;
+	bool			can_sleep;
 	const char		*label;
 	void			*data;
 	struct list_head        list;
Signature · 1 line
2.40.1
#37 lore raw

PATCH v2 20/23 gpio: add SRCU infrastructure to struct gpio_device

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Add the SRCU struct to GPIO device. It will be used to serialize access to the GPIO chip pointer. Initialize and clean it up where applicable.

---
 drivers/gpio/gpiolib.c | 13 ++++++++++---
 drivers/gpio/gpiolib.h |  2 ++
 2 files changed, 12 insertions(+), 3 deletions(-)
drivers/gpio/gpiolib.c +10 -3
index 2f78fa9f8dbf..c49d7a156bdd 100644
@@ -680,6 +680,7 @@ static void gpiodev_release(struct device *dev)
 	ida_free(&gpio_ida, gdev->id);
 	kfree_const(gdev->label);
 	kfree(gdev->descs);
+	cleanup_srcu_struct(&gdev->srcu);
 	kfree(gdev);
 }
 
@@ -943,6 +944,10 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 	BLOCKING_INIT_NOTIFIER_HEAD(&gdev->device_notifier);
 	init_rwsem(&gdev->sem);
 
+	ret = init_srcu_struct(&gdev->srcu);
+	if (ret)
+		goto err_remove_from_list;
+
 #ifdef CONFIG_PINCTRL
 	INIT_LIST_HEAD(&gdev->pin_ranges);
 #endif
@@ -950,15 +955,15 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 	if (gc->names) {
 		ret = gpiochip_set_desc_names(gc);
 		if (ret)
-			goto err_remove_from_list;
+			goto err_cleanup_gdev_srcu;
 	}
 	ret = gpiochip_set_names(gc);
 	if (ret)
-		goto err_remove_from_list;
+		goto err_cleanup_gdev_srcu;
 
 	ret = gpiochip_init_valid_mask(gc);
 	if (ret)
-		goto err_remove_from_list;
+		goto err_cleanup_gdev_srcu;
 
 	ret = of_gpiochip_add(gc);
 	if (ret)
@@ -1038,6 +1043,8 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 		gpio_device_put(gdev);
 		goto err_print_message;
 	}
+err_cleanup_gdev_srcu:
+	cleanup_srcu_struct(&gdev->srcu);
 err_remove_from_list:
 	scoped_guard(mutex, &gpio_devices_lock)
 		list_del_rcu(&gdev->list);
drivers/gpio/gpiolib.h +2 -0
index 43ff4931e2c3..35d71e30c546 100644
@@ -49,6 +49,7 @@
  * @sem: protects the structure from a NULL-pointer dereference of @chip by
  *       user-space operations when the device gets unregistered during
  *       a hot-unplug event
+ * @srcu: protects the pointer to the underlying GPIO chip
  * @pin_ranges: range of pins served by the GPIO driver
  *
  * This state container holds most of the runtime variable data
@@ -73,6 +74,7 @@ struct gpio_device {
 	struct blocking_notifier_head line_state_notifier;
 	struct blocking_notifier_head device_notifier;
 	struct rw_semaphore	sem;
+	struct srcu_struct	srcu;
 
 #ifdef CONFIG_PINCTRL
 	/*
Signature · 1 line
2.40.1
#38 lore raw

PATCH v2 21/23 gpio: protect the pointer to gpio_chip in gpio_device with SRCU

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Ensure we cannot crash if the GPIO device gets unregistered (and the chip pointer set to NULL) during any of the API calls.

To that end: wait for all users of gdev->chip to exit their read-only SRCU critical sections in gpiochip_remove().

For brevity: add a guard class which can be instantiated at the top of every function requiring read-only access to the chip pointer and use it in all API calls taking a GPIO descriptor as argument. In places where we only deal with the GPIO device - use regular guard() helpers and rcu_dereference() for chip access. Do the same in API calls taking a const pointer to gpio_desc.

---
 drivers/gpio/gpiolib-cdev.c  |  63 +++++----
 drivers/gpio/gpiolib-sysfs.c |  90 +++++++++---
 drivers/gpio/gpiolib.c       | 257 +++++++++++++++++++++++------------
 drivers/gpio/gpiolib.h       |  22 ++-
 4 files changed, 298 insertions(+), 134 deletions(-)
drivers/gpio/gpiolib-cdev.c +36 -27
index e993c6a7215a..ccdeed013f6b 100644
@@ -205,9 +205,9 @@ static long linehandle_ioctl(struct file *file, unsigned int cmd,
 	unsigned int i;
 	int ret;
 
-	guard(rwsem_read)(&lh->gdev->sem);
+	guard(srcu)(&lh->gdev->srcu);
 
-	if (!lh->gdev->chip)
+	if (!rcu_dereference(lh->gdev->chip))
 		return -ENODEV;
 
 	switch (cmd) {
@@ -1520,9 +1520,9 @@ static long linereq_ioctl(struct file *file, unsigned int cmd,
 	struct linereq *lr = file->private_data;
 	void __user *ip = (void __user *)arg;
 
-	guard(rwsem_read)(&lr->gdev->sem);
+	guard(srcu)(&lr->gdev->srcu);
 
-	if (!lr->gdev->chip)
+	if (!rcu_dereference(lr->gdev->chip))
 		return -ENODEV;
 
 	switch (cmd) {
@@ -1551,9 +1551,9 @@ static __poll_t linereq_poll(struct file *file,
 	struct linereq *lr = file->private_data;
 	__poll_t events = 0;
 
-	guard(rwsem_read)(&lr->gdev->sem);
+	guard(srcu)(&lr->gdev->srcu);
 
-	if (!lr->gdev->chip)
+	if (!rcu_dereference(lr->gdev->chip))
 		return EPOLLHUP | EPOLLERR;
 
 	poll_wait(file, &lr->wait, wait);
@@ -1573,9 +1573,9 @@ static ssize_t linereq_read(struct file *file, char __user *buf,
 	ssize_t bytes_read = 0;
 	int ret;
 
-	guard(rwsem_read)(&lr->gdev->sem);
+	guard(srcu)(&lr->gdev->srcu);
 
-	if (!lr->gdev->chip)
+	if (!rcu_dereference(lr->gdev->chip))
 		return -ENODEV;
 
 	if (count < sizeof(le))
@@ -1874,9 +1874,9 @@ static __poll_t lineevent_poll(struct file *file,
 	struct lineevent_state *le = file->private_data;
 	__poll_t events = 0;
 
-	guard(rwsem_read)(&le->gdev->sem);
+	guard(srcu)(&le->gdev->srcu);
 
-	if (!le->gdev->chip)
+	if (!rcu_dereference(le->gdev->chip))
 		return EPOLLHUP | EPOLLERR;
 
 	poll_wait(file, &le->wait, wait);
@@ -1912,9 +1912,9 @@ static ssize_t lineevent_read(struct file *file, char __user *buf,
 	ssize_t ge_size;
 	int ret;
 
-	guard(rwsem_read)(&le->gdev->sem);
+	guard(srcu)(&le->gdev->srcu);
 
-	if (!le->gdev->chip)
+	if (!rcu_dereference(le->gdev->chip))
 		return -ENODEV;
 
 	/*
@@ -1995,9 +1995,9 @@ static long lineevent_ioctl(struct file *file, unsigned int cmd,
 	void __user *ip = (void __user *)arg;
 	struct gpiohandle_data ghd;
 
-	guard(rwsem_read)(&le->gdev->sem);
+	guard(srcu)(&le->gdev->srcu);
 
-	if (!le->gdev->chip)
+	if (!rcu_dereference(le->gdev->chip))
 		return -ENODEV;
 
 	/*
@@ -2295,10 +2295,13 @@ static void gpio_v2_line_info_changed_to_v1(
 static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
 				  struct gpio_v2_line_info *info)
 {
-	struct gpio_chip *gc = desc->gdev->chip;
 	unsigned long dflags;
 	const char *label;
 
+	CLASS(gpio_chip_guard, guard)(desc);
+	if (!guard.gc)
+		return;
+
 	memset(info, 0, sizeof(*info));
 	info->offset = gpio_chip_hwgpio(desc);
 
@@ -2331,8 +2334,8 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
 	    test_bit(FLAG_USED_AS_IRQ, &dflags) ||
 	    test_bit(FLAG_EXPORT, &dflags) ||
 	    test_bit(FLAG_SYSFS, &dflags) ||
-	    !gpiochip_line_is_valid(gc, info->offset) ||
-	    !pinctrl_gpio_can_use_line(gc, info->offset))
+	    !gpiochip_line_is_valid(guard.gc, info->offset) ||
+	    !pinctrl_gpio_can_use_line(guard.gc, info->offset))
 		info->flags |= GPIO_V2_LINE_FLAG_USED;
 
 	if (test_bit(FLAG_IS_OUT, &dflags))
@@ -2505,10 +2508,10 @@ static long gpio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 	struct gpio_device *gdev = cdev->gdev;
 	void __user *ip = (void __user *)arg;
 
-	guard(rwsem_read)(&gdev->sem);
+	guard(srcu)(&gdev->srcu);
 
 	/* We fail any subsequent ioctl():s when the chip is gone */
-	if (!gdev->chip)
+	if (!rcu_dereference(gdev->chip))
 		return -ENODEV;
 
 	/* Fill in the struct and pass to userspace */
@@ -2591,9 +2594,9 @@ static __poll_t lineinfo_watch_poll(struct file *file,
 	struct gpio_chardev_data *cdev = file->private_data;
 	__poll_t events = 0;
 
-	guard(rwsem_read)(&cdev->gdev->sem);
+	guard(srcu)(&cdev->gdev->srcu);
 
-	if (!cdev->gdev->chip)
+	if (!rcu_dereference(cdev->gdev->chip))
 		return EPOLLHUP | EPOLLERR;
 
 	poll_wait(file, &cdev->wait, pollt);
@@ -2614,9 +2617,9 @@ static ssize_t lineinfo_watch_read(struct file *file, char __user *buf,
 	int ret;
 	size_t event_size;
 
-	guard(rwsem_read)(&cdev->gdev->sem);
+	guard(srcu)(&cdev->gdev->srcu);
 
-	if (!cdev->gdev->chip)
+	if (!rcu_dereference(cdev->gdev->chip))
 		return -ENODEV;
 
 #ifndef CONFIG_GPIO_CDEV_V1
@@ -2691,10 +2694,10 @@ static int gpio_chrdev_open(struct inode *inode, struct file *file)
 	struct gpio_chardev_data *cdev;
 	int ret = -ENOMEM;
 
-	guard(rwsem_read)(&gdev->sem);
+	guard(srcu)(&gdev->srcu);
 
 	/* Fail on open if the backing gpiochip is gone */
-	if (!gdev->chip)
+	if (!rcu_dereference(gdev->chip))
 		return -ENODEV;
 
 	cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
@@ -2781,6 +2784,7 @@ static const struct file_operations gpio_fileops = {
 
 int gpiolib_cdev_register(struct gpio_device *gdev, dev_t devt)
 {
+	struct gpio_chip *gc;
 	int ret;
 
 	cdev_init(&gdev->chrdev, &gpio_fileops);
@@ -2791,8 +2795,13 @@ int gpiolib_cdev_register(struct gpio_device *gdev, dev_t devt)
 	if (ret)
 		return ret;
 
-	chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
-		 MAJOR(devt), gdev->id);
+	guard(srcu)(&gdev->srcu);
+
+	gc = rcu_dereference(gdev->chip);
+	if (!gc)
+		return -ENODEV;
+
+	chip_dbg(gc, "added GPIO chardev (%d:%d)\n", MAJOR(devt), gdev->id);
 
 	return 0;
 }
drivers/gpio/gpiolib-sysfs.c +68 -22

209 lines not on this page · raw message

drivers/gpio/gpiolib.c +173 -84

591 lines not on this page · raw message

drivers/gpio/gpiolib.h +21 -1
index 35d71e30c546..b3810f7d286a 100644
@@ -63,7 +63,7 @@ struct gpio_device {
 	int			id;
 	struct device		*mockdev;
 	struct module		*owner;
-	struct gpio_chip	*chip;
+	struct gpio_chip __rcu	*chip;
 	struct gpio_desc	*descs;
 	int			base;
 	u16			ngpio;
@@ -193,6 +193,26 @@ struct gpio_desc {
 
 #define gpiod_not_found(desc)		(IS_ERR(desc) && PTR_ERR(desc) == -ENOENT)
 
+struct gpio_chip_guard {
+	struct gpio_device *gdev;
+	struct gpio_chip *gc;
+	int idx;
+};
+
+DEFINE_CLASS(gpio_chip_guard,
+	     struct gpio_chip_guard,
+	     srcu_read_unlock(&_T.gdev->srcu, _T.idx),
+	     ({
+		struct gpio_chip_guard _guard;
+
+		_guard.gdev = desc->gdev;
+		_guard.idx = srcu_read_lock(&_guard.gdev->srcu);
+		_guard.gc = rcu_dereference(_guard.gdev->chip);
+
+		_guard;
+	     }),
+	     struct gpio_desc *desc)
+
 int gpiod_request(struct gpio_desc *desc, const char *label);
 void gpiod_free(struct gpio_desc *desc);
 
Signature · 1 line
2.40.1
#39 lore raw

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

Quoted 14 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Ensure we cannot crash if the GPIO device gets unregistered (and the chip pointer set to NULL) during any of the API calls.

To that end: wait for all users of gdev->chip to exit their read-only SRCU critical sections in gpiochip_remove().

For brevity: add a guard class which can be instantiated at the top of every function requiring read-only access to the chip pointer and use it in all API calls taking a GPIO descriptor as argument. In places where we only deal with the GPIO device - use regular guard() helpers and rcu_dereference() for chip access. Do the same in API calls taking a const pointer to gpio_desc.

...

Quoted 5 lines

static ssize_t base_show(struct device *dev,

drivers/gpio/gpiolib-sysfs.c +1 -1
 			       struct device_attribute *attr, char *buf)
 {
-	const struct gpio_device *gdev = dev_get_drvdata(dev);
+	struct gpio_device *gdev = dev_get_drvdata(dev);

drivers/gpio/gpiolib-sysfs.c static const struct attribute_group *gpio_groups[] = { · line 421

Quoted 10 lines
drivers/gpio/gpiolib-sysfs.c +8 -1
+	struct gpio_chip *gc;
 
-	return sysfs_emit(buf, "%d\n", gdev->chip->base);
+	guard(srcu)(&gdev->srcu);
+
+	gc = rcu_dereference(gdev->chip);
+	if (!gc)
+		return -ENODEV;
+
+	return sysfs_emit(buf, "%d\n", gc->base);

Similar Q as below.

Quoted 1 line

}

...

Quoted 5 lines

static ssize_t label_show(struct device *dev,

drivers/gpio/gpiolib-sysfs.c +1 -1
 			       struct device_attribute *attr, char *buf)
 {
-	const struct gpio_device *gdev = dev_get_drvdata(dev);
+	struct gpio_device *gdev = dev_get_drvdata(dev);

drivers/gpio/gpiolib-sysfs.c static const struct attribute_group *gpio_groups[] = { · line 437

Quoted 10 lines
drivers/gpio/gpiolib-sysfs.c +8 -1
+	struct gpio_chip *gc;
 
-	return sysfs_emit(buf, "%s\n", gdev->chip->label ?: "");
+	guard(srcu)(&gdev->srcu);
+
+	gc = rcu_dereference(gdev->chip);
+	if (!gc)
+		return -ENODEV;
+
+	return sysfs_emit(buf, "%s\n", gc->label ?: "");

Why do you need gc label here and not gdev? In other code you switched over (in a patch before this in the series).

Quoted 7 lines

}

static ssize_t ngpio_show(struct device *dev,

drivers/gpio/gpiolib-sysfs.c +1 -1
 			       struct device_attribute *attr, char *buf)
 {
-	const struct gpio_device *gdev = dev_get_drvdata(dev);
+	struct gpio_device *gdev = dev_get_drvdata(dev);

drivers/gpio/gpiolib-sysfs.c static const struct attribute_group *gpio_groups[] = { · line 453

Quoted 10 lines
drivers/gpio/gpiolib-sysfs.c +8 -1
+	struct gpio_chip *gc;
 
-	return sysfs_emit(buf, "%u\n", gdev->chip->ngpio);
+	guard(srcu)(&gdev->srcu);
+
+	gc = rcu_dereference(gdev->chip);
+	if (!gc)
+		return -ENODEV;
+
+	return sysfs_emit(buf, "%u\n", gc->ngpio);

Ditto.

Quoted 1 line

}

...

drivers/gpio/gpiolib.c static int gpiochip_find_base_unlocked(int ngpio) · line 334

Quoted 11 lines

int gpiod_get_direction(struct gpio_desc *desc)
{

drivers/gpio/gpiolib.c +3 -2
-	struct gpio_chip *gc;
 	unsigned long flags;
 	unsigned int offset;
 	int ret;
 
-	gc = gpiod_to_chip(desc);
+	if (!desc)
+		/* Sane default is INPUT. */
+		return 1;

Hmm... I can't imagine how this value may anyhow be used / useful.

drivers/gpio/gpiolib.c static int gpiochip_find_base_unlocked(int ngpio) · line 337

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+	if (IS_ERR(desc))
+		return -EINVAL;

With above said, can't we use one of VALIDATE_DESC*() macro here?

...

drivers/gpio/gpiolib.c struct gpio_device *gpio_device_find(void *data, · line 1182

Quoted 5 lines
drivers/gpio/gpiolib.c +2 -0
 	list_for_each_entry_srcu(gdev, &gpio_devices, list,
 				 srcu_read_lock_held(&gpio_devices_srcu)) {
 
+	list_for_each_entry_srcu(gdev, &gpio_devices, list,
+				 srcu_read_lock_held(&gpio_devices_srcu)) {

Seems like a candidate for

#define gpio_for_each_device(...) ...

...

drivers/gpio/gpiolib.c EXPORT_SYMBOL_GPL(gpiod_direction_output); · line 2801

Quoted 7 lines
drivers/gpio/gpiolib.c +3 -2
 	VALIDATE_DESC(desc);
 
-	gc = desc->gdev->chip;
-	if (!gc->en_hw_timestamp) {
+	CLASS(gpio_chip_guard, guard)(desc);
+	if (!guard.gc)
+		return -ENODEV;

Not sure if it would be good to have a respective VALIDATE_DESC_GUARDED() or so. At least it may deduplicate a few cases.

...

drivers/gpio/gpiolib.c int gpiod_to_irq(const struct gpio_desc *desc) · line 3586

Quoted 1 line
drivers/gpio/gpiolib.c +1 -0
+	/* FIXME Cannot use gpio_chip_guard due to const desc. */

gpio_chip_guard()

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

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

Quoted 48 lines · Andy Shevchenko
Quoted 14 lines · Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

Ensure we cannot crash if the GPIO device gets unregistered (and the chip pointer set to NULL) during any of the API calls.

To that end: wait for all users of gdev->chip to exit their read-only SRCU critical sections in gpiochip_remove().

For brevity: add a guard class which can be instantiated at the top of every function requiring read-only access to the chip pointer and use it in all API calls taking a GPIO descriptor as argument. In places where we only deal with the GPIO device - use regular guard() helpers and rcu_dereference() for chip access. Do the same in API calls taking a const pointer to gpio_desc.

...

Quoted 5 lines

static ssize_t base_show(struct device *dev,
struct device_attribute *attr, char *buf)
{

drivers/gpio/gpiolib-sysfs.c +1 -1
-     const struct gpio_device *gdev = dev_get_drvdata(dev);
+     struct gpio_device *gdev = dev_get_drvdata(dev);

drivers/gpio/gpiolib-sysfs.c static const struct attribute_group *gpio_groups[] = { · line 421

Quoted 10 lines
drivers/gpio/gpiolib-sysfs.c +8 -1
+     struct gpio_chip *gc;
 
-     return sysfs_emit(buf, "%d\n", gdev->chip->base);
+     guard(srcu)(&gdev->srcu);
+
+     gc = rcu_dereference(gdev->chip);
+     if (!gc)
+             return -ENODEV;
+
+     return sysfs_emit(buf, "%d\n", gc->base);

Similar Q as below.

Quoted 1 line

}

...

Quoted 7 lines

static ssize_t label_show(struct device *dev,
struct device_attribute *attr, char *buf)
{

drivers/gpio/gpiolib-sysfs.c +2 -1
-     const struct gpio_device *gdev = dev_get_drvdata(dev);
+     struct gpio_device *gdev = dev_get_drvdata(dev);
+     struct gpio_chip *gc;
Quoted 12 lines

drivers/gpio/gpiolib-sysfs.c static const struct attribute_group *gpio_groups[] = { · line 437

Quoted 8 lines
drivers/gpio/gpiolib-sysfs.c +7 -1
-     return sysfs_emit(buf, "%s\n", gdev->chip->label ?: "");
+     guard(srcu)(&gdev->srcu);
+
+     gc = rcu_dereference(gdev->chip);
+     if (!gc)
+             return -ENODEV;
+
+     return sysfs_emit(buf, "%s\n", gc->label ?: "");

Why do you need gc label here and not gdev? In other code you switched over (in a patch before this in the series).

Yeah, good point.

Quoted 36 lines
Quoted 7 lines

}

static ssize_t ngpio_show(struct device *dev,
struct device_attribute *attr, char *buf)
{

drivers/gpio/gpiolib-sysfs.c +1 -1
-     const struct gpio_device *gdev = dev_get_drvdata(dev);
+     struct gpio_device *gdev = dev_get_drvdata(dev);

drivers/gpio/gpiolib-sysfs.c static const struct attribute_group *gpio_groups[] = { · line 453

Quoted 10 lines
drivers/gpio/gpiolib-sysfs.c +8 -1
+     struct gpio_chip *gc;
 
-     return sysfs_emit(buf, "%u\n", gdev->chip->ngpio);
+     guard(srcu)(&gdev->srcu);
+
+     gc = rcu_dereference(gdev->chip);
+     if (!gc)
+             return -ENODEV;
+
+     return sysfs_emit(buf, "%u\n", gc->ngpio);

Ditto.

Quoted 1 line

}

...

drivers/gpio/gpiolib.c static int gpiochip_find_base_unlocked(int ngpio) · line 334

Quoted 11 lines

int gpiod_get_direction(struct gpio_desc *desc)
{

drivers/gpio/gpiolib.c +3 -2
-     struct gpio_chip *gc;
      unsigned long flags;
      unsigned int offset;
      int ret;
 
-     gc = gpiod_to_chip(desc);
+     if (!desc)
+             /* Sane default is INPUT. */
+             return 1;
Quoted 7 lines

Hmm... I can't imagine how this value may anyhow be used / useful.

drivers/gpio/gpiolib.c static int gpiochip_find_base_unlocked(int ngpio) · line 337

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+     if (IS_ERR(desc))
+             return -EINVAL;

With above said, can't we use one of VALIDATE_DESC*() macro here?

Possibly.

Quoted 23 lines

...

drivers/gpio/gpiolib.c struct gpio_device *gpio_device_find(void *data, · line 1182

Quoted 5 lines

list_for_each_entry_srcu(gdev, &gpio_devices, list,
srcu_read_lock_held(&gpio_devices_srcu)) {

drivers/gpio/gpiolib.c +2 -0
+     list_for_each_entry_srcu(gdev, &gpio_devices, list,
+                              srcu_read_lock_held(&gpio_devices_srcu)) {

Seems like a candidate for

#define gpio_for_each_device(...) ...

...

drivers/gpio/gpiolib.c EXPORT_SYMBOL_GPL(gpiod_direction_output); · line 2801

Quoted 7 lines
      VALIDATE_DESC(desc);
drivers/gpio/gpiolib.c +3 -2
-     gc = desc->gdev->chip;
-     if (!gc->en_hw_timestamp) {
+     CLASS(gpio_chip_guard, guard)(desc);
+     if (!guard.gc)
+             return -ENODEV;
Quoted 3 lines

Not sure if it would be good to have a respective VALIDATE_DESC_GUARDED() or so. At least it may deduplicate a few cases.

We could of course do it like this:

VALIDATE_DESC_GUARDED(desc, guard) where guard would be the name of the guard variable but I generally dislike macros with flow-control statements and I think this would just go too far. In fact: I'd gladly get rid of VALIDATE_DESC() and co. altogether.

Bart

Quoted 11 lines

...

Quoted 1 line

+ /* FIXME Cannot use gpio_chip_guard due to const desc. */

gpio_chip_guard()

--
With Best Regards,
Andy Shevchenko

#41 lore raw

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

In reply to Andy Shevchenko
Quoted 1 line · Andy Shevchenko

[snip]

Quoted 5 lines
Quoted 2 lines

+ /* FIXME Cannot use gpio_chip_guard due to const desc. */

gpio_chip_guard()

Nope, it's the name of the class type, not a function.

Bart

#42 lore raw

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

In reply to Andy Shevchenko
Quoted 1 line · Andy Shevchenko

[snip]

Quoted 8 lines
Quoted 8 lines

int gpiod_get_direction(struct gpio_desc *desc)
{

-     struct gpio_chip *gc;
      unsigned long flags;
      unsigned int offset;
      int ret;
Quoted 7 lines

drivers/gpio/gpiolib.c static int gpiochip_find_base_unlocked(int ngpio) · line 334

Quoted 4 lines
drivers/gpio/gpiolib.c +3 -1
-     gc = gpiod_to_chip(desc);
+     if (!desc)
+             /* Sane default is INPUT. */
+             return 1;

Hmm... I can't imagine how this value may anyhow be used / useful.

What else would you return for an optional (NULL) GPIO?

Bart

[snip]

#43 lore raw

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

Quoted 2 lines · Bartosz Golaszewski

On Mon, Feb 5, 2024 at 1:31 PM Andy Shevchenko
<[email protected]> wrote:

...

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

int gpiod_get_direction(struct gpio_desc *desc)
{

-     struct gpio_chip *gc;
      unsigned long flags;
      unsigned int offset;
      int ret;
Quoted 8 lines
Quoted 6 lines

drivers/gpio/gpiolib.c static int gpiochip_find_base_unlocked(int ngpio) · line 334

Quoted 4 lines
drivers/gpio/gpiolib.c +3 -1
-     gc = gpiod_to_chip(desc);
+     if (!desc)
+             /* Sane default is INPUT. */
+             return 1;

Hmm... I can't imagine how this value may anyhow be used / useful.

What else would you return for an optional (NULL) GPIO?

An error. If somebody asks for direction of the non-existing GPIO, there is no (valid) answer for that.

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

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

Quoted 20 lines · Andy Shevchenko
Quoted 2 lines · Bartosz Golaszewski

On Mon, Feb 5, 2024 at 1:31 PM Andy Shevchenko
<[email protected]> wrote:

...

Quoted 13 lines
Quoted 13 lines
Quoted 12 lines

int gpiod_get_direction(struct gpio_desc *desc)
{

drivers/gpio/gpiolib.c +3 -2
-     struct gpio_chip *gc;
      unsigned long flags;
      unsigned int offset;
      int ret;
 
-     gc = gpiod_to_chip(desc);
+     if (!desc)
+             /* Sane default is INPUT. */
+             return 1;
Quoted 7 lines
Quoted 3 lines
Quoted 1 line

Hmm... I can't imagine how this value may anyhow be used / useful.

What else would you return for an optional (NULL) GPIO?

An error. If somebody asks for direction of the non-existing GPIO, there is no (valid) answer for that.

All other functions return 0 for desc == NULL to accommodate gpiod_get_optional(). I think we should stay consistent here.

Bart

#45 lore raw

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

Quoted 24 lines · Bartosz Golaszewski
Quoted 22 lines · Andy Shevchenko
Quoted 2 lines · Bartosz Golaszewski

On Mon, Feb 5, 2024 at 1:31 PM Andy Shevchenko
<[email protected]> wrote:

...

Quoted 15 lines
Quoted 14 lines

drivers/gpio/gpiolib.c static int gpiochip_find_base_unlocked(int ngpio) · line 334

Quoted 12 lines

int gpiod_get_direction(struct gpio_desc *desc)
{

drivers/gpio/gpiolib.c +3 -2
-     struct gpio_chip *gc;
      unsigned long flags;
      unsigned int offset;
      int ret;
 
-     gc = gpiod_to_chip(desc);
+     if (!desc)
+             /* Sane default is INPUT. */
+             return 1;

Hmm... I can't imagine how this value may anyhow be used / useful.

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

What else would you return for an optional (NULL) GPIO?

An error. If somebody asks for direction of the non-existing GPIO, there is no (valid) answer for that.

All other functions return 0 for desc == NULL to accommodate gpiod_get_optional(). I think we should stay consistent here.

The way you proposed is inconsistent, i.e. you may not return any direction for the unknown / non-existing GPIO. You speculate it will be 1, I may consider that in my (hypothetical for now) case it should be 0.

Just don't make all bananas to be oranges. It won't work.

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

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

Quoted 31 lines · Andy Shevchenko
Quoted 28 lines · Bartosz Golaszewski
Quoted 26 lines · Andy Shevchenko
Quoted 2 lines · Bartosz Golaszewski

On Mon, Feb 5, 2024 at 1:31 PM Andy Shevchenko
<[email protected]> wrote:

...

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

int gpiod_get_direction(struct gpio_desc *desc)
{

-     struct gpio_chip *gc;
      unsigned long flags;
      unsigned int offset;
      int ret;
Quoted 8 lines
Quoted 6 lines

drivers/gpio/gpiolib.c static int gpiochip_find_base_unlocked(int ngpio) · line 334

Quoted 4 lines
drivers/gpio/gpiolib.c +3 -1
-     gc = gpiod_to_chip(desc);
+     if (!desc)
+             /* Sane default is INPUT. */
+             return 1;

Hmm... I can't imagine how this value may anyhow be used / useful.

What else would you return for an optional (NULL) GPIO?

An error. If somebody asks for direction of the non-existing GPIO, there is no (valid) answer for that.

Quoted 9 lines
Quoted 2 lines

All other functions return 0 for desc == NULL to accommodate gpiod_get_optional(). I think we should stay consistent here.

The way you proposed is inconsistent, i.e. you may not return any direction for the unknown / non-existing GPIO. You speculate it will be 1, I may consider that in my (hypothetical for now) case it should be 0.

Just don't make all bananas to be oranges. It won't work.

I don't have a strong conviction here. May make it an error as well. It's still inconsistent though - calling gpiod_direction_output(NULL); will return 0 and then you get an error when you do gpiod_get_direction(NULL). I don't have a good solution though.

Bart

#47 lore raw

Re: [PATCH v2 21/23] gpio: protect the pointer to gpio_chip in gpio_device with SRCU

Quoted 8 lines · Bartosz Golaszewski
Quoted 6 lines · Andy Shevchenko
Quoted 5 lines · Bartosz Golaszewski
Quoted 3 lines · Andy Shevchenko
Quoted 2 lines · Bartosz Golaszewski

On Mon, Feb 5, 2024 at 1:31 PM Andy Shevchenko
<[email protected]> wrote:

...

Quoted 26 lines
Quoted 26 lines
Quoted 14 lines
Quoted 14 lines
Quoted 14 lines
Quoted 13 lines

Review

Quoted 11 lines

int gpiod_get_direction(struct gpio_desc *desc)
{

(quoted diff) +3 -2
-     struct gpio_chip *gc;
      unsigned long flags;
      unsigned int offset;
      int ret;
 
-     gc = gpiod_to_chip(desc);
+     if (!desc)
+             /* Sane default is INPUT. */
+             return 1;

Hmm... I can't imagine how this value may anyhow be used / useful.

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

What else would you return for an optional (NULL) GPIO?

An error. If somebody asks for direction of the non-existing GPIO, there is no (valid) answer for that.

All other functions return 0 for desc == NULL to accommodate gpiod_get_optional(). I think we should stay consistent here.

The way you proposed is inconsistent, i.e. you may not return any direction for the unknown / non-existing GPIO. You speculate it will be 1, I may consider that in my (hypothetical for now) case it should be 0.

Quoted 6 lines
Quoted 1 line

Just don't make all bananas to be oranges. It won't work.

I don't have a strong conviction here. May make it an error as well. It's still inconsistent though - calling gpiod_direction_output(NULL); will return 0 and then you get an error when you do gpiod_get_direction(NULL). I don't have a good solution though.

Yes, and this is the best what we can have. Because the real code may rely on the returned value and they should be really aware on the returned values in some cases.

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

PATCH v2 22/23 gpio: remove the RW semaphore from the GPIO device

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

With all accesses to gdev->chip being protected with SRCU, we can now remove the RW-semaphore specific to the character device which fullfilled the same role up to this point.

---
 drivers/gpio/gpiolib-cdev.c | 1 -
 drivers/gpio/gpiolib.c      | 4 ----
 drivers/gpio/gpiolib.h      | 5 -----
 3 files changed, 10 deletions(-)
drivers/gpio/gpiolib-cdev.c +0 -1
index ccdeed013f6b..9323b357df43 100644
@@ -24,7 +24,6 @@
 #include <linux/pinctrl/consumer.h>
 #include <linux/poll.h>
 #include <linux/rbtree.h>
-#include <linux/rwsem.h>
 #include <linux/seq_file.h>
 #include <linux/spinlock.h>
 #include <linux/timekeeping.h>
drivers/gpio/gpiolib.c +0 -4
index 89e1c98b0bda..c7b039398e0d 100644
@@ -958,7 +958,6 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
 
 	BLOCKING_INIT_NOTIFIER_HEAD(&gdev->line_state_notifier);
 	BLOCKING_INIT_NOTIFIER_HEAD(&gdev->device_notifier);
-	init_rwsem(&gdev->sem);
 
 	ret = init_srcu_struct(&gdev->srcu);
 	if (ret)
@@ -1097,8 +1096,6 @@ void gpiochip_remove(struct gpio_chip *gc)
 	struct gpio_device *gdev = gc->gpiodev;
 	unsigned int i;
 
-	down_write(&gdev->sem);
-
 	/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
 	gpiochip_sysfs_unregister(gdev);
 	gpiochip_free_hogs(gc);
@@ -1136,7 +1133,6 @@ void gpiochip_remove(struct gpio_chip *gc)
 	 * gone.
 	 */
 	gcdev_unregister(gdev);
-	up_write(&gdev->sem);
 	gpio_device_put(gdev);
 }
 EXPORT_SYMBOL_GPL(gpiochip_remove);
drivers/gpio/gpiolib.h +0 -5
index b3810f7d286a..07443d26cbca 100644
@@ -16,7 +16,6 @@
 #include <linux/gpio/driver.h>
 #include <linux/module.h>
 #include <linux/notifier.h>
-#include <linux/rwsem.h>
 #include <linux/srcu.h>
 
 #define GPIOCHIP_NAME	"gpiochip"
@@ -46,9 +45,6 @@
  *                       requested, released or reconfigured
  * @device_notifier: used to notify character device wait queues about the GPIO
  *                   device being unregistered
- * @sem: protects the structure from a NULL-pointer dereference of @chip by
- *       user-space operations when the device gets unregistered during
- *       a hot-unplug event
  * @srcu: protects the pointer to the underlying GPIO chip
  * @pin_ranges: range of pins served by the GPIO driver
  *
@@ -73,7 +69,6 @@ struct gpio_device {
 	struct list_head        list;
 	struct blocking_notifier_head line_state_notifier;
 	struct blocking_notifier_head device_notifier;
-	struct rw_semaphore	sem;
 	struct srcu_struct	srcu;
 
 #ifdef CONFIG_PINCTRL
Signature · 1 line
2.40.1
#49 lore raw

PATCH v2 23/23 gpio: mark unsafe gpio_chip manipulators as deprecated

In reply to Bartosz Golaszewski

From: Bartosz Golaszewski <[email protected]>

We still have some functions that return the address of the GPIO chip associated with the GPIO device. This is dangerous and the users should find a better solution. Let's add appropriate comments to the kernel docs.

---
 drivers/gpio/gpiolib.c | 6 ++++++
 1 file changed, 6 insertions(+)
drivers/gpio/gpiolib.c +6 -0
index c7b039398e0d..dc00eeed6253 100644
@@ -211,6 +211,11 @@ EXPORT_SYMBOL_GPL(desc_to_gpio);
 /**
  * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
  * @desc:	descriptor to return the chip of
+ *
+ * *DEPRECATED*
+ * This function is unsafe and should not be used. Using the chip address
+ * without taking the SRCU read lock may result in dereferencing a dangling
+ * pointer.
  */
 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
 {
@@ -275,6 +280,7 @@ EXPORT_SYMBOL(gpio_device_get_label);
  * Returns:
  * Address of the GPIO chip backing this device.
  *
+ * *DEPRECATED*
  * Until we can get rid of all non-driver users of struct gpio_chip, we must
  * provide a way of retrieving the pointer to it from struct gpio_device. This
  * is *NOT* safe as the GPIO API is considered to be hot-unpluggable and the
Signature · 1 line
2.40.1