Skip to contentSkip to conversation

gpiolib: gpio naming in sysfs

PATCH In review Jani Nikula 9 participants 36 messages Dec 9, 2009 – Dec 23, 2009

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

cover gpiolib: gpio naming in sysfs

Hi David and Greg -

There's been debate in the past about naming gpios exported to the sysfs. Long story short, there are users for that, and there are now two ways of naming gpios in the sysfs: char **names in struct gpio_chip [1], and gpio_export_link() [2].

This patchset combines these two by allowing gpio_export_link() to have dev == NULL to make the link under gpiolib sysfs (instead of arbitrary device), and to use gpio_chip names to create links (instead of naming the actual devices with those). This gpio_export_link() with dev == NULL would also be useful for gpios not associated with a driver.

Greg, patch 1/3 introduces class_{create,remove}_link(), is that acceptable?

CC Daniel, you introduced names in struct gpio_chip in the first place, does this (especially patch 3/3) look acceptable to you?

BR,
Jani.

[1] commit 926b663ce8215ba448960e1ff6e58b67a2c3b99b
[2] commit a4177ee7f1a83eecb1d75e85d32664b023ef65e9

Artem Bityutskiy (1):
device class: add symlink creation helpers

Jani Nikula (2):
gpiolib: add support for having symlinks under gpio class directory
gpiolib: use chip->names for symlinks, always use gpioN for device
names

 drivers/base/class.c   |   21 ++++++++++
 drivers/gpio/gpiolib.c |  101 +++++++++++++++++++++++++++++++++++++++++++++---
 include/linux/device.h |    4 ++
 3 files changed, 120 insertions(+), 6 deletions(-)
#1 lore raw

PATCH 1/3 device class: add symlink creation helpers

From: Artem Bityutskiy <[email protected]>

---
 drivers/base/class.c   |   21 +++++++++++++++++++++
 include/linux/device.h |    4 ++++
 2 files changed, 25 insertions(+), 0 deletions(-)
drivers/base/class.c +21 -0
index 161746d..818cbe2 100644
@@ -92,6 +92,25 @@ void class_remove_file(struct class *cls, const struct class_attribute *attr)
 		sysfs_remove_file(&cls->p->class_subsys.kobj, &attr->attr);
 }
 
+int class_create_link(struct class *cls, struct kobject *target,
+		      const char *name)
+{
+	int error;
+
+	if (cls)
+		error = sysfs_create_link(&cls->p->class_subsys.kobj,
+					  target, name);
+	else
+		error = -EINVAL;
+	return error;
+}
+
+void class_remove_link(struct class *cls, const char *name)
+{
+	if (cls)
+		sysfs_remove_link(&cls->p->class_subsys.kobj, name);
+}
+
 static struct class *class_get(struct class *cls)
 {
 	if (cls)
@@ -585,6 +604,8 @@ int __init classes_init(void)
 
 EXPORT_SYMBOL_GPL(class_create_file);
 EXPORT_SYMBOL_GPL(class_remove_file);
+EXPORT_SYMBOL_GPL(class_create_link);
+EXPORT_SYMBOL_GPL(class_remove_link);
 EXPORT_SYMBOL_GPL(class_unregister);
 EXPORT_SYMBOL_GPL(class_destroy);
 
include/linux/device.h +4 -0
index 2ea3e49..e877be6 100644
@@ -262,6 +262,10 @@ extern int __must_check class_create_file(struct class *class,
 					  const struct class_attribute *attr);
 extern void class_remove_file(struct class *class,
 			      const struct class_attribute *attr);
+extern int __must_check class_create_link(struct class *class,
+					  struct kobject *target,
+					  const char *name);
+extern void class_remove_link(struct class *class, const char *name);
 
 struct class_interface {
 	struct list_head	node;
Signature · 1 line
1.6.5.2
#2 lore raw

PATCH 2/3 gpiolib: add support for having symlinks under gpio class directory

Extend the functionality of gpio_export_link() to allow exported GPIOs to have names using sysfs links under /sys/class/gpio.

Also automatically remove links on gpio_unexport().

---
 drivers/gpio/gpiolib.c |   95 +++++++++++++++++++++++++++++++++++++++++++++---
 1 files changed, 90 insertions(+), 5 deletions(-)
drivers/gpio/gpiolib.c +90 -5
index 50de0f5..f254195 100644
@@ -9,6 +9,8 @@
 #include <linux/seq_file.h>
 #include <linux/gpio.h>
 #include <linux/idr.h>
+#include <linux/list.h>
+#include "../base/base.h"
 
 
 /* Optional implementation infrastructure for GPIO interfaces.
@@ -608,6 +610,84 @@ static struct class gpio_class = {
 	.class_attrs =	gpio_class_attrs,
 };
 
+/* sysfs link */
+struct sysfs_link {
+	unsigned gpio;
+	struct device *dev;
+	const char *name;
+	struct list_head node;
+};
+
+/* list of links to gpio sysfs nodes, protected by sysfs_mutex */
+static LIST_HEAD(sysfs_links);
+
+/* create link, store info */
+static int create_link(unsigned gpio, struct device *dev,
+		struct kobject *target, const char *name)
+{
+	struct sysfs_link	*link;
+	int			status = -ENOMEM;
+
+	link = kzalloc(sizeof(*link), GFP_KERNEL);
+	if (link == NULL)
+		goto err0;
+
+	link->name = kstrdup(name, GFP_KERNEL);
+	if (link->name == NULL)
+		goto err1;
+
+	link->gpio = gpio;
+	link->dev = dev;
+
+	if (dev != NULL) {
+		dev = get_device(dev);
+		if (dev == NULL) {
+			status = -ENODEV;
+			goto err2;
+		}
+		status = sysfs_create_link(&dev->kobj, target, name);
+	} else {
+		status = class_create_link(&gpio_class, target, name);
+	}
+
+	if (status)
+		goto err3;
+
+	list_add(&link->node, &sysfs_links);
+
+	return 0;
+
+err3:
+	if (dev != NULL)
+		put_device(dev);
+err2:
+	kfree(link->name);
+err1:
+	kfree(link);
+err0:
+
+	return status;
+}
+
+/* remove symlinks pointing to gpio */
+static void remove_links(unsigned gpio)
+{
+	struct sysfs_link	*link, *tmp;
+
+	list_for_each_entry_safe(link, tmp, &sysfs_links, node) {
+		if (link->gpio == gpio) {
+			if (link->dev != NULL) {
+				sysfs_remove_link(&link->dev->kobj, link->name);
+				put_device(link->dev);
+			} else {
+				class_remove_link(&gpio_class, link->name);
+			}
+			list_del(&link->node);
+			kfree(link->name);
+			kfree(link);
+		}
+	}
+}
 
 /**
  * gpio_export - export a GPIO through sysfs
@@ -701,12 +781,17 @@ static int match_export(struct device *dev, void *data)
 
 /**
  * gpio_export_link - create a sysfs link to an exported GPIO node
- * @dev: device under which to create symlink
+ * @dev: device under which to create symlink, or NULL for gpio class
  * @name: name of the symlink
  * @gpio: gpio to create symlink to, already exported
  *
- * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
- * node. Caller is responsible for unlinking.
+ * If @dev is non-NULL, set up a symlink from /sys/.../dev/name to
+ * /sys/class/gpio/gpioN node.
+ *
+ * If @dev is NULL, set up the symlink from /sys/class/gpio/name to
+ * /sys/class/gpio/gpioN node.
+ *
+ * Symlinks are removed on gpio_unexport() on the @gpio.
  *
  * Returns zero on success, else an error.
  */
@@ -727,8 +812,7 @@ int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
 
 		tdev = class_find_device(&gpio_class, NULL, desc, match_export);
 		if (tdev != NULL) {
-			status = sysfs_create_link(&dev->kobj, &tdev->kobj,
-						name);
+			status = create_link(gpio, dev, &tdev->kobj, name);
 		} else {
 			status = -ENODEV;
 		}
@@ -769,6 +853,7 @@ void gpio_unexport(unsigned gpio)
 		if (dev) {
 			gpio_setup_irq(desc, dev, 0);
 			clear_bit(FLAG_EXPORT, &desc->flags);
+			remove_links(gpio);
 			put_device(dev);
 			device_unregister(dev);
 			status = 0;
Signature · 1 line
1.6.5.2
#3 lore raw

PATCH 3/3 gpiolib: use chip->names for symlinks, always use gpioN for device names

Restore gpiolib sysfs device naming back to /sys/class/gpio/gpioN, where N is the GPIO number. Use the chip->names mechanism for creating symlinks to those devices instead of creating the devices using chip->names. All GPIO naming (other than gpioN) in gpiolib sysfs is now done using symlinks.

While the device names are now unique again, collisions in chip->names will still prevent duplicates from being exported to sysfs.

---
 drivers/gpio/gpiolib.c |    6 +++++-
 1 files changed, 5 insertions(+), 1 deletions(-)
drivers/gpio/gpiolib.c +5 -1
index f254195..fe7ffad 100644
@@ -740,7 +740,7 @@ int gpio_export(unsigned gpio, bool direction_may_change)
 		struct device	*dev;
 
 		dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
-				desc, ioname ? ioname : "gpio%d", gpio);
+				desc, "gpio%d", gpio);
 		if (!IS_ERR(dev)) {
 			if (direction_may_change)
 				status = sysfs_create_group(&dev->kobj,
@@ -756,6 +756,10 @@ int gpio_export(unsigned gpio, bool direction_may_change)
 				status = device_create_file(dev,
 						&dev_attr_edge);
 
+			if (!status && ioname != NULL)
+				status = create_link(gpio, NULL, &dev->kobj,
+						ioname);
+
 			if (status != 0)
 				device_unregister(dev);
 		} else
Signature · 1 line
1.6.5.2
#4 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 2 lines · Jani Nikula

While the device names are now unique again, collisions in chip->names will still prevent duplicates from being exported to sysfs.

That's why I was never a real fan of chip->names...

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

- Dave

#5 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 4 lines · David Brownell
Quoted 2 lines · Jani Nikula

While the device names are now unique again, collisions in chip->names will still prevent duplicates from being exported to sysfs.

Quoted 8 lines

That's why I was never a real fan of chip->names...

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'? Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

thanks,

greg k-h

#6 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 11 lines · Greg KH
Quoted 7 lines

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'?  Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

I want a concrete example. Those chip->names things don't seem helpful to me though...

If for example I were building a JTAG adapter on Linux, it might consist of a spidev node (chardev) plus a handful of GPIOs. So "the device directory" would be the sysfs home of that spidev node (or some variant)? And inside that directory would be files named after various signals that are used as GPIOs ... maybe SRST, TRST, and DETECT to start with? Holding some cookie that gets mapped to those GPIO's sysfs entries?

I confess I'd still think a symlink from that directory to the real GPIO would be easier to work with...

- Dave

#7 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 16 lines · David Brownell
Quoted 11 lines · Greg KH
Quoted 7 lines

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'? ?Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

I want a concrete example. Those chip->names things don't seem helpful to me though...

Quoted 8 lines

If for example I were building a JTAG adapter on Linux, it might consist of a spidev node (chardev) plus a handful of GPIOs. So "the device directory" would be the sysfs home of that spidev node (or some variant)? And inside that directory would be files named after various signals that are used as GPIOs ... maybe SRST, TRST, and DETECT to start with? Holding some cookie that gets mapped to those GPIO's sysfs entries?

Um, I really don't know, as I don't know the GPIO subsystem, nor why you all have this problem in the first place :)

I also find it funny that you think changing the kernel is easier than userspace, that's a strange situation.

Anyway, I assumed that you already have a struct device for the GPIO devices, right? Put it in there was what I was thinking, but as I don't understand your current layout, I really don't know.

Quoted 2 lines

I confess I'd still think a symlink from that directory to the real GPIO would be easier to work with...

No, don't do that, no symlinks from a class please.

thanks,

greg k-h

#8 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 14 lines · Greg KH
Quoted 13 lines · David Brownell
Quoted 11 lines · Greg KH
Quoted 7 lines

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'? ?Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

Quoted 7 lines
Quoted 4 lines

I want a concrete example. Those chip->names things don't seem helpful to me though...

...

Um, I really don't know, as I don't know the GPIO subsystem, nor why you all have this problem in the first place :)

