gpiolib: export the consumer's PID to user-space
cover gpiolib: export the consumer's PID to user-space
I've been asked several times independently over the course of last months for a way to figure out the PID of the user-space process that's holding a specific GPIO line. This does sound like a valid use-case as the user may create a background process that requests some lines and then want to kill it to release those lines.
These patches propose to extend the gpio_v2_line_info struct with the consumer's PID which is set to the process ID for user-space consumers and 0 for kernel-space ones.
Bartosz Golaszewski (2):
gpiolib: un-inline gpiod_request_user()
gpiolib: cdev: export the consumer's PID
drivers/gpio/gpiolib-cdev.c | 2 ++ drivers/gpio/gpiolib.c | 33 +++++++++++++++++++++++++++++---- drivers/gpio/gpiolib.h | 14 +++----------- include/uapi/linux/gpio.h | 5 ++++- 4 files changed, 38 insertions(+), 16 deletions(-)
Signature · 1 line
2.34.1
PATCH 1/2 gpiolib: un-inline gpiod_request_user()
Pull this bit of code into gpiolib.c as we're soon be calling certain symbols static in this compilation unit.
--- drivers/gpio/gpiolib.c | 11 +++++++++++ drivers/gpio/gpiolib.h | 12 +----------- 2 files changed, 12 insertions(+), 11 deletions(-)
drivers/gpio/gpiolib.c +11 -0
@@ -2009,6 +2009,17 @@ int gpiod_request(struct gpio_desc *desc, const char *label)return ret; } +int gpiod_request_user (struct gpio_desc *desc,const char *label) +{ +int ret; + + ret =gpiod_request (desc, label); +if (ret == -EPROBE_DEFER ) + ret = -ENODEV ; + +return ret; +} +static bool gpiod_free_commit (struct gpio_desc *desc) {bool ret = false;
drivers/gpio/gpiolib.h +1 -11
@@ -179,19 +179,9 @@ struct gpio_desc {#define gpiod_not_found (desc) (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT)int gpiod_request (struct gpio_desc *desc,const char *label); +int gpiod_request_user (struct gpio_desc *desc,const char *label);void gpiod_free (struct gpio_desc *desc); -static inline int gpiod_request_user (struct gpio_desc *desc,const char *label) -{ -int ret; - - ret =gpiod_request (desc, label); -if (ret == -EPROBE_DEFER ) - ret = -ENODEV ; - -return ret; -} -int gpiod_configure_flags (struct gpio_desc *desc,const char *con_id,unsigned long lflags,enum gpiod_flags dflags);int gpio_set_debounce_timeout (struct gpio_desc *desc,unsigned int debounce);
Signature · 1 line
2.34.1
Re: [PATCH 1/2] gpiolib: un-inline gpiod_request_user()
Quoted 2 lines · Bartosz Golaszewski
Pull this bit of code into
gpiolib.cas we're soon be calling certain symbols static in this compilation unit.
Quoted 56 lines
Signed-off-by Bartosz Golaszewski <[email protected]>--- drivers/gpio/gpiolib.c | 11 +++++++++++ drivers/gpio/gpiolib.h | 12 +----------- 2 files changed, 12 insertions(+), 11 deletions(-)drivers/gpio/gpiolib.c +11
-0@@ -2009,6 +2009,17 @@ int gpiod_request(struct gpio_desc *desc, const char *label)return ret; } +int gpiod_request_user (struct gpio_desc *desc,const char *label) +{ +int ret; + + ret =gpiod_request (desc, label); +if (ret == -EPROBE_DEFER ) + ret = -ENODEV ; + +return ret; +} +static bool gpiod_free_commit (struct gpio_desc *desc) {bool ret = false;drivers/gpio/gpiolib.h +1
-11@@ -179,19 +179,9 @@ struct gpio_desc {#define gpiod_not_found (desc) (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT)int gpiod_request (struct gpio_desc *desc,const char *label); +int gpiod_request_user (struct gpio_desc *desc,const char *label);void gpiod_free (struct gpio_desc *desc); -static inline int gpiod_request_user (struct gpio_desc *desc,const char *label) -{ -int ret; - - ret =gpiod_request (desc, label); -if (ret == -EPROBE_DEFER ) - ret = -ENODEV ; - -return ret; -} -int gpiod_configure_flags (struct gpio_desc *desc,const char *con_id,unsigned long lflags,enum gpiod_flags dflags);int gpio_set_debounce_timeout (struct gpio_desc *desc,unsigned int debounce);Signature · 1 line
2.34.1
Signature · 2 lines
With Best Regards, Andy Shevchenko
Kent Gibson
reviewerRe: [PATCH 1/2] gpiolib: un-inline gpiod_request_user()
In reply to Bartosz GolaszewskiQuoted 3 lines · Bartosz Golaszewski
Pull this bit of code into
gpiolib.cas we're soon be calling certain symbols static in this compilation unit.
Nit: "we'll soon be calling certain static symbols"
Quoted 56 lines
Signed-off-by Bartosz Golaszewski <[email protected]>--- drivers/gpio/gpiolib.c | 11 +++++++++++ drivers/gpio/gpiolib.h | 12 +----------- 2 files changed, 12 insertions(+), 11 deletions(-)drivers/gpio/gpiolib.c +11
-0@@ -2009,6 +2009,17 @@ int gpiod_request(struct gpio_desc *desc, const char *label)return ret; } +int gpiod_request_user (struct gpio_desc *desc,const char *label) +{ +int ret; + + ret =gpiod_request (desc, label); +if (ret == -EPROBE_DEFER ) + ret = -ENODEV ; + +return ret; +} +static bool gpiod_free_commit (struct gpio_desc *desc) {bool ret = false;drivers/gpio/gpiolib.h +1
-11@@ -179,19 +179,9 @@ struct gpio_desc {#define gpiod_not_found (desc) (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT)int gpiod_request (struct gpio_desc *desc,const char *label); +int gpiod_request_user (struct gpio_desc *desc,const char *label);void gpiod_free (struct gpio_desc *desc); -static inline int gpiod_request_user (struct gpio_desc *desc,const char *label) -{ -int ret; - - ret =gpiod_request (desc, label); -if (ret == -EPROBE_DEFER ) - ret = -ENODEV ; - -return ret; -} -int gpiod_configure_flags (struct gpio_desc *desc,const char *con_id,unsigned long lflags,enum gpiod_flags dflags);int gpio_set_debounce_timeout (struct gpio_desc *desc,unsigned int debounce);Signature · 1 line
2.34.1
PATCH 2/2 gpiolib: cdev: export the consumer's PID
In reply to Bartosz GolaszewskiIt's useful for user-space to be able to know the PIDs of processes holding GPIO lines in case they have the permissions and need to kill them.
Extend the gpio_v2_line_info structure with the consumer_pid field that's set to the PID of the user-space process or 0 if the user lives in the kernel.
--- drivers/gpio/gpiolib-cdev.c | 2 ++ drivers/gpio/gpiolib.c | 24 +++++++++++++++++++----- drivers/gpio/gpiolib.h | 2 ++ include/uapi/linux/gpio.h | 5 ++++- 4 files changed, 27 insertions(+), 6 deletions(-)
drivers/gpio/gpiolib-cdev.c +2 -0
@@ -2120,6 +2120,8 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,if (desc->label)strscpy (info->consumer, desc->label,sizeof (info->consumer)); + info->consumer_pid = desc->pid; +/* * Userspace only need to know that the kernel is using this GPIO so * it can't use it.
drivers/gpio/gpiolib.c +19 -5
@@ -96,6 +96,11 @@ static inline void desc_set_label(struct gpio_desc *d, const char *label) d->label = label; } +static inline void desc_set_pid (struct gpio_desc *d,pid_t pid) +{ + d->pid = pid; +} +/** * gpio_to_desc - Convert a GPIO number to its descriptor * @gpio: global GPIO number
@@ -1892,7 +1897,8 @@ EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);* on each other, and help provide better diagnostics in debugfs. * They're called even less than the "set direction" calls. */ -static int gpiod_request_commit (struct gpio_desc *desc,const char *label) +static int +gpiod_request_commit (struct gpio_desc *desc,const char *label,pid_t pid) {struct gpio_chip *gc = desc->gdev->chip;int ret;
@@ -1913,6 +1919,7 @@ static int gpiod_request_commit(struct gpio_desc *desc, const char *label)if (test_and_set_bit (FLAG_REQUESTED , &desc->flags) ==0 ) {desc_set_label (desc, label ? :"?" ); +desc_set_pid (desc, pid); }else { ret = -EBUSY ; goto out_free_unlock;
@@ -1987,7 +1994,8 @@ static int validate_desc(const struct gpio_desc *desc, const char *func)return ; \ }while (0 ) -int gpiod_request(struct gpio_desc *desc, const char *label) +static int +gpiod_request_with_pid (struct gpio_desc *desc,const char *label,pid_t pid) {int ret = -EPROBE_DEFER ;struct gpio_device *gdev;
@@ -1996,7 +2004,7 @@ int gpiod_request(struct gpio_desc *desc, const char *label) gdev = desc->gdev;if (try_module_get (gdev->owner)) { - ret =gpiod_request_commit (desc, label); + ret =gpiod_request_commit (desc, label, pid);if (ret)module_put (gdev->owner);else
@@ -2009,11 +2017,16 @@ int gpiod_request(struct gpio_desc *desc, const char *label)return ret; } +int gpiod_request (struct gpio_desc *desc,const char *label) +{ +return gpiod_request_with_pid (desc, label,0 ); +} +int gpiod_request_user (struct gpio_desc *desc,const char *label) {int ret; - ret =gpiod_request (desc, label); + ret =gpiod_request_with_pid (desc, label, current->pid);if (ret == -EPROBE_DEFER ) ret = -ENODEV ;
@@ -2042,6 +2055,7 @@ static bool gpiod_free_commit(struct gpio_desc *desc) }kfree_const (desc->label);desc_set_label (desc,NULL ); +desc_set_pid (desc,0 );clear_bit (FLAG_ACTIVE_LOW , &desc->flags);clear_bit (FLAG_REQUESTED , &desc->flags);clear_bit (FLAG_OPEN_DRAIN , &desc->flags);
@@ -2140,7 +2154,7 @@ struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *gc,return desc; } - ret =gpiod_request_commit (desc, label); + ret =gpiod_request_commit (desc, label,0 );if (ret <0 )return ERR_PTR (ret);
drivers/gpio/gpiolib.h +2 -0
@@ -165,6 +165,8 @@ struct gpio_desc {/* Connection label */ const char *label; +/* Consumer's PID (if consumer is in user-space, otherwise 0) */ +pid_t pid;/* Name of the GPIO */ const char *name;#ifdef CONFIG_OF_DYNAMIC
include/uapi/linux/gpio.h +4 -1
@@ -219,6 +219,8 @@ struct gpio_v2_line_request {* gpio_v2_line_flag, such as %GPIO_V2_LINE_FLAG_ACTIVE_LOW, * %GPIO_V2_LINE_FLAG_OUTPUT etc, added together. * @attrs: the configuration attributes associated with the line +* @consumer_pid: process ID of the user-space consumer or 0 if the consumer +* lives in kernel space * @padding: reserved for future use */ struct gpio_v2_line_info {
@@ -228,8 +230,9 @@ struct gpio_v2_line_info {__u32 num_attrs;__aligned_u64 flags;struct gpio_v2_line_attribute attrs[GPIO_V2_LINE_NUM_ATTRS_MAX ]; +__s32 consumer_pid;/* Space reserved for future use. */ -__u32 padding[4 ]; +__u32 padding[3 ]; };/**
Signature · 1 line
2.34.1
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 7 lines · Bartosz Golaszewski
It's useful for user-space to be able to know the PIDs of processes holding GPIO lines in case they have the permissions and need to kill them.
Extend the
gpio_v2_line_infostructure with theconsumer_pidfield that's set to the PID of the user-space process or 0 if the user lives in the kernel.
...
drivers/gpio/gpiolib.c int gpiod_request(struct gpio_desc *desc, const char *label) · line 2022
Quoted 3 lines
drivers/gpio/gpiolib.c +3
-0+int gpiod_request (struct gpio_desc *desc,const char *label) +{ +return gpiod_request_with_pid (desc, label,0 );
Why not -1? I would expect this is the usual way of telling "don't use this PID".
Quoted 1 line
+}
...
drivers/gpio/gpiolib.c static bool gpiod_free_commit(struct gpio_desc *desc) · line 2058
Quoted 1 line
drivers/gpio/gpiolib.c +1
-0+desc_set_pid (desc,0 );
Ditto.
...
drivers/gpio/gpiolib.c struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *gc, · line 2157
Quoted 1 line
drivers/gpio/gpiolib.c +1
-0+ ret =gpiod_request_commit (desc, label,0 );
Ditto.
Signature · 2 lines
With Best Regards, Andy Shevchenko
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
In reply to Bartosz Golaszewski+Cc: Kees
Quoted 7 lines · Bartosz Golaszewski
It's useful for user-space to be able to know the PIDs of processes holding GPIO lines in case they have the permissions and need to kill them.
Extend the
gpio_v2_line_infostructure with theconsumer_pidfield that's set to the PID of the user-space process or 0 if the user lives in the kernel.
I'm wondering if there is any security implications and this PID can be abused.
Signature · 2 lines
With Best Regards, Andy Shevchenko
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 8 lines · Andy Shevchenko
+Cc: Kees
Quoted 4 lines · Bartosz Golaszewski
It's useful for user-space to be able to know the PIDs of processes holding GPIO lines in case they have the permissions and need to kill them.
Quoted 7 lines
Quoted 3 lines
Extend the
gpio_v2_line_infostructure with theconsumer_pidfield that's set to the PID of the user-space process or 0 if the user lives in the kernel.I'm wondering if there is any security implications and this PID can be abused.
I was wondering about that too but nothing came to my mind. By default any user - even one who doesn't have permissions to access /dev/gpiochip* - can already figure out by browsing /proc/$PID/fd that a process does have some lines requested - but not which exactly. This provides that additional bit of knowledge to users who already do have permissions to call ioctl() on /dev/gpiochip*.
Bart
Kent Gibson
reviewerRe: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
In reply to Bartosz GolaszewskiQuoted 4 lines · Bartosz Golaszewski
It's useful for user-space to be able to know the PIDs of processes holding GPIO lines in case they have the permissions and need to kill them.
"the PID of the process holding a GPIO line"
As written it could be interpreted to imply that multiple processes can hold a line, so go singular to remove that possibility.
Quoted 140 lines
Extend the
gpio_v2_line_infostructure with theconsumer_pidfield that's set to the PID of the user-space process or 0 if the user lives in the kernel.Signed-off-by Bartosz Golaszewski <[email protected]>--- drivers/gpio/gpiolib-cdev.c | 2 ++ drivers/gpio/gpiolib.c | 24 +++++++++++++++++++----- drivers/gpio/gpiolib.h | 2 ++ include/uapi/linux/gpio.h | 5 ++++- 4 files changed, 27 insertions(+), 6 deletions(-)drivers/gpio/gpiolib-cdev.c +2
-0@@ -2120,6 +2120,8 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,if (desc->label)strscpy (info->consumer, desc->label,sizeof (info->consumer)); + info->consumer_pid = desc->pid; +/* * Userspace only need to know that the kernel is using this GPIO so * it can't use it. drivers/gpio/gpiolib.c +19
-5@@ -96,6 +96,11 @@ static inline void desc_set_label(struct gpio_desc *d, const char *label) d->label = label; } +static inline void desc_set_pid (struct gpio_desc *d,pid_t pid) +{ + d->pid = pid; +} +/** * gpio_to_desc - Convert a GPIO number to its descriptor * @gpio: global GPIO number @@ -1892,7 +1897,8 @@ EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);* on each other, and help provide better diagnostics in debugfs. * They're called even less than the "set direction" calls. */ -static int gpiod_request_commit (struct gpio_desc *desc,const char *label) +static int +gpiod_request_commit (struct gpio_desc *desc,const char *label,pid_t pid) {struct gpio_chip *gc = desc->gdev->chip;int ret;@@ -1913,6 +1919,7 @@ static int gpiod_request_commit(struct gpio_desc *desc, const char *label)if (test_and_set_bit (FLAG_REQUESTED , &desc->flags) ==0 ) {desc_set_label (desc, label ? :"?" ); +desc_set_pid (desc, pid); }else { ret = -EBUSY ; goto out_free_unlock;@@ -1987,7 +1994,8 @@ static int validate_desc(const struct gpio_desc *desc, const char *func)return ; \ }while (0 ) -int gpiod_request(struct gpio_desc *desc, const char *label) +static int +gpiod_request_with_pid (struct gpio_desc *desc,const char *label,pid_t pid) {int ret = -EPROBE_DEFER ;struct gpio_device *gdev;@@ -1996,7 +2004,7 @@ int gpiod_request(struct gpio_desc *desc, const char *label) gdev = desc->gdev;if (try_module_get (gdev->owner)) { - ret =gpiod_request_commit (desc, label); + ret =gpiod_request_commit (desc, label, pid);if (ret)module_put (gdev->owner);else @@ -2009,11 +2017,16 @@ int gpiod_request(struct gpio_desc *desc, const char *label)return ret; } +int gpiod_request (struct gpio_desc *desc,const char *label) +{ +return gpiod_request_with_pid (desc, label,0 ); +} +int gpiod_request_user (struct gpio_desc *desc,const char *label) {int ret; - ret =gpiod_request (desc, label); + ret =gpiod_request_with_pid (desc, label, current->pid);if (ret == -EPROBE_DEFER ) ret = -ENODEV ;@@ -2042,6 +2055,7 @@ static bool gpiod_free_commit(struct gpio_desc *desc) }kfree_const (desc->label);desc_set_label (desc,NULL ); +desc_set_pid (desc,0 );clear_bit (FLAG_ACTIVE_LOW , &desc->flags);clear_bit (FLAG_REQUESTED , &desc->flags);clear_bit (FLAG_OPEN_DRAIN , &desc->flags);@@ -2140,7 +2154,7 @@ struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *gc,return desc; } - ret =gpiod_request_commit (desc, label); + ret =gpiod_request_commit (desc, label,0 );if (ret <0 )return ERR_PTR (ret);drivers/gpio/gpiolib.h +2
-0@@ -165,6 +165,8 @@ struct gpio_desc {/* Connection label */ const char *label; +/* Consumer's PID (if consumer is in user-space, otherwise 0) */ +pid_t pid;/* Name of the GPIO */ const char *name;#ifdef CONFIG_OF_DYNAMIC include/uapi/linux/gpio.h +2
-0@@ -219,6 +219,8 @@ struct gpio_v2_line_request {* gpio_v2_line_flag, such as %GPIO_V2_LINE_FLAG_ACTIVE_LOW, * %GPIO_V2_LINE_FLAG_OUTPUT etc, added together. * @attrs: the configuration attributes associated with the line +* @consumer_pid: process ID of the user-space consumer or 0 if the consumer +* lives in kernel space * @padding: reserved for future use */ struct gpio_v2_line_info {
include/uapi/linux/gpio.h struct gpio_v2_line_info { · line 233
Quoted 4 lines
include/uapi/linux/gpio.h +1
-0@@ -228,8 +230,9 @@ struct gpio_v2_line_info {__u32 num_attrs;__aligned_u64 flags;struct gpio_v2_line_attribute attrs[GPIO_V2_LINE_NUM_ATTRS_MAX ]; +__s32 consumer_pid;
My knee-jerk reaction here was to make the pid unsigned, as we never pass a negative PID.
Keeping in mind that the existing kernel will return 0 for this field (the existing padding), so 0 needs to be excluded from valid PIDs anyway.
Andy suggests returning -1 for kernel held lines.
In that case 0 would mean "old kernel", while -1 would mean "kernel held".
As libgpiod will have to convert the 0 to -1 when returning the PID to user-space as a pid_t, I'm good with the uAPI using 0 to mean "no PID available" for all cases. I'm still open to passing -1 for kernel held is there is a use case for it, but I don't see one.
Cheers,
Kent.
Quoted 9 lines
include/uapi/linux/gpio.h +1
-1/* Space reserved for future use. */ -__u32 padding[4 ]; +__u32 padding[3 ]; };/** Signature · 1 line
2.34.1
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 163 lines · Kent Gibson
Quoted 4 lines · Bartosz Golaszewski
It's useful for user-space to be able to know the PIDs of processes holding GPIO lines in case they have the permissions and need to kill them.
"the PID of the process holding a GPIO line"
As written it could be interpreted to imply that multiple processes can hold a line, so go singular to remove that possibility.
Quoted 140 lines
Extend the
gpio_v2_line_infostructure with theconsumer_pidfield that's set to the PID of the user-space process or 0 if the user lives in the kernel.Signed-off-by Bartosz Golaszewski <[email protected]>--- drivers/gpio/gpiolib-cdev.c | 2 ++ drivers/gpio/gpiolib.c | 24 +++++++++++++++++++----- drivers/gpio/gpiolib.h | 2 ++ include/uapi/linux/gpio.h | 5 ++++- 4 files changed, 27 insertions(+), 6 deletions(-)drivers/gpio/gpiolib-cdev.c +2
-0@@ -2120,6 +2120,8 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,if (desc->label)strscpy (info->consumer, desc->label,sizeof (info->consumer)); + info->consumer_pid = desc->pid; +/* * Userspace only need to know that the kernel is using this GPIO so * it can't use it. drivers/gpio/gpiolib.c +19
-5@@ -96,6 +96,11 @@ static inline void desc_set_label(struct gpio_desc *d, const char *label) d->label = label; } +static inline void desc_set_pid (struct gpio_desc *d,pid_t pid) +{ + d->pid = pid; +} +/** * gpio_to_desc - Convert a GPIO number to its descriptor * @gpio: global GPIO number @@ -1892,7 +1897,8 @@ EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);* on each other, and help provide better diagnostics in debugfs. * They're called even less than the "set direction" calls. */ -static int gpiod_request_commit (struct gpio_desc *desc,const char *label) +static int +gpiod_request_commit (struct gpio_desc *desc,const char *label,pid_t pid) {struct gpio_chip *gc = desc->gdev->chip;int ret;@@ -1913,6 +1919,7 @@ static int gpiod_request_commit(struct gpio_desc *desc, const char *label)if (test_and_set_bit (FLAG_REQUESTED , &desc->flags) ==0 ) {desc_set_label (desc, label ? :"?" ); +desc_set_pid (desc, pid); }else { ret = -EBUSY ; goto out_free_unlock;@@ -1987,7 +1994,8 @@ static int validate_desc(const struct gpio_desc *desc, const char *func)return ; \ }while (0 ) -int gpiod_request(struct gpio_desc *desc, const char *label) +static int +gpiod_request_with_pid (struct gpio_desc *desc,const char *label,pid_t pid) {int ret = -EPROBE_DEFER ;struct gpio_device *gdev;@@ -1996,7 +2004,7 @@ int gpiod_request(struct gpio_desc *desc, const char *label) gdev = desc->gdev;if (try_module_get (gdev->owner)) { - ret =gpiod_request_commit (desc, label); + ret =gpiod_request_commit (desc, label, pid);if (ret)module_put (gdev->owner);else @@ -2009,11 +2017,16 @@ int gpiod_request(struct gpio_desc *desc, const char *label)return ret; } +int gpiod_request (struct gpio_desc *desc,const char *label) +{ +return gpiod_request_with_pid (desc, label,0 ); +} +int gpiod_request_user (struct gpio_desc *desc,const char *label) {int ret; - ret =gpiod_request (desc, label); + ret =gpiod_request_with_pid (desc, label, current->pid);if (ret == -EPROBE_DEFER ) ret = -ENODEV ;@@ -2042,6 +2055,7 @@ static bool gpiod_free_commit(struct gpio_desc *desc) }kfree_const (desc->label);desc_set_label (desc,NULL ); +desc_set_pid (desc,0 );clear_bit (FLAG_ACTIVE_LOW , &desc->flags);clear_bit (FLAG_REQUESTED , &desc->flags);clear_bit (FLAG_OPEN_DRAIN , &desc->flags);@@ -2140,7 +2154,7 @@ struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *gc,return desc; } - ret =gpiod_request_commit (desc, label); + ret =gpiod_request_commit (desc, label,0 );if (ret <0 )return ERR_PTR (ret);drivers/gpio/gpiolib.h +2
-0@@ -165,6 +165,8 @@ struct gpio_desc {/* Connection label */ const char *label; +/* Consumer's PID (if consumer is in user-space, otherwise 0) */ +pid_t pid;/* Name of the GPIO */ const char *name;#ifdef CONFIG_OF_DYNAMIC include/uapi/linux/gpio.h +2
-0@@ -219,6 +219,8 @@ struct gpio_v2_line_request {* gpio_v2_line_flag, such as %GPIO_V2_LINE_FLAG_ACTIVE_LOW, * %GPIO_V2_LINE_FLAG_OUTPUT etc, added together. * @attrs: the configuration attributes associated with the line +* @consumer_pid: process ID of the user-space consumer or 0 if the consumer +* lives in kernel space * @padding: reserved for future use */ struct gpio_v2_line_info {include/uapi/linux/gpio.h struct gpio_v2_line_info { · line 233
Quoted 4 lines
include/uapi/linux/gpio.h +1
-0@@ -228,8 +230,9 @@ struct gpio_v2_line_info {__u32 num_attrs;__aligned_u64 flags;struct gpio_v2_line_attribute attrs[GPIO_V2_LINE_NUM_ATTRS_MAX ]; +__s32 consumer_pid;My knee-jerk reaction here was to make the pid unsigned, as we never pass a negative PID.
Keeping in mind that the existing kernel will return 0 for this field (the existing padding), so 0 needs to be excluded from valid PIDs anyway.
Quoted 9 lines
Andy suggests returning -1 for kernel held lines.
In that case 0 would mean "old kernel", while -1 would mean "kernel held".As libgpiod will have to convert the 0 to -1 when returning the PID to user-space as a
pid_t, I'm good with the uAPI using 0 to mean "no PID available" for all cases. I'm still open to passing -1 for kernel held is there is a use case for it, but I don't see one.
Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on fork() (kind of like the close() on exec flag).
I need to think about it more.
Bart
Kent Gibson
reviewerRe: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 186 lines · Bartosz Golaszewski
Quoted 163 lines · Kent Gibson
Quoted 4 lines · Bartosz Golaszewski
It's useful for user-space to be able to know the PIDs of processes holding GPIO lines in case they have the permissions and need to kill them.
"the PID of the process holding a GPIO line"
As written it could be interpreted to imply that multiple processes can hold a line, so go singular to remove that possibility.
Quoted 140 lines
Extend the
gpio_v2_line_infostructure with theconsumer_pidfield that's set to the PID of the user-space process or 0 if the user lives in the kernel.Signed-off-by Bartosz Golaszewski <[email protected]>--- drivers/gpio/gpiolib-cdev.c | 2 ++ drivers/gpio/gpiolib.c | 24 +++++++++++++++++++----- drivers/gpio/gpiolib.h | 2 ++ include/uapi/linux/gpio.h | 5 ++++- 4 files changed, 27 insertions(+), 6 deletions(-)drivers/gpio/gpiolib-cdev.c +2
-0@@ -2120,6 +2120,8 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,if (desc->label)strscpy (info->consumer, desc->label,sizeof (info->consumer)); + info->consumer_pid = desc->pid; +/* * Userspace only need to know that the kernel is using this GPIO so * it can't use it. drivers/gpio/gpiolib.c +19
-5@@ -96,6 +96,11 @@ static inline void desc_set_label(struct gpio_desc *d, const char *label) d->label = label; } +static inline void desc_set_pid (struct gpio_desc *d,pid_t pid) +{ + d->pid = pid; +} +/** * gpio_to_desc - Convert a GPIO number to its descriptor * @gpio: global GPIO number @@ -1892,7 +1897,8 @@ EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);* on each other, and help provide better diagnostics in debugfs. * They're called even less than the "set direction" calls. */ -static int gpiod_request_commit (struct gpio_desc *desc,const char *label) +static int +gpiod_request_commit (struct gpio_desc *desc,const char *label,pid_t pid) {struct gpio_chip *gc = desc->gdev->chip;int ret;@@ -1913,6 +1919,7 @@ static int gpiod_request_commit(struct gpio_desc *desc, const char *label)if (test_and_set_bit (FLAG_REQUESTED , &desc->flags) ==0 ) {desc_set_label (desc, label ? :"?" ); +desc_set_pid (desc, pid); }else { ret = -EBUSY ; goto out_free_unlock;@@ -1987,7 +1994,8 @@ static int validate_desc(const struct gpio_desc *desc, const char *func)return ; \ }while (0 ) -int gpiod_request(struct gpio_desc *desc, const char *label) +static int +gpiod_request_with_pid (struct gpio_desc *desc,const char *label,pid_t pid) {int ret = -EPROBE_DEFER ;struct gpio_device *gdev;@@ -1996,7 +2004,7 @@ int gpiod_request(struct gpio_desc *desc, const char *label) gdev = desc->gdev;if (try_module_get (gdev->owner)) { - ret =gpiod_request_commit (desc, label); + ret =gpiod_request_commit (desc, label, pid);if (ret)module_put (gdev->owner);else @@ -2009,11 +2017,16 @@ int gpiod_request(struct gpio_desc *desc, const char *label)return ret; } +int gpiod_request (struct gpio_desc *desc,const char *label) +{ +return gpiod_request_with_pid (desc, label,0 ); +} +int gpiod_request_user (struct gpio_desc *desc,const char *label) {int ret; - ret =gpiod_request (desc, label); + ret =gpiod_request_with_pid (desc, label, current->pid);if (ret == -EPROBE_DEFER ) ret = -ENODEV ;@@ -2042,6 +2055,7 @@ static bool gpiod_free_commit(struct gpio_desc *desc) }kfree_const (desc->label);desc_set_label (desc,NULL ); +desc_set_pid (desc,0 );clear_bit (FLAG_ACTIVE_LOW , &desc->flags);clear_bit (FLAG_REQUESTED , &desc->flags);clear_bit (FLAG_OPEN_DRAIN , &desc->flags);@@ -2140,7 +2154,7 @@ struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *gc,return desc; } - ret =gpiod_request_commit (desc, label); + ret =gpiod_request_commit (desc, label,0 );if (ret <0 )return ERR_PTR (ret);drivers/gpio/gpiolib.h +2
-0@@ -165,6 +165,8 @@ struct gpio_desc {/* Connection label */ const char *label; +/* Consumer's PID (if consumer is in user-space, otherwise 0) */ +pid_t pid;/* Name of the GPIO */ const char *name;#ifdef CONFIG_OF_DYNAMIC include/uapi/linux/gpio.h +2
-0@@ -219,6 +219,8 @@ struct gpio_v2_line_request {* gpio_v2_line_flag, such as %GPIO_V2_LINE_FLAG_ACTIVE_LOW, * %GPIO_V2_LINE_FLAG_OUTPUT etc, added together. * @attrs: the configuration attributes associated with the line +* @consumer_pid: process ID of the user-space consumer or 0 if the consumer +* lives in kernel space * @padding: reserved for future use */ struct gpio_v2_line_info {include/uapi/linux/gpio.h struct gpio_v2_line_info { · line 233
Quoted 4 lines
include/uapi/linux/gpio.h +1
-0@@ -228,8 +230,9 @@ struct gpio_v2_line_info {__u32 num_attrs;__aligned_u64 flags;struct gpio_v2_line_attribute attrs[GPIO_V2_LINE_NUM_ATTRS_MAX ]; +__s32 consumer_pid;My knee-jerk reaction here was to make the pid unsigned, as we never pass a negative PID.
Keeping in mind that the existing kernel will return 0 for this field (the existing padding), so 0 needs to be excluded from valid PIDs anyway.Quoted 9 lines
Andy suggests returning -1 for kernel held lines.
In that case 0 would mean "old kernel", while -1 would mean "kernel held".As libgpiod will have to convert the 0 to -1 when returning the PID to user-space as a
pid_t, I'm good with the uAPI using 0 to mean "no PID available" for all cases. I'm still open to passing -1 for kernel held is there is a use case for it, but I don't see one.Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
Quoted 7 lines
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).I need to think about it more.
I thought the O_CLOEXEC was set on the request fds exactly to prevent this case - only one process can hold the request fd.
Cheers,
Kent.
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 1 line · Kent Gibson
[snip]
Quoted 34 lines
Quoted 34 lines
Quoted 7 lines
My knee-jerk reaction here was to make the pid unsigned, as we never pass a negative PID.
Keeping in mind that the existing kernel will return 0 for this field (the existing padding), so 0 needs to be excluded from valid PIDs anyway.Quoted 9 lines
Andy suggests returning -1 for kernel held lines.
In that case 0 would mean "old kernel", while -1 would mean "kernel held".As libgpiod will have to convert the 0 to -1 when returning the PID to user-space as a
pid_t, I'm good with the uAPI using 0 to mean "no PID available" for all cases. I'm still open to passing -1 for kernel held is there is a use case for it, but I don't see one.Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).
Quoted 6 lines
Quoted 2 lines
I need to think about it more.
I thought the
O_CLOEXECwas set on the request fds exactly to prevent this case - only one process can hold the request fd.
O_CLOEXEC means "close on exec" not "close on fork". When you fork, you inherit all file descriptors from your parent. Only once you call execve() are the fds with this flag closed *in the child*.
Bart
Kent Gibson
reviewerRe: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 26 lines · Bartosz Golaszewski
Quoted 1 line · Kent Gibson
[snip]
Quoted 21 lines
Quoted 20 lines
Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).I need to think about it more.
Quoted 8 lines
Quoted 3 lines
I thought the
O_CLOEXECwas set on the request fds exactly to prevent this case - only one process can hold the request fd.
O_CLOEXECmeans "close on exec" not "close on fork". When you fork, you inherit all file descriptors from your parent. Only once you callexecve()are the fds with this flag closed *in the child*.
Ah, ok.
You want to pass request fd ownership from parent to child?? Why not lock ownership to the parent, so O_CLOFORK, were that available?
Cheers,
Kent.
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 37 lines · Kent Gibson
Quoted 26 lines · Bartosz Golaszewski
Quoted 1 line · Kent Gibson
[snip]
Quoted 21 lines
Quoted 20 lines
Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).I need to think about it more.
Quoted 8 lines
Quoted 3 lines
I thought the
O_CLOEXECwas set on the request fds exactly to prevent this case - only one process can hold the request fd.
O_CLOEXECmeans "close on exec" not "close on fork". When you fork, you inherit all file descriptors from your parent. Only once you callexecve()are the fds with this flag closed *in the child*.
Quoted 5 lines
Ah, ok.
You want to pass request fd ownership from parent to child?? Why not lock ownership to the parent, soO_CLOFORK, were that available?
Because what if we want to request a line and then daemonize i.e. fork and exit in parent? It makes much more sense to keep the lines requested in the child IMO.
During the BoF at Linux Plumbers it was suggested to use /proc/$PID/fdinfo to expose the information about which lines are requested but I can't figure out a way to do it elegantly.
Bart
Kent Gibson
reviewerRe: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 44 lines · Bartosz Golaszewski
Quoted 37 lines · Kent Gibson
Quoted 26 lines · Bartosz Golaszewski
Quoted 1 line · Kent Gibson
[snip]
Quoted 21 lines
Quoted 20 lines
Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).I need to think about it more.
Quoted 8 lines
Quoted 3 lines
I thought the
O_CLOEXECwas set on the request fds exactly to prevent this case - only one process can hold the request fd.
O_CLOEXECmeans "close on exec" not "close on fork". When you fork, you inherit all file descriptors from your parent. Only once you callexecve()are the fds with this flag closed *in the child*.Quoted 5 lines
Ah, ok.
You want to pass request fd ownership from parent to child?? Why not lock ownership to the parent, soO_CLOFORK, were that available?
Quoted 4 lines
Because what if we want to request a line and then daemonize i.e. fork and exit in parent? It makes much more sense to keep the lines requested in the child IMO.
Then you are doing it backwards - daemonize first ;-).
Generally speaking, doesn't transfer of resource ownership to the forked child create havoc in multi-threaded apps? i.e. one thread requests a resource, another forks. The parent thread unknowingly loses ownership, and the forked child process only starts with a replica of the forking thread.
Quoted 4 lines
During the BoF at Linux Plumbers it was suggested to use
/proc/$PID/fdinfoto expose the information about which lines are requested but I can't figure out a way to do it elegantly.
Yeah, missed that :-(.
Makes sense.
As each request fd can contain multiple lines on a particular chip, you would need to identify the gpiochip and the offsets for that request. So two fields - the gpiochip path, and the list of offsets.
Is that already too clunky or am I missing something?
Cheers,
Kent.
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 51 lines · Kent Gibson
Quoted 44 lines · Bartosz Golaszewski
Quoted 37 lines · Kent Gibson
Quoted 26 lines · Bartosz Golaszewski
Quoted 1 line · Kent Gibson
[snip]
Quoted 21 lines
Quoted 20 lines
Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).I need to think about it more.
Quoted 8 lines
Quoted 3 lines
I thought the
O_CLOEXECwas set on the request fds exactly to prevent this case - only one process can hold the request fd.
O_CLOEXECmeans "close on exec" not "close on fork". When you fork, you inherit all file descriptors from your parent. Only once you callexecve()are the fds with this flag closed *in the child*.Quoted 5 lines
Ah, ok.
You want to pass request fd ownership from parent to child?? Why not lock ownership to the parent, soO_CLOFORK, were that available?Quoted 4 lines
Because what if we want to request a line and then daemonize i.e. fork and exit in parent? It makes much more sense to keep the lines requested in the child IMO.
Quoted 8 lines
Then you are doing it backwards - daemonize first ;-).
Generally speaking, doesn't transfer of resource ownership to the forked child create havoc in multi-threaded apps? i.e. one thread requests a resource, another forks. The parent thread unknowingly loses ownership, and the forked child process only starts with a replica of the forking thread.
Yeah, sounds like a bad idea.
Quoted 7 lines
Quoted 4 lines
During the BoF at Linux Plumbers it was suggested to use
/proc/$PID/fdinfoto expose the information about which lines are requested but I can't figure out a way to do it elegantly.Yeah, missed that :-(.
Quoted 8 lines
Makes sense.
As each request fd can contain multiple lines on a particular chip, you would need to identify the gpiochip and the offsets for that request. So two fields - the gpiochip path, and the list of offsets.
Is that already too clunky or am I missing something?
It's worse than that - we don't know the character device's filesystem path in gpiolib. Nor should we, as we can be in a different fs namespace when checking it than in which we were when we opened the device (which is also another concern for storing the path to the character device in struct gpiod_chip - unless we specify explicitly that it's the path that was used to open it). Since we don't know it - we can only get it from the file descriptor that the requesting process got after calling open() on the GPIO device. But this fd may have been closed in the meantime. I think I opened a can of worms with this one. :)
Bartosz
Kent Gibson
reviewerRe: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 79 lines · Bartosz Golaszewski
Quoted 51 lines · Kent Gibson
Quoted 44 lines · Bartosz Golaszewski
Quoted 37 lines · Kent Gibson
Quoted 26 lines · Bartosz Golaszewski
Quoted 1 line · Kent Gibson
[snip]
Quoted 21 lines
Quoted 20 lines
Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).I need to think about it more.
Quoted 8 lines
Quoted 3 lines
I thought the
O_CLOEXECwas set on the request fds exactly to prevent this case - only one process can hold the request fd.
O_CLOEXECmeans "close on exec" not "close on fork". When you fork, you inherit all file descriptors from your parent. Only once you callexecve()are the fds with this flag closed *in the child*.Quoted 5 lines
Ah, ok.
You want to pass request fd ownership from parent to child?? Why not lock ownership to the parent, soO_CLOFORK, were that available?Quoted 4 lines
Because what if we want to request a line and then daemonize i.e. fork and exit in parent? It makes much more sense to keep the lines requested in the child IMO.
Quoted 8 lines
Then you are doing it backwards - daemonize first ;-).
Generally speaking, doesn't transfer of resource ownership to the forked child create havoc in multi-threaded apps? i.e. one thread requests a resource, another forks. The parent thread unknowingly loses ownership, and the forked child process only starts with a replica of the forking thread.
Yeah, sounds like a bad idea.
Quoted 7 lines
Quoted 4 lines
During the BoF at Linux Plumbers it was suggested to use
/proc/$PID/fdinfoto expose the information about which lines are requested but I can't figure out a way to do it elegantly.Yeah, missed that :-(.
Quoted 8 lines
Makes sense.
As each request fd can contain multiple lines on a particular chip, you would need to identify the gpiochip and the offsets for that request. So two fields - the gpiochip path, and the list of offsets.
Is that already too clunky or am I missing something?
Quoted 11 lines
It's worse than that - we don't know the character device's filesystem path in gpiolib. Nor should we, as we can be in a different fs namespace when checking it than in which we were when we opened the device (which is also another concern for storing the path to the character device in struct
gpiod_chip- unless we specify explicitly that it's the path that was used to open it). Since we don't know it - we can only get it from the file descriptor that the requesting process got after callingopen()on the GPIO device. But this fd may have been closed in the meantime. I think I opened a can of worms with this one. :)
Forgot that we don't have the path readily available in the kernel - would device name suffice?
Cheers,
Kent.
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 93 lines · Kent Gibson
Quoted 79 lines · Bartosz Golaszewski
Quoted 51 lines · Kent Gibson
Quoted 44 lines · Bartosz Golaszewski
Quoted 37 lines · Kent Gibson
Quoted 26 lines · Bartosz Golaszewski
Quoted 1 line · Kent Gibson
[snip]
Quoted 21 lines
Quoted 20 lines
Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).I need to think about it more.
Quoted 8 lines
Quoted 3 lines
I thought the
O_CLOEXECwas set on the request fds exactly to prevent this case - only one process can hold the request fd.
O_CLOEXECmeans "close on exec" not "close on fork". When you fork, you inherit all file descriptors from your parent. Only once you callexecve()are the fds with this flag closed *in the child*.Quoted 5 lines
Ah, ok.
You want to pass request fd ownership from parent to child?? Why not lock ownership to the parent, soO_CLOFORK, were that available?Quoted 4 lines
Because what if we want to request a line and then daemonize i.e. fork and exit in parent? It makes much more sense to keep the lines requested in the child IMO.
Quoted 8 lines
Then you are doing it backwards - daemonize first ;-).
Generally speaking, doesn't transfer of resource ownership to the forked child create havoc in multi-threaded apps? i.e. one thread requests a resource, another forks. The parent thread unknowingly loses ownership, and the forked child process only starts with a replica of the forking thread.
Yeah, sounds like a bad idea.
Quoted 7 lines
Quoted 4 lines
During the BoF at Linux Plumbers it was suggested to use
/proc/$PID/fdinfoto expose the information about which lines are requested but I can't figure out a way to do it elegantly.Yeah, missed that :-(.
Quoted 8 lines
Makes sense.
As each request fd can contain multiple lines on a particular chip, you would need to identify the gpiochip and the offsets for that request. So two fields - the gpiochip path, and the list of offsets.
Is that already too clunky or am I missing something?
Quoted 11 lines
It's worse than that - we don't know the character device's filesystem path in gpiolib. Nor should we, as we can be in a different fs namespace when checking it than in which we were when we opened the device (which is also another concern for storing the path to the character device in struct
gpiod_chip- unless we specify explicitly that it's the path that was used to open it). Since we don't know it - we can only get it from the file descriptor that the requesting process got after callingopen()on the GPIO device. But this fd may have been closed in the meantime. I think I opened a can of worms with this one. :)
Quoted 2 lines
Forgot that we don't have the path readily available in the kernel - would device name suffice?
Maybe. I'm looking at what fdinfo shows in my vm and see things like:
$ cat /proc/2353/fdinfo/10 pos: 0 flags: 02004000 mnt_id: 15 ino: 1052 inotify wd:1 ino:1 sdev:3c mask:fce ignored_mask:0 fhandle-bytes:c fhandle-type:1 f_handle:7f0dd9400100000000000000
I don't see any tools/libs readily available for parsing these. In libgpiod, if the user wanted to read the PID of the owner of the line, we'd need to manually go through the list of all fdinfo entries we have permissions to access and compare those against the line w'ere checking.
We'd need of course first expose that info like:
gpio chip:gpiochip2 lines:0,3,4,7
Does that make sense?
Bart
Kent Gibson
reviewerRe: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 99 lines · Bartosz Golaszewski
Quoted 93 lines · Kent Gibson
Quoted 79 lines · Bartosz Golaszewski
Quoted 51 lines · Kent Gibson
Quoted 44 lines · Bartosz Golaszewski
Quoted 37 lines · Kent Gibson
Quoted 26 lines · Bartosz Golaszewski
Quoted 1 line · Kent Gibson
[snip]
Quoted 21 lines
Quoted 20 lines
Using -1 sounds good but I've just realized there's a different problem. A process holding a file descriptor may fork and both the parent and the child will keep the same file descriptors open. Now we'll have two processes (with different PIDs) holding the same GPIO lines (specifically holding a file descriptor to the same anonymous inode).
This already poses a problem for this patch as we'd need to return an array of PIDs which we don't have the space for but also is a situation which we haven't discussed previously IIRC - two processes keeping the same GPIO lines requested.
I don't have any good idea on how to address this yet. One thing off the top of my head is: close the parent's file descriptor from kernel space (is it even possible?) on
fork()(kind of like theclose()on exec flag).I need to think about it more.
Quoted 8 lines
Quoted 3 lines
I thought the
O_CLOEXECwas set on the request fds exactly to prevent this case - only one process can hold the request fd.
O_CLOEXECmeans "close on exec" not "close on fork". When you fork, you inherit all file descriptors from your parent. Only once you callexecve()are the fds with this flag closed *in the child*.Quoted 5 lines
Ah, ok.
You want to pass request fd ownership from parent to child?? Why not lock ownership to the parent, soO_CLOFORK, were that available?Quoted 4 lines
Because what if we want to request a line and then daemonize i.e. fork and exit in parent? It makes much more sense to keep the lines requested in the child IMO.
Quoted 8 lines
Then you are doing it backwards - daemonize first ;-).
Generally speaking, doesn't transfer of resource ownership to the forked child create havoc in multi-threaded apps? i.e. one thread requests a resource, another forks. The parent thread unknowingly loses ownership, and the forked child process only starts with a replica of the forking thread.
Yeah, sounds like a bad idea.
Quoted 7 lines
Quoted 4 lines
During the BoF at Linux Plumbers it was suggested to use
/proc/$PID/fdinfoto expose the information about which lines are requested but I can't figure out a way to do it elegantly.Yeah, missed that :-(.
Quoted 8 lines
Makes sense.
As each request fd can contain multiple lines on a particular chip, you would need to identify the gpiochip and the offsets for that request. So two fields - the gpiochip path, and the list of offsets.
Is that already too clunky or am I missing something?
Quoted 11 lines
It's worse than that - we don't know the character device's filesystem path in gpiolib. Nor should we, as we can be in a different fs namespace when checking it than in which we were when we opened the device (which is also another concern for storing the path to the character device in struct
gpiod_chip- unless we specify explicitly that it's the path that was used to open it). Since we don't know it - we can only get it from the file descriptor that the requesting process got after callingopen()on the GPIO device. But this fd may have been closed in the meantime. I think I opened a can of worms with this one. :)Quoted 2 lines
Forgot that we don't have the path readily available in the kernel - would device name suffice?
Maybe. I'm looking at what fdinfo shows in my vm and see things like:
Quoted 8 lines
$ cat /proc/2353/fdinfo/10 pos: 0 flags: 02004000 mnt_id: 15 ino: 1052 inotify wd:1 ino:1 sdev:3c mask:fce ignored_mask:0 fhandle-bytes:c fhandle-type:1 f_handle:7f0dd9400100000000000000
For a gpio fd (reported as gpio-line by lsof) I only get the basics:
pos: 0
flags: 02000000mnt_id: 14
ino: 7661
Quoted 6 lines
I don't see any
tools/libsreadily available for parsing these. In libgpiod, if the user wanted to read the PID of the owner of the line, we'd need to manually go through the list of all fdinfo entries we have permissions to access and compare those against the line w'ere checking.
Quoted 6 lines
We'd need of course first expose that info like:
gpio chip:gpiochip2 lines:0,3,4,7
Does that make sense?
Makes sense to me, though I don't claim to know anything about fdinfo field formatting.
e.g. I also see fdinfo fields like this:
eventfd-count: 0
eventfd-id: 1
so
gpio-chip: gpiochip2 gpio-lines: 0,3,4,7
might be ok too.
Cheers,
Kent.
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 2 lines · Kent Gibson
Quoted 1 line · Bartosz Golaszewski
On Tue, Sep 13, 2022 at 4:55 PM Kent Gibson <[email protected]> wrote:
...
Quoted 14 lines
Quoted 5 lines
We'd need of course first expose that info like:
gpio chip:gpiochip2 lines:0,3,4,7
Does that make sense?
Makes sense to me, though I don't claim to know anything about fdinfo field formatting.
e.g. I also see fdinfo fields like this:
eventfd-count: 0
eventfd-id: 1
Quoted 6 lines
so
gpio-chip: gpiochip2 gpio-lines: 0,3,4,7might be ok too.
Always think about two or more GPIO chips in the same process with 1 or more lines requested from each of them.
Signature · 2 lines
With Best Regards, Andy Shevchenko
Re: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
Quoted 23 lines · Andy Shevchenko
Quoted 2 lines · Kent Gibson
Quoted 1 line · Bartosz Golaszewski
On Tue, Sep 13, 2022 at 4:55 PM Kent Gibson <[email protected]> wrote:
...
Quoted 16 lines
Quoted 5 lines
We'd need of course first expose that info like:
gpio chip:gpiochip2 lines:0,3,4,7
Does that make sense?
Makes sense to me, though I don't claim to know anything about fdinfo field formatting.
e.g. I also see fdinfo fields like this:
eventfd-count: 0
eventfd-id: 1so
Quoted 8 lines
Quoted 4 lines
gpio-chip: gpiochip2 gpio-lines: 0,3,4,7might be ok too.
Always think about two or more GPIO chips in the same process with 1 or more lines requested from each of them.
That is fine because every file descriptor has its own fdinfo entry and so one entry can only contain information about a single request.
Bart
Kent Gibson
reviewerRe: [PATCH 2/2] gpiolib: cdev: export the consumer's PID
In reply to Andy ShevchenkoQuoted 22 lines · Andy Shevchenko
Quoted 2 lines · Kent Gibson
Quoted 1 line · Bartosz Golaszewski
On Tue, Sep 13, 2022 at 4:55 PM Kent Gibson <[email protected]> wrote:
...
Quoted 16 lines
Quoted 5 lines
We'd need of course first expose that info like:
gpio chip:gpiochip2 lines:0,3,4,7
Does that make sense?
Makes sense to me, though I don't claim to know anything about fdinfo field formatting.
e.g. I also see fdinfo fields like this:
eventfd-count: 0
eventfd-id: 1so
Quoted 8 lines
Quoted 4 lines
gpio-chip: gpiochip2 gpio-lines: 0,3,4,7might be ok too.
Always think about two or more GPIO chips in the same process with 1 or more lines requested from each of them.
I considered that - as Bart noted and as I stated earlier, each request fd is limited to one gpiochip and one set of offsets. And those are fixed for the lifetime of the request.
Different requests will be different fds.
But on the subject of repeats in fdinfo, I get the impression that multi-field fdinfo rows, e.g. the tfd rows here:
pos: 0
flags: 02000002mnt_id: 14
ino: 7661
tfd: 12 events: 19 data: c pos:0 ino:1ded sdev:d tfd: 14 events: 19 data: e pos:0 ino:1ded sdev:d
are formatted that way as they may be repeated, so they are getting all their ducks in a row, as it were.
So perhaps the gpio-lines could be exploded into repeated gpio-line rows? That may be going overboard as we are only encoding one field per line at the moment, not a struct as in the tfd case, but might we ever want to add more details?
Again, just speculating based on the few examples I have on hand.
Cheers,
Kent.