Maybe Jani can provide a more concrete example.

Quoted 2 lines

I also find it funny that you think changing the kernel is easier than userspace, that's a strange situation.

I don't recall saying that. :)

It's a case of kernel having access to system data that's not otherwise exported to userspace. It knows how the various bits of hardware fit together ... and in this case wants to export associations between some GPIOs and some other hardware. Given that, userspace can pick things up.

Quoted 3 lines

Anyway, I assumed that you already have a struct device for the GPIO devices, right? Put it in there was what I was thinking, but as I don't understand your current layout, I really don't know.

There are gpio_chip devices, for a set of GPIOs. But not for the individual GPIOs.

Quoted 4 lines
Quoted 2 lines

I confess I'd still think a symlink from that directory to the real GPIO would be easier to work with...

No, don't do that, no symlinks from a class please.

I didn't catch a reason for that request... could you explain that?

- Dave

#9 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 46 lines · David Brownell
Quoted 14 lines · Greg KH
Quoted 13 lines · David Brownell
Quoted 11 lines · Greg KH
Quoted 7 lines

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'? ?Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

Quoted 7 lines
Quoted 4 lines

I want a concrete example. Those chip->names things don't seem helpful to me though...

...

Um, I really don't know, as I don't know the GPIO subsystem, nor why you all have this problem in the first place :)

Maybe Jani can provide a more concrete example.

Quoted 2 lines

I also find it funny that you think changing the kernel is easier than userspace, that's a strange situation.

I don't recall saying that. :)

It's a case of kernel having access to system data that's not otherwise exported to userspace. It knows how the various bits of hardware fit together ... and in this case wants to export associations between some GPIOs and some other hardware. Given that, userspace can pick things up.

Quoted 3 lines

Anyway, I assumed that you already have a struct device for the GPIO devices, right? Put it in there was what I was thinking, but as I don't understand your current layout, I really don't know.

There are gpio_chip devices, for a set of GPIOs. But not for the individual GPIOs.

Quoted 7 lines
Quoted 4 lines
Quoted 2 lines

I confess I'd still think a symlink from that directory to the real GPIO would be easier to work with...

No, don't do that, no symlinks from a class please.

I didn't catch a reason for that request... could you explain that?

It only causes confusion and you would be the only subsystem needing such a strange thing, causing me to believe something is wrong with the request.

Also see Kay's response, it was better :)

thanks,

greg k-h

Quoted 2 lines

- Dave

#10 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

In reply to Greg KH
Quoted 26 lines · Greg KH
Quoted 16 lines · David Brownell
Quoted 11 lines · Greg KH
Quoted 7 lines

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'? ?Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

I want a concrete example. Those chip->names things don't seem helpful to me though...

Quoted 8 lines

If for example I were building a JTAG adapter on Linux, it might consist of a spidev node (chardev) plus a handful of GPIOs. So "the device directory" would be the sysfs home of that spidev node (or some variant)? And inside that directory would be files named after various signals that are used as GPIOs ... maybe SRST, TRST, and DETECT to start with? Holding some cookie that gets mapped to those GPIO's sysfs entries?

Quoted 5 lines

Um, I really don't know, as I don't know the GPIO subsystem, nor why you all have this problem in the first place :)

I also find it funny that you think changing the kernel is easier than userspace, that's a strange situation.

User-space does not know which GPIO number is what. E.g., is the "power_button" GPIO number 6 or 99? It just does not have this information.

Kernel knows this, either because it was compiled for a specific board revision, or it got this information from the bootloader.

And the whole idea is to make kernel export this name. Currently, the kernel exports only the numbers in sysfs, which is not enough.

And because gpiolib is designed as it is designed, we found that having additional link in /sys/class/gpio is the nicest solution from gpiolib's POW. It just fits naturally to the existing design.

And no, we do not have per-gpio struct device, so we cannot add a new "name" attribute there. We need to either persuade you to accept our solution or make you take closer look at gpoiolib subsystem and suggest us the right way to go :-)

Signature · 2 lines
Best Regards,
Artem Bityutskiy (Артём Битюцкий)
#11 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 37 lines · Artem Bityutskiy
Quoted 26 lines · Greg KH
Quoted 16 lines · David Brownell
Quoted 11 lines · Greg KH
Quoted 7 lines

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'? ?Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

I want a concrete example. Those chip->names things don't seem helpful to me though...

Quoted 8 lines

If for example I were building a JTAG adapter on Linux, it might consist of a spidev node (chardev) plus a handful of GPIOs. So "the device directory" would be the sysfs home of that spidev node (or some variant)? And inside that directory would be files named after various signals that are used as GPIOs ... maybe SRST, TRST, and DETECT to start with? Holding some cookie that gets mapped to those GPIO's sysfs entries?

Quoted 5 lines

Um, I really don't know, as I don't know the GPIO subsystem, nor why you all have this problem in the first place :)

I also find it funny that you think changing the kernel is easier than userspace, that's a strange situation.

User-space does not know which GPIO number is what. E.g., is the "power_button" GPIO number 6 or 99? It just does not have this information.

Quoted 5 lines

Kernel knows this, either because it was compiled for a specific board revision, or it got this information from the bootloader.

And the whole idea is to make kernel export this name. Currently, the kernel exports only the numbers in sysfs, which is not enough.

Then export a file with the name somewhere as well. Why not put that in the directory you were going to point the symlink at?

Quoted 8 lines

And because gpiolib is designed as it is designed, we found that having additional link in /sys/class/gpio is the nicest solution from gpiolib's POW. It just fits naturally to the existing design.

And no, we do not have per-gpio struct device, so we cannot add a new "name" attribute there. We need to either persuade you to accept our solution or make you take closer look at gpoiolib subsystem and suggest us the right way to go :-)

If you don't have a struct device, then what are you going to generate a symlink to?

And sorry, I'm swamped with other work right now, I honestly have no time to dig into the gpio subsystem.

thanks,

greg k-h

#12 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 7 lines · ext Greg KH
Quoted 4 lines

And no, we do not have per-gpio struct device, so we cannot add a new "name" attribute there. We need to either persuade you to accept our solution or make you take closer look at gpoiolib subsystem and suggest us the right way to go :-)

If you don't have a struct device, then what are you going to generate a symlink to?

Sorry, this piece of information was wrong.

Signature · 2 lines
Best Regards,
Artem Bityutskiy (Артём Битюцкий)
#13 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 10 lines · Artem Bityutskiy
Quoted 7 lines · ext Greg KH
Quoted 4 lines

And no, we do not have per-gpio struct device, so we cannot add a new "name" attribute there. We need to either persuade you to accept our solution or make you take closer look at gpoiolib subsystem and suggest us the right way to go :-)

If you don't have a struct device, then what are you going to generate a symlink to?

Sorry, this piece of information was wrong.

Great, then you can use the 'let's make a sysfs file and grep for it from userspace' option.

Or, you can use the 'create a directory for your class, and create symlinks in there like other subsystems do' option.

Both of which require no changes in the driver core, and have precedent in that other subsystems already do this today.

Good luck,

greg k-h

#14 lore raw

PATCH 1/1 crypto: Fix complain about lack test for internal used algorithm

In reply to Artem Bityutskiy

When load aesni-intel and ghash_clmulni-intel driver,kernel will complain no
test for some internal used algorithm.
The strange information as following:

alg: No test for __aes-aesni (__driver-aes-aesni)
alg: No test for __ecb-aes-aesni (__driver-ecb-aes-aesni)
alg: No test for __cbc-aes-aesni (__driver-cbc-aes-aesni)
alg: No test for __ecb-aes-aesni (cryptd(__driver-ecb-aes-aesni)
alg: No test for __ghash (__ghash-pclmulqdqni)
alg: No test for __ghash (cryptd(__ghash-pclmulqdqni))

After summarize, the internal used algorithm driver with priority equal 0 or equal 50 when cryptd is used.

This patch add function to check driver is internal used and will shut up when internal driver is not tested.

---

crypto/algapi.c +27 -0
index a03ebcb..a602223 100644
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/rtnetlink.h>
 #include <linux/string.h>
+#include <crypto/cryptd.h>
 
 #include "internal.h"
 
@@ -243,6 +244,32 @@ err:
 	goto out;
 }
 
+int crypto_is_internal(const char *driver)
+{
+	struct crypto_alg *q;
+	int found = 0;
+
+	list_for_each_entry(q, &crypto_alg_list, cra_list) {
+		if (!strcmp(q->cra_driver_name, driver)) {
+			found = 1;
+			break;
+		}
+	}
+
+	if (found) {
+
+		if (q->cra_priority == 0)
+			return 1;
+		if (q->cra_priority == CRYPTD_PRIORITY_ADDITION &&
+				strstr(q->cra_driver_name, "cryptd"))
+			return 1;
+	}
+
+	return 0;
+
+}
+EXPORT_SYMBOL_GPL(crypto_is_internal);
+
 void crypto_alg_tested(const char *name, int err)
 {
 	struct crypto_larval *test;
crypto/cryptd.c +1 -1
index f8ae0d9..79785b7 100644
@@ -275,7 +275,7 @@ static void *cryptd_alloc_instance(struct crypto_alg *alg, unsigned int head,
 
 	memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
 
-	inst->alg.cra_priority = alg->cra_priority + 50;
+	inst->alg.cra_priority = alg->cra_priority + CRYPTD_PRIORITY_ADDITION;
 	inst->alg.cra_blocksize = alg->cra_blocksize;
 	inst->alg.cra_alignmask = alg->cra_alignmask;
 
crypto/internal.h +2 -0
index 2d22636..23b6498 100644
@@ -101,6 +101,8 @@ int crypto_register_notifier(struct notifier_block *nb);
 int crypto_unregister_notifier(struct notifier_block *nb);
 int crypto_probing_notify(unsigned long val, void *v);
 
+int crypto_is_internal(const char *driver);
+
 static inline void crypto_alg_put(struct crypto_alg *alg)
 {
 	if (atomic_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
crypto/testmgr.c +2 -1
index fe68115..542941c 100644
@@ -2413,7 +2413,8 @@ test_done:
 	return rc;
 
 notest:
-	printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
+	if (!crypto_is_internal(driver))
+		printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
 	return 0;
 non_fips_alg:
 	return -EINVAL;
include/crypto/cryptd.h +2 -0
index 1c96b25..50cd473 100644
@@ -9,6 +9,8 @@
 #include <linux/kernel.h>
 #include <crypto/hash.h>
 
+#define CRYPTD_PRIORITY_ADDITION 50
+
 struct cryptd_ablkcipher {
 	struct crypto_ablkcipher base;
 };
maintainer
#15 lore raw

Re: [PATCH]crypto: Fix complain about lack test for internal used algorithm

Quoted 10 lines · Youquan,Song

When load aesni-intel and ghash_clmulni-intel driver,kernel will complain no
test for some internal used algorithm.
The strange information as following:

alg: No test for __aes-aesni (__driver-aes-aesni)
alg: No test for __ecb-aes-aesni (__driver-ecb-aes-aesni)
alg: No test for __cbc-aes-aesni (__driver-cbc-aes-aesni)
alg: No test for __ecb-aes-aesni (cryptd(__driver-ecb-aes-aesni)
alg: No test for __ghash (__ghash-pclmulqdqni)
alg: No test for __ghash (cryptd(__ghash-pclmulqdqni))

I'd prefer to just add nul testmgr entries for these algorithms.

Thanks,

Signature · 4 lines
Visit Openswan at http://www.openswan.org/
Email: Herbert Xu ~{PmV>HI~} <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
#16 lore raw

Re: [PATCH]crypto: Fix complain about lack test for internal used algorithm

Quoted 5 lines · Youquan,Song
Quoted 4 lines

When load aesni-intel and ghash_clmulni-intel driver,kernel will complain no
test for some internal used algorithm.
The strange information as following:

Quoted 8 lines
Quoted 6 lines

alg: No test for __aes-aesni (__driver-aes-aesni)
alg: No test for __ecb-aes-aesni (__driver-ecb-aes-aesni)
alg: No test for __cbc-aes-aesni (__driver-cbc-aes-aesni)
alg: No test for __ecb-aes-aesni (cryptd(__driver-ecb-aes-aesni)
alg: No test for __ghash (__ghash-pclmulqdqni)
alg: No test for __ghash (cryptd(__ghash-pclmulqdqni))

I'd prefer to just add nul testmgr entries for these algorithms.

Hi Herbert,

Do you like the following modification to the patch? If yes, I will resend the patch.

Thanks

-Youquan

---

crypto/algapi.c +27 -0
index a03ebcb..a602223 100644
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/rtnetlink.h>
 #include <linux/string.h>
+#include <crypto/cryptd.h>
 
 #include "internal.h"
 
@@ -243,6 +244,32 @@ err:
 	goto out;
 }
 
+int crypto_is_internal(const char *driver)
+{
+	struct crypto_alg *q;
+	int found = 0;
+
+	list_for_each_entry(q, &crypto_alg_list, cra_list) {
+		if (!strcmp(q->cra_driver_name, driver)) {
+			found = 1;
+			break;
+		}
+	}
+
+	if (found) {
+
+		if (q->cra_priority == 0)
+			return 1;
+		if (q->cra_priority == CRYPTD_PRIORITY_ADDITION &&
+				strstr(q->cra_driver_name, "cryptd"))
+			return 1;
+	}
+
+	return 0;
+
+}
+EXPORT_SYMBOL_GPL(crypto_is_internal);
+
 void crypto_alg_tested(const char *name, int err)
 {
 	struct crypto_larval *test;
crypto/cryptd.c +1 -1
index f8ae0d9..79785b7 100644
@@ -275,7 +275,7 @@ static void *cryptd_alloc_instance(struct crypto_alg *alg, unsigned int head,
 
 	memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
 
-	inst->alg.cra_priority = alg->cra_priority + 50;
+	inst->alg.cra_priority = alg->cra_priority + CRYPTD_PRIORITY_ADDITION;
 	inst->alg.cra_blocksize = alg->cra_blocksize;
 	inst->alg.cra_alignmask = alg->cra_alignmask;
 
crypto/internal.h +2 -0
index 2d22636..23b6498 100644
@@ -101,6 +101,8 @@ int crypto_register_notifier(struct notifier_block *nb);
 int crypto_unregister_notifier(struct notifier_block *nb);
 int crypto_probing_notify(unsigned long val, void *v);
 
+int crypto_is_internal(const char *driver);
+
 static inline void crypto_alg_put(struct crypto_alg *alg)
 {
 	if (atomic_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
crypto/testmgr.c +24 -0
index f70ce52..0de1ef4 100644
@@ -1316,6 +1316,12 @@ out:
 	return err;
 }
 
+static int alg_test_null(const struct alg_test_desc *desc,
+			     const char *driver, u32 type, u32 mask)
+{
+	return 0;
+}
+
 static int alg_test_skcipher(const struct alg_test_desc *desc,
 			     const char *driver, u32 type, u32 mask)
 {
@@ -2086,6 +2092,15 @@ static const struct alg_test_desc alg_test_descs[] = {
 			}
 		}
 	}, {
+		.alg = "null",
+		.test = alg_test_null,
+		.suite = {
+			.hash = {
+				.vecs = NULL,
+				.count = 0
+			}
+		}
+	}, {
 		.alg = "pcbc(fcrypt)",
 		.test = alg_test_skcipher,
 		.suite = {
@@ -2365,6 +2380,15 @@ int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
 	int j;
 	int rc;
 
+	if (crypto_is_internal(driver)) {
+		i = alg_find_test("null");
+		if (i < 0)
+			goto notest;
+		rc = alg_test_descs[i].test(alg_test_descs + i, "null",
+					     type, mask);
+		goto test_done;
+
+	}
 	if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
 		char nalg[CRYPTO_MAX_ALG_NAME];
 
include/crypto/cryptd.h +2 -0
index 1c96b25..50cd473 100644
@@ -9,6 +9,8 @@
 #include <linux/kernel.h>
 #include <crypto/hash.h>
 
+#define CRYPTD_PRIORITY_ADDITION 50
+
 struct cryptd_ablkcipher {
 	struct crypto_ablkcipher base;
 };
maintainer
#17 lore raw

Re: [PATCH]crypto: Fix complain about lack test for internal used algorithm

Quoted 3 lines · Youquan,Song

Do you like the following modification to the patch? If yes, I will resend the patch.

No what I meant is that each algorithm should have its own nul entry. IOW we don't need this crypto_is_internal stuff at all.

Thanks,

Signature · 4 lines
Visit Openswan at http://www.openswan.org/
Email: Herbert Xu ~{PmV>HI~} <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
#18 lore raw

Re: [PATCH]crypto: Fix complain about lack test for internal used algorithm

Quoted 2 lines

No what I meant is that each algorithm should have its own nul entry. IOW we don't need this crypto_is_internal stuff at all.

Hi Herbert,

Well, Are you satisfied with the following modification?

Thanks.

-Youquan

crypto/testmgr.c +84 -0
index f70ce52..60c9857 100644
@@ -1477,9 +1477,69 @@ static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
 	return err;
 }
 
+static int alg_test_null(const struct alg_test_desc *desc,
+			     const char *driver, u32 type, u32 mask)
+{
+	return 0;
+}
+
 /* Please keep this list sorted by algorithm name. */
 static const struct alg_test_desc alg_test_descs[] = {
 	{
+		.alg = "ecb(__aes-aesni)",
+		.test = alg_test_null,
+		.suite = {
+			.cipher = {
+				.enc = {
+					.vecs = NULL,
+					.count = 0
+				},
+				.dec = {
+					.vecs = NULL,
+					.count = 0
+				}
+			}
+		}
+	}, {
+		.alg = "__driver-cbc-aes-aesni",
+		.test = alg_test_null,
+		.suite = {
+			.cipher = {
+				.enc = {
+					.vecs = NULL,
+					.count = 0
+				},
+				.dec = {
+					.vecs = NULL,
+					.count = 0
+				}
+			}
+		}
+	}, {
+		.alg = "__driver-ecb-aes-aesni",
+		.test = alg_test_null,
+		.suite = {
+			.cipher = {
+				.enc = {
+					.vecs = NULL,
+					.count = 0
+				},
+				.dec = {
+					.vecs = NULL,
+					.count = 0
+				}
+			}
+		}
+	}, {
+		.alg = "__ghash-pclmulqdqni",
+		.test = alg_test_null,
+		.suite = {
+			.hash = {
+				.vecs = NULL,
+				.count = 0
+			}
+		}
+	}, {
 		.alg = "ansi_cprng",
 		.test = alg_test_cprng,
 		.fips_allowed = 1,
@@ -1623,6 +1683,30 @@ static const struct alg_test_desc alg_test_descs[] = {
 			}
 		}
 	}, {
+		.alg = "cryptd(__driver-ecb-aes-aesni)",
+		.test = alg_test_null,
+		.suite = {
+			.cipher = {
+				.enc = {
+					.vecs = NULL,
+					.count = 0
+				},
+				.dec = {
+					.vecs = NULL,
+					.count = 0
+				}
+			}
+		}
+	}, {
+		.alg = "cryptd(__ghash-pclmulqdqni)",
+		.test = alg_test_null,
+		.suite = {
+			.hash = {
+				.vecs = NULL,
+				.count = 0
+			}
+		}
+	}, {
 		.alg = "ctr(aes)",
 		.test = alg_test_skcipher,
 		.fips_allowed = 1,
maintainer
#19 lore raw

Re: [PATCH]crypto: Fix complain about lack test for internal used algorithm

Quoted 6 lines · Youquan,Song
Quoted 2 lines

No what I meant is that each algorithm should have its own nul entry. IOW we don't need this crypto_is_internal stuff at all.

Hi Herbert,

Well, Are you satisfied with the following modification?

Yes looks good to me. Please resubmit with a proper changelog and sign-off.

Thanks,

Signature · 4 lines
Visit Openswan at http://www.openswan.org/
Email: Herbert Xu ~{PmV>HI~} <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
#20 lore raw

PATCH RESEND 1/1 crypto: Fix complain about lack test for internal used algorithm

When load aesni-intel and ghash_clmulni-intel driver,kernel will complain no
test for some internal used algorithm.
The strange information as following:

alg: No test for __aes-aesni (__driver-aes-aesni)
alg: No test for __ecb-aes-aesni (__driver-ecb-aes-aesni)
alg: No test for __cbc-aes-aesni (__driver-cbc-aes-aesni)
alg: No test for __ecb-aes-aesni (cryptd(__driver-ecb-aes-aesni)
alg: No test for __ghash (__ghash-pclmulqdqni)
alg: No test for __ghash (cryptd(__ghash-pclmulqdqni))

This patch add NULL test entries for these algorithm and driver.

---

crypto/testmgr.c +84 -0
index f70ce52..e934eca 100644
@@ -1477,9 +1477,54 @@ static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
 	return err;
 }
 
+static int alg_test_null(const struct alg_test_desc *desc,
+			     const char *driver, u32 type, u32 mask)
+{
+	return 0;
+}
+
 /* Please keep this list sorted by algorithm name. */
 static const struct alg_test_desc alg_test_descs[] = {
 	{
+		.alg = "__driver-cbc-aes-aesni",
+		.test = alg_test_null,
+		.suite = {
+			.cipher = {
+				.enc = {
+					.vecs = NULL,
+					.count = 0
+				},
+				.dec = {
+					.vecs = NULL,
+					.count = 0
+				}
+			}
+		}
+	}, {
+		.alg = "__driver-ecb-aes-aesni",
+		.test = alg_test_null,
+		.suite = {
+			.cipher = {
+				.enc = {
+					.vecs = NULL,
+					.count = 0
+				},
+				.dec = {
+					.vecs = NULL,
+					.count = 0
+				}
+			}
+		}
+	}, {
+		.alg = "__ghash-pclmulqdqni",
+		.test = alg_test_null,
+		.suite = {
+			.hash = {
+				.vecs = NULL,
+				.count = 0
+			}
+		}
+	}, {
 		.alg = "ansi_cprng",
 		.test = alg_test_cprng,
 		.fips_allowed = 1,
@@ -1623,6 +1668,30 @@ static const struct alg_test_desc alg_test_descs[] = {
 			}
 		}
 	}, {
+		.alg = "cryptd(__driver-ecb-aes-aesni)",
+		.test = alg_test_null,
+		.suite = {
+			.cipher = {
+				.enc = {
+					.vecs = NULL,
+					.count = 0
+				},
+				.dec = {
+					.vecs = NULL,
+					.count = 0
+				}
+			}
+		}
+	}, {
+		.alg = "cryptd(__ghash-pclmulqdqni)",
+		.test = alg_test_null,
+		.suite = {
+			.hash = {
+				.vecs = NULL,
+				.count = 0
+			}
+		}
+	}, {
 		.alg = "ctr(aes)",
 		.test = alg_test_skcipher,
 		.fips_allowed = 1,
@@ -1669,6 +1738,21 @@ static const struct alg_test_desc alg_test_descs[] = {
 			}
 		}
 	}, {
+		.alg = "ecb(__aes-aesni)",
+		.test = alg_test_null,
+		.suite = {
+			.cipher = {
+				.enc = {
+					.vecs = NULL,
+					.count = 0
+				},
+				.dec = {
+					.vecs = NULL,
+					.count = 0
+				}
+			}
+		}
+	}, {
 		.alg = "ecb(aes)",
 		.test = alg_test_skcipher,
 		.fips_allowed = 1,
maintainer
#21 lore raw

Re: [Resend PATCH]crypto: Fix complain about lack test for internal used algorithm

Quoted 11 lines · Youquan,Song

When load aesni-intel and ghash_clmulni-intel driver,kernel will complain no
test for some internal used algorithm.
The strange information as following:

alg: No test for __aes-aesni (__driver-aes-aesni)
alg: No test for __ecb-aes-aesni (__driver-ecb-aes-aesni)
alg: No test for __cbc-aes-aesni (__driver-cbc-aes-aesni)
alg: No test for __ecb-aes-aesni (cryptd(__driver-ecb-aes-aesni)
alg: No test for __ghash (__ghash-pclmulqdqni)
alg: No test for __ghash (cryptd(__ghash-pclmulqdqni))

Quoted 4 lines

This patch add NULL test entries for these algorithm and driver.

Patch applied. Thanks a lot!

Signature · 4 lines
Visit Openswan at http://www.openswan.org/
Email: Herbert Xu ~{PmV>HI~} <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
#22 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

In reply to David Brownell
Quoted 16 lines · David Brownell
Quoted 11 lines · Greg KH
Quoted 7 lines

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'? Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

I want a concrete example. Those chip->names things don't seem helpful to me though...

Quoted 8 lines

If for example I were building a JTAG adapter on Linux, it might consist of a spidev node (chardev) plus a handful of GPIOs. So "the device directory" would be the sysfs home of that spidev node (or some variant)? And inside that directory would be files named after various signals that are used as GPIOs ... maybe SRST, TRST, and DETECT to start with? Holding some cookie that gets mapped to those GPIO's sysfs entries?

If you've got a spidev node then you've got a dev to pass to gpio_export_link, all's right with the world. I think the best thing (which I think is what Greg was thinking) would be to
have /sys/class/gpio/gpioN/name which reads null unless the kernel has registered a name against that gpio.

Now I don't like the chip->name thing as a way to hold these labels, I'd prefer an IDR indexed by gpio number, but that's an implementation detail for later.

A concrete use case: I've got a board here, the support patch for which will hopefully appear in a few days. On it I've got an 8-bit uC which does a bunch of I/O and on certain conditions, toggles gpio lines so a userspace daemon knows what's going on. At the moment, I have /sys/class/<board name>/ which exports things like revision information as well as attributes telling me which gpio numbers are used for which purpose. My scripts therefore look something like

echo 1 > /sys/class/gpio/gpiocat /sys/class/<board-name>/ack-gpio/value

I'm actually fairly happy with that but I don't pretend it's everyone's cup of tea. The point is though, the microprocessor has no in-kernel incarnation except these few gpio so there's no convenient dev node to link the names through; gpio_export_link() isn't useful.

This problem could be solved as I have, but it could equally-well be solved by exporting gpioN/name attributes which I could search for.

	--Ben.
#23 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

In reply to Greg KH
Quoted 6 lines · Greg KH
Quoted 5 lines · David Brownell
Quoted 2 lines · Jani Nikula

While the device names are now unique again, collisions in chip->names will still prevent duplicates from being exported to sysfs.

That's why I was never a real fan of chip->names...

Yea, poor idea indeed.

Quoted 11 lines
Quoted 7 lines

IMO a "good" solution in this space needs to accept that those names are not going to be globally unique ... but that they'll be unique within some context, of necessity.

If Greg doesn't want to see those names under classes, so be it ... but where should they then appear?

As a sysfs file within the device directory called 'name'? Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

Well it bunts the handling of duplicates to who ever is grepping but yea, sounds good. The user script can sanity-check it's results against the controlling gpio-chip if need be. In fact, maybe symlink from gpioN/chip back to gpio-chipY could be useful? A bit redundant though, as you can check using the number ranges..

In fact I thought I had a patch to create /sys/class/gpio/gpioN/name at some stage.. Can't find it though, oh well.

	--Ben.
#24 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Hi David and Ben -

Quoted 5 lines · ext Ben Nizette
Quoted 3 lines · Greg KH

As a sysfs file within the device directory called 'name'? Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

Quoted 8 lines

Well it bunts the handling of duplicates to who ever is grepping but yea, sounds good. The user script can sanity-check it's results against the controlling gpio-chip if need be. In fact, maybe symlink from gpioN/chip back to gpio-chipY could be useful? A bit redundant though, as you can check using the number ranges..

In fact I thought I had a patch to create /sys/class/gpio/gpioN/name at some stage.. Can't find it though, oh well.

Ben, could you please look harder? ;)

If we were to add /sys/class/gpio/gpioN/name attribute, what would be the optimal source for the names?

I'd prefer a scheme where a) the name could be set in both board files and drivers, the latter overriding the former as necessary, and b) the name could be set without actually requesting the gpio, so you could set all known names in board files without interfering with the drivers.

AFAICS this would pretty much lead to adding a pair of new functions gpio_set_name() and gpio_get_name(), which would work also for gpios that haven't been requested. (IDR lookup Ben mentioned in another mail sounds good, though there's the problem you can't specify the id - this is why gpio_setup_irq() uses the flags for storing the id.)

Here are some other alternatives I could think of, but none of them sound good to me:

1) Add new function gpio_export_name() to export with a certain name attribute. Leads to two ways of exporting.

2) Add 'name' parameter to gpio_export() to export with a certain name attribute. Changes an existing interface.

3) Use 'label' in gpio_request() for name attribute. Stores names also for gpios that are never exported, wastes a pointer per gpio in gpio_desc.

4) Use chip->names. Wastes a pointer per gpio even if one name is used, almost the same as adding char *name to struct gpio_desc. Not convenient to use, at least in OMAP.

Opinions?

BR,
Jani.

#25 lore raw

Re: [PATCH 3/3] gpiolib: use chip->names for symlinks, always use gpioN for device names

Quoted 14 lines · Jani Nikula

Hi David and Ben -

Quoted 11 lines · ext Ben Nizette
Quoted 3 lines · Greg KH

As a sysfs file within the device directory called 'name'? Then just grep through the tree to find the right device, that also handles duplicates just fine, right?

Well it bunts the handling of duplicates to who ever is grepping but yea, sounds good. The user script can sanity-check it's results against the controlling gpio-chip if need be. In fact, maybe symlink from gpioN/chip back to gpio-chipY could be useful? A bit redundant though, as you can check using the number ranges..

Quoted 4 lines
Quoted 2 lines

In fact I thought I had a patch to create /sys/class/gpio/gpioN/name at some stage.. Can't find it though, oh well.

Ben, could you please look harder? ;)

hehe, likely destroyed in the Great Hard-Disk Fire of '08. Shouldn't be hard to recreate, though I don't have the time at the moment.

Quoted 3 lines

If we were to add /sys/class/gpio/gpioN/name attribute, what would be the optimal source for the names?

You and I seem to be on the same page here; my $0.02 is for an IDR with gpio_{get,set,lookup}_name() functions. Actually, I can't remember, do the new flex arrays efficiently store sparse array data, or are they just useful 'coz they can grow?

Still open to debate though is whether gpio_set_name should enforce uniqueness; is isn't required at a FS-level any more but I can't see anything good coming from namespace collisions here.

Quoted 11 lines

I'd prefer a scheme where a) the name could be set in both board files and drivers, the latter overriding the former as necessary, and b) the name could be set without actually requesting the gpio, so you could set all known names in board files without interfering with the drivers.

AFAICS this would pretty much lead to adding a pair of new functions gpio_set_name() and gpio_get_name(), which would work also for gpios that haven't been requested. (IDR lookup Ben mentioned in another mail sounds good, though there's the problem you can't specify the id - this is why gpio_setup_irq() uses the flags for storing the id.)

Agreed.

Quoted 6 lines

Here are some other alternatives I could think of, but none of them sound good to me:

1) Add new function gpio_export_name() to export with a certain name attribute. Leads to two ways of exporting.

Well 3 including _link(). I don't think that's the problem so much as restricting naming to userspace users only. While I can't think of kernel users who /need/ this functionality, it'd clean a few code paths and while we're at it, why not?

Quoted 3 lines

2) Add 'name' parameter to gpio_export() to export with a certain name attribute. Changes an existing interface.

As above

Quoted 4 lines

3) Use 'label' in gpio_request() for name attribute. Stores names also for gpios that are never exported, wastes a pointer per gpio in gpio_desc.

And while debugfs is emphatically /not/ an ABI, it's still a semantic change to the exported information

Quoted 4 lines

4) Use chip->names. Wastes a pointer per gpio even if one name is used, almost the same as adding char *name to struct gpio_desc. Not convenient to use, at least in OMAP.

Not convenient on any platform I know of, I've never liked chip->names and would hope it goes away when (something like) the above interface is implemented.

	--Ben.
#26 lore raw

Re: [PATCH 2/3] gpiolib: add support for having symlinks under gpio class directory

In reply to Jani Nikula
Quoted 2 lines · Jani Nikula

Extend the functionality of gpio_export_link() to allow exported GPIOs to have names using sysfs links under /sys/class/gpio.

No, please don't create symlinks under a class, that is not something that any userspace tool is expecting.

I don't understand what you are trying to do here, why do you need a symlink? What is wrong with the original device names?

confused,

greg k-h

#27 lore raw

Re: [PATCH 2/3] gpiolib: add support for having symlinks under gpio class directory

Quoted 9 lines · ext Greg KH
Quoted 2 lines · Jani Nikula

Extend the functionality of gpio_export_link() to allow exported GPIOs to have names using sysfs links under /sys/class/gpio.

No, please don't create symlinks under a class, that is not something that any userspace tool is expecting.

I don't understand what you are trying to do here, why do you need a symlink? What is wrong with the original device names?

The problem
~~~~~~~~~~~

GPIOs can be exported to gpiolib sysfs at /sys/class/gpio/ like this:

# ls -l /sys/class/gpio/
--w-------    1 root     0            4096 Jan  1 00:00 export
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio25 -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio38 -> ../../devices/virtual/gpio/gpio38
...

The GPIO lines may and do change from board revision to another. For example a power button's GPIO number might be 25 in board rev 1.0 but 66 in board rev 1.1.

We want to assign symbolic names to GPIO lines and hide the numbering changes from userspace, because it is very painful to amend userspace for every board revision.

Existing solution
~~~~~~~~~~~~~~~~~

gpio_export_link() can be used to create symlinks from drivers' sysfs to gpiolib, but this obviously requires a driver. For example:

# ls -l /sys/devices/platform/foo/
lrwxrwxrwx    1 root     0               0 Jan  2 00:31 power_button -> ../../virtual/gpio/gpio25
...

This doesn't really work for GPIO lines not associated with any driver.

How we addressed the problem
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

We simply decided to extend gpio_export_link(). When it is called with 'dev == NULL' (no driver), it creates an additional symlink in /sys/class/gpio/

# ls -l /sys/class/gpio/
--w-------    1 root     0            4096 Jan  1 00:00 export
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 power_button -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio25 -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio38 -> ../../devices/virtual/gpio/gpio38
...

This is exactly what our patchset allows to do.

An alternative would be a dummy driver just to create a home in sysfs for the standalone GPIOs and use the gpio_export_link() to make the links there.

Any other suggestions?

Thanks,
Jani,
Artem.

#28 lore raw

Re: [PATCH 2/3] gpiolib: add support for having symlinks under gpio class directory

Quoted 22 lines · Jani Nikula
Quoted 9 lines · ext Greg KH
Quoted 2 lines · Jani Nikula

Extend the functionality of gpio_export_link() to allow exported GPIOs to have names using sysfs links under /sys/class/gpio.

No, please don't create symlinks under a class, that is not something that any userspace tool is expecting.

I don't understand what you are trying to do here, why do you need a symlink? What is wrong with the original device names?

The problem
~~~~~~~~~~~

GPIOs can be exported to gpiolib sysfs at /sys/class/gpio/ like this:

# ls -l /sys/class/gpio/
--w-------    1 root     0            4096 Jan  1 00:00 export
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio25 -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio38 -> ../../devices/virtual/gpio/gpio38
...
Quoted 7 lines

The GPIO lines may and do change from board revision to another. For example a power button's GPIO number might be 25 in board rev 1.0 but 66 in board rev 1.1.

We want to assign symbolic names to GPIO lines and hide the numbering changes from userspace, because it is very painful to amend userspace for every board revision.

True, just like it is hard to change the kernel for every type of configuration as well :)

This is the problem that udev solves, from usersapce, but you don't have device nodes for it to manage, right?

Quoted 11 lines

Existing solution
~~~~~~~~~~~~~~~~~

gpio_export_link() can be used to create symlinks from drivers' sysfs to gpiolib, but this obviously requires a driver. For example:

# ls -l /sys/devices/platform/foo/
lrwxrwxrwx    1 root     0               0 Jan  2 00:31 power_button -> ../../virtual/gpio/gpio25
...

This doesn't really work for GPIO lines not associated with any driver.

Understood

Quoted 14 lines

How we addressed the problem
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

We simply decided to extend gpio_export_link(). When it is called with 'dev == NULL' (no driver), it creates an additional symlink in /sys/class/gpio/

# ls -l /sys/class/gpio/
--w-------    1 root     0            4096 Jan  1 00:00 export
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 power_button -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio25 -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio38 -> ../../devices/virtual/gpio/gpio38
...
Quoted 7 lines

This is exactly what our patchset allows to do.

An alternative would be a dummy driver just to create a home in sysfs for the standalone GPIOs and use the gpio_export_link() to make the links there.

Any other suggestions?

This type of "policy" should be better off done in userspace whereever possible. Can't you just have a udev rule to create symlinks from somewhere else, into /sys/class/gpio/ that show this type of information that you are wanting to have?

thanks,

greg k-h

#29 lore raw

Re: [PATCH 2/3] gpiolib: add support for having symlinks under gpio class directory

Quoted 12 lines · Greg KH
Quoted 11 lines · Jani Nikula

We simply decided to extend gpio_export_link(). When it is called with 'dev == NULL' (no driver), it creates an additional symlink in /sys/class/gpio/

# ls -l /sys/class/gpio/
--w-------    1 root     0            4096 Jan  1 00:00 export
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 power_button -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio25 -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio38 -> ../../devices/virtual/gpio/gpio38
...
Quoted 7 lines
Quoted 7 lines

This is exactly what our patchset allows to do.

An alternative would be a dummy driver just to create a home in sysfs for the standalone GPIOs and use the gpio_export_link() to make the links there.

Any other suggestions?

We can not do anything like that. The symlink name must always match the name in /sys/devices/, and it must be a 1:1 relation. We can not allow anything else, it confuses tools which rightfully expect this.

You could convert the class to a "bus", the /sys/class layout is pretty much broken by design, and should better be avoided. It's not extensible, flat in its layout, and today just a too dumb version of the "bus" subsystem which does not have all these limitations.

All the device links would show up in /sys/bus/gpio/devices/, here you have the same rules as in /sys/class/: no additional symlinks, the same names as in /sys/devices -- but you could add a custom folder to the /sys/bus/gpio/ directory where you could do whatever fits your needs. :)

Thanks,
Kay

#30 lore raw

Re: [PATCH 2/3] gpiolib: add support for having symlinks under gpio class directory

Quoted 30 lines · Kay Sievers
Quoted 12 lines · Greg KH
Quoted 11 lines · Jani Nikula

We simply decided to extend gpio_export_link(). When it is called with 'dev == NULL' (no driver), it creates an additional symlink in /sys/class/gpio/

# ls -l /sys/class/gpio/
--w-------    1 root     0            4096 Jan  1 00:00 export
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 power_button -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio25 -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio38 -> ../../devices/virtual/gpio/gpio38
...
Quoted 7 lines
Quoted 7 lines

This is exactly what our patchset allows to do.

An alternative would be a dummy driver just to create a home in sysfs for the standalone GPIOs and use the gpio_export_link() to make the links there.

Any other suggestions?

We can not do anything like that. The symlink name must always match the name in /sys/devices/, and it must be a 1:1 relation. We can not allow anything else, it confuses tools which rightfully expect this.

You could convert the class to a "bus", the /sys/class layout is pretty much broken by design, and should better be avoided. It's not extensible, flat in its layout, and today just a too dumb version of the "bus" subsystem which does not have all these limitations.

Quoted 5 lines

All the device links would show up in /sys/bus/gpio/devices/, here you have the same rules as in /sys/class/: no additional symlinks, the same names as in /sys/devices -- but you could add a custom folder to the /sys/bus/gpio/ directory where you could do whatever fits your needs. :)

Ah, yeah, good point, the pci "slots" directory does something like this today, with symlinks pointing out of that directory to other devices.

It's messy, but it somehow works...

thanks,

greg k-h

#31 lore raw

Re: [PATCH 2/3] gpiolib: add support for having symlinks under gpio class directory

In reply to Greg KH
Quoted 7 lines · ext Greg KH
Quoted 3 lines · Jani Nikula

We want to assign symbolic names to GPIO lines and hide the numbering changes from userspace, because it is very painful to amend userspace for every board revision.

True, just like it is hard to change the kernel for every type of configuration as well :)

As explained by Artem, the kernel might get that information from the bootloader, for example, so once things are in place, there'd be no need to modify either the kernel or the userspace.

Quoted 2 lines

This is the problem that udev solves, from usersapce, but you don't have device nodes for it to manage, right?

When exporting a GPIO to sysfs, a struct device is created with 0,0 for dev_t, so I suppose that's correct.

Not having a device node limits the options with udev, right?

Quoted 4 lines

This type of "policy" should be better off done in userspace whereever possible. Can't you just have a udev rule to create symlinks from somewhere else, into /sys/class/gpio/ that show this type of information that you are wanting to have?

Let's see. 'udevadm monitor --env' gives me this when I 'echo add > uevent' for an exported gpio #5:

UDEV [1230784956.241303] add /class/gpio/gpio5 (gpio)
UDEV_LOG=3
ACTION=add
DEVPATH=/class/gpio/gpio5
SUBSYSTEM=gpio
SEQNUM=930
UDEVD_EVENT=1

Now *assuming* we had /sys/class/gpio/gpioN/name, I could create very crude udev rules along the lines of this:

SUBSYSTEM=="gpio", ACTION=="add", ATTR{name}!="", RUN="/bin/ln -s /sys$devpath /tmp/gpio-$attr{name}" SUBSYSTEM=="gpio", ACTION=="remove", ATTR{name}!="", RUN="/bin/rm /tmp/gpio-$attr{name}"

Not exactly pretty, but seems to work (using another attr for testing). Is there a more elegant way of doing this with udev when there are no device nodes? Or is it even sensible to use udev without the device nodes? And what would be the right place for the symlinks?

*If* we got that working in a sensible fashion, it'd be a matter of adding the "name" attribute to each gpio.

BR,
Jani.

#32 lore raw

Re: [PATCH 2/3] gpiolib: add support for having symlinks under gpio class directory

Quoted 14 lines · Jani Nikula

Let's see. 'udevadm monitor --env' gives me this when I 'echo add > uevent' for an exported gpio #5:

UDEV [1230784956.241303] add /class/gpio/gpio5 (gpio)
UDEV_LOG=3
ACTION=add
DEVPATH=/class/gpio/gpio5
SUBSYSTEM=gpio
SEQNUM=930
UDEVD_EVENT=1

Now *assuming* we had /sys/class/gpio/gpioN/name, I could create very crude udev rules along the lines of this:

Quoted 7 lines

SUBSYSTEM=="gpio", ACTION=="add", ATTR{name}!="", RUN="/bin/ln -s /sys$devpath /tmp/gpio-$attr{name}" SUBSYSTEM=="gpio", ACTION=="remove", ATTR{name}!="", RUN="/bin/rm /tmp/gpio-$attr{name}"

Not exactly pretty, but seems to work (using another attr for testing). Is there a more elegant way of doing this with udev when there are no device nodes? Or is it even sensible to use udev without the device nodes? And what would be the right place for the symlinks?

Kay said he didn't like you creating symlinks in /dev with udev, but this looks ok to me.

Quoted 2 lines

*If* we got that working in a sensible fashion, it'd be a matter of adding the "name" attribute to each gpio.

Yup, just use whatever you were wanting to use as the symlink name, it seems that logic was already done.

thanks.

greg k-h

#33 lore raw

Re: [PATCH 2/3] gpiolib: add support for having symlinks under gpio class directory

In reply to Jani Nikula
Quoted 7 lines · Jani Nikula

GPIOs can be exported to gpiolib sysfs at /sys/class/gpio/ like this:

# ls -l /sys/class/gpio/
--w-------    1 root     0            4096 Jan  1 00:00 export
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio25 -> ../../devices/virtual/gpio/gpio25
lrwxrwxrwx    1 root     0               0 Jan  1 00:00 gpio38 -> ../../devices/virtual/gpio/gpio38
...

Hmm, ISTR they don't always appear as "virtual" ... though that's pretty much irrelevant to the larger point you're making. Even when there are real device nodes for the gpio chips parenting any given GPIOs, they end up in fairly un-useful parts of the device tree (in terms of being related to something more significant than the random wires that were handy to the hardware designer).

Quoted 7 lines

The GPIO lines may and do change from board revision to another. For example a power button's GPIO number might be 25 in board rev 1.0 but 66 in board rev 1.1.

We want to assign symbolic names to GPIO lines and hide the numbering changes from userspace, because it is very painful to amend userspace for every board revision.

Related: these are part of what one might call "composite devices", which are crafted using a component from this subsystem, one from that, a few from over there, and so on. They don't properly belong in any single location in the device tree. Some level of symlinking seems inevitable.

And no, a full fledged chardev node is inappropriate so I don't see udev as able to help out.

#35 lore raw
In reply to Jani Nikula
Quoted 14 lines · On Wed, 9 Dec 2009 15:49:01 +0200 Jani Nikula <[email protected]>…

Hi David and Greg -

There's been debate in the past about naming gpios exported to the sysfs. Long story short, there are users for that, and there are now two ways of naming gpios in the sysfs: char **names in struct gpio_chip [1], and gpio_export_link() [2].

This patchset combines these two by allowing gpio_export_link() to have dev == NULL to make the link under gpiolib sysfs (instead of arbitrary device), and to use gpio_chip names to create links (instead of naming the actual devices with those). This gpio_export_link() with dev == NULL would also be useful for gpios not associated with a driver.

Quoted 6 lines

Greg, patch 1/3 introduces class_{create,remove}_link(), is that acceptable?

CC Daniel, you introduced names in struct gpio_chip in the first place, does this (especially patch 3/3) look acceptable to you?

I haven't seen an email from David in perhaps two months, so we're on our own in this.

Can you please remind us what the earlier objections were, and tell us how this patchset addresses them?

Thanks.