Skip to contentSkip to conversation

pinctrl: pinmux: Add pinmux-select debugfs file

PATCH Superseded Drew Fustini 5 participants 16 messages Feb 10, 2021 – Feb 17, 2021

Subsystems (2)

v4 of 9 Superseded Latest is v9 →

lore
Share & tools
lore
#0 lore raw

v4 cover pinctrl: pinmux: Add pinmux-select debugfs file

This series first converts the debugfs files in the pinctrl subsystem to octal permissions and then adds a new debugfs file "pinmux-select".

Function name and group name can be written to "pinmux-select" which will cause the function and group to be activated on the pin controller.

Notes for PATCH v4:
- correct the commit message in the second patch to reference function and group name instead of integer selectors. Apologies for not fixing that in v3
- fix typos in cover letter

Notes for PATCH v3:
- add Suggested-by: Andy Shevchenko to the "pinctrl: use to octal permissions for debugfs files" patch
- change the octal permissions from 0400 to 0444 to correctly match the symbolic permissions (thanks to Joe Perches and Geert Uytterhoeven)
- note that S_IFREG flag is added to the mode in __debugfs_create_file() (thanks to Andy for highlighting this and Joe for suggesting I should add a note to the commit message)
- fix order of the goto labels so that the buffers are freed correctly as suggested by Dan Carpenter
- move from devm_kzalloc() to kzalloc() as the buffers are only used inside the pinmux_select() function and not related to the lifetime of the pin controller device (thanks to Andy for pointing this out)
- correct the pinmux-select example in commit message to use the function and group name instead of selector (thanks to Geert)

Notes for PATCH v2:
- create patch series that includes patch to switch all the debugfs files in pinctrl subsystem over to octal permission
- write function name and group name, instead of error-prone selector numbers, to the 'pinmux-select' file
- switch from static to dynamic allocation for the kernel buffer filled by strncpy_from_user()
- look up function selector from function name using pinmux_func_name_to_selector()
- validate group name with get_function_groups() and match_string()
- look up selector for group name with pinctrl_get_group_selector()

Notes for PATCH v1:
- posted seperate patch to switch all the debugfs files in pinctrl subsystem over to octal permission [1]
- there is no existing documentation for any of the debugfs enteries for pinctrl, so it seemed to have a bigger scope than just this patch. I also noticed that rst documentation is confusingly named "pinctl" (no 'r') and started thread about that [2]. Linus suggested chaning that to 'pin-control'. Thus I am planning a seperate documentation patch series where the file is renamed, references changed and a section on the pinctrl debugfs files is added.

Notes for RFC v2 [3]:
- rename debugfs file "pinmux-set" to "pinmux-select"
- renmae pinmux_set_write() to pinmux_select()
- switch from memdup_user_nul() to strncpy_from_user()
- switch from pr_warn() to dev_err()

[1] https://lore.kernel.org/linux-gpio/[email protected]/
[2] https://lore.kernel.org/linux-gpio/20210126050817.GA187797@x1/
[3] https://lore.kernel.org/linux-gpio/[email protected]/

Drew Fustini (2):
pinctrl: use to octal permissions for debugfs files
pinctrl: pinmux: Add pinmux-select debugfs file

 drivers/pinctrl/core.c    |   6 +--
 drivers/pinctrl/pinconf.c |   4 +-
 drivers/pinctrl/pinmux.c  | 111 +++++++++++++++++++++++++++++++++++++-
 3 files changed, 114 insertions(+), 7 deletions(-)
Signature · 1 line
2.25.1
#1 lore raw

PATCH v4 1/2 pinctrl: use to octal permissions for debugfs files

Switch over pinctrl debugfs files to use octal permissions as they are preferred over symbolic permissions. Refer to commit f90774e1fd27 ("checkpatch: look for symbolic permissions and suggest octal instead").

Note: S_IFREG flag is added to the mode by __debugfs_create_file() in fs/debugfs/inode.c

---
 drivers/pinctrl/core.c    | 6 +++---
 drivers/pinctrl/pinconf.c | 4 ++--
 drivers/pinctrl/pinmux.c  | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)
drivers/pinctrl/core.c +3 -3
index 3663d87f51a0..02f8710afb9c 100644
@@ -1914,11 +1914,11 @@ static void pinctrl_init_debugfs(void)
 		return;
 	}
 
-	debugfs_create_file("pinctrl-devices", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-devices", 0444,
 			    debugfs_root, NULL, &pinctrl_devices_fops);
-	debugfs_create_file("pinctrl-maps", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-maps", 0444,
 			    debugfs_root, NULL, &pinctrl_maps_fops);
-	debugfs_create_file("pinctrl-handles", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-handles", 0444,
 			    debugfs_root, NULL, &pinctrl_fops);
 }
 
drivers/pinctrl/pinconf.c +2 -2
index 02c075cc010b..d9d54065472e 100644
@@ -370,9 +370,9 @@ DEFINE_SHOW_ATTRIBUTE(pinconf_groups);
 void pinconf_init_device_debugfs(struct dentry *devroot,
 			 struct pinctrl_dev *pctldev)
 {
-	debugfs_create_file("pinconf-pins", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinconf-pins", 0444,
 			    devroot, pctldev, &pinconf_pins_fops);
-	debugfs_create_file("pinconf-groups", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinconf-groups", 0444,
 			    devroot, pctldev, &pinconf_groups_fops);
 }
 
drivers/pinctrl/pinmux.c +2 -2
index bab888fe3f8e..c651b2db0925 100644
@@ -676,9 +676,9 @@ DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
 void pinmux_init_device_debugfs(struct dentry *devroot,
 			 struct pinctrl_dev *pctldev)
 {
-	debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinmux-functions", 0444,
 			    devroot, pctldev, &pinmux_functions_fops);
-	debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinmux-pins", 0444,
 			    devroot, pctldev, &pinmux_pins_fops);
 }
 
Signature · 1 line
2.25.1
#2 lore raw

Re: [PATCH v4 1/2] pinctrl: use to octal permissions for debugfs files

Quoted 32 lines · Drew Fustini

Switch over pinctrl debugfs files to use octal permissions as they are preferred over symbolic permissions. Refer to commit f90774e1fd27 ("checkpatch: look for symbolic permissions and suggest octal instead").

Note: S_IFREG flag is added to the mode by __debugfs_create_file() in fs/debugfs/inode.c

---

 drivers/pinctrl/core.c    | 6 +++---
 drivers/pinctrl/pinconf.c | 4 ++--
 drivers/pinctrl/pinmux.c  | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)
drivers/pinctrl/core.c +0 -0
index 3663d87f51a0..02f8710afb9c 100644
@@ -1914,11 +1914,11 @@ static void pinctrl_init_debugfs(void)
  		return;
  	}

drivers/pinctrl/core.c +1 -1
-	debugfs_create_file("pinctrl-devices", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-devices", 0444,

  debugfs_root, NULL, &pinctrl_devices_fops);

drivers/pinctrl/core.c +1 -1
-	debugfs_create_file("pinctrl-maps", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-maps", 0444,

  debugfs_root, NULL, &pinctrl_maps_fops);

drivers/pinctrl/core.c +1 -1
-	debugfs_create_file("pinctrl-handles", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-handles", 0444,
Quoted 2 lines

  debugfs_root, NULL, &pinctrl_fops); }

Why aren't you also converting this block in the same file?

@@ -1890,11 +1890,11 @@ static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)

                        dev_name(pctldev->dev));
                return;
        }
-       debugfs_create_file("pins", S_IFREG | S_IRUGO,
+       debugfs_create_file("pins", S_IFREG | 0444,
                            device_root, pctldev, &pinctrl_pins_fops);
-       debugfs_create_file("pingroups", S_IFREG | S_IRUGO,
+       debugfs_create_file("pingroups", S_IFREG | 0444,
                            device_root, pctldev, &pinctrl_groups_fops);
-       debugfs_create_file("gpio-ranges", S_IFREG | S_IRUGO,
+       debugfs_create_file("gpio-ranges", S_IFREG | 0444,
                            device_root, pctldev, &pinctrl_gpioranges_fops);
        if (pctldev->desc->pmxops)
                pinmux_init_device_debugfs(device_root, pctldev);
#3 lore raw

Re: [PATCH v4 1/2] pinctrl: use to octal permissions for debugfs files

Quoted 46 lines · Joe Perches
Quoted 32 lines · Drew Fustini

Switch over pinctrl debugfs files to use octal permissions as they are preferred over symbolic permissions. Refer to commit f90774e1fd27 ("checkpatch: look for symbolic permissions and suggest octal instead").

Note: S_IFREG flag is added to the mode by __debugfs_create_file() in fs/debugfs/inode.c

---

 drivers/pinctrl/core.c    | 6 +++---
 drivers/pinctrl/pinconf.c | 4 ++--
 drivers/pinctrl/pinmux.c  | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)
drivers/pinctrl/core.c +0 -0
index 3663d87f51a0..02f8710afb9c 100644
@@ -1914,11 +1914,11 @@ static void pinctrl_init_debugfs(void)
  		return;
  	}

drivers/pinctrl/core.c +1 -1
-	debugfs_create_file("pinctrl-devices", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-devices", 0444,

  debugfs_root, NULL, &pinctrl_devices_fops);

drivers/pinctrl/core.c +1 -1
-	debugfs_create_file("pinctrl-maps", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-maps", 0444,

  debugfs_root, NULL, &pinctrl_maps_fops);

drivers/pinctrl/core.c +1 -1
-	debugfs_create_file("pinctrl-handles", S_IFREG | S_IRUGO,
+	debugfs_create_file("pinctrl-handles", 0444,
Quoted 2 lines

  debugfs_root, NULL, &pinctrl_fops); }

Why aren't you also converting this block in the same file?

(quoted diff) +0 -1
@@ -1890,11 +1890,11 @@ static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
                        dev_name(pctldev->dev));
                return;
        }
-       debugfs_create_file("pins", S_IFREG | S_IRUGO,

Review static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev) · line 1900

Quoted 10 lines
(quoted diff) +3 -2
+       debugfs_create_file("pins", S_IFREG | 0444,
                            device_root, pctldev, &pinctrl_pins_fops);
-       debugfs_create_file("pingroups", S_IFREG | S_IRUGO,
+       debugfs_create_file("pingroups", S_IFREG | 0444,
                            device_root, pctldev, &pinctrl_groups_fops);
-       debugfs_create_file("gpio-ranges", S_IFREG | S_IRUGO,
+       debugfs_create_file("gpio-ranges", S_IFREG | 0444,
                            device_root, pctldev, &pinctrl_gpioranges_fops);
        if (pctldev->desc->pmxops)
                pinmux_init_device_debugfs(device_root, pctldev);

Thank you, that is a very good point. I should have included those calls to debugfs_create_file() in the patch as well. I will fix that in the next revision. It looks like I also need to change how sscanf() is being handle per the other thread of discussion.

Thanks,
Drew

#4 lore raw

PATCH v4 2/2 pinctrl: pinmux: Add pinmux-select debugfs file

In reply to Drew Fustini

Add "pinmux-select" to debugfs which will activate a function and group when "<function-name group-name>" are written to the file. The write operation pinmux_select() handles this by checking that the names map to valid selectors and then calling ops->set_mux().

The existing "pinmux-functions" debugfs file lists the pin functions registered for the pin controller. For example:

function: pinmux-uart0, groups = [ pinmux-uart0-pins ]
function: pinmux-mmc0, groups = [ pinmux-mmc0-pins ]
function: pinmux-mmc1, groups = [ pinmux-mmc1-pins ]
function: pinmux-i2c0, groups = [ pinmux-i2c0-pins ]
function: pinmux-i2c1, groups = [ pinmux-i2c1-pins ]
function: pinmux-spi1, groups = [ pinmux-spi1-pins ]

To activate function pinmux-i2c1 and group pinmux-i2c1-pins:

echo "pinmux-i2c1 pinmux-i2c1-pins" > pinmux-select

---
 drivers/pinctrl/pinmux.c | 107 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
drivers/pinctrl/pinmux.c +107 -0
index c651b2db0925..23fa32f0a067 100644
@@ -673,6 +673,111 @@ void pinmux_show_setting(struct seq_file *s,
 DEFINE_SHOW_ATTRIBUTE(pinmux_functions);
 DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
 
+#define PINMUX_MAX_NAME 64
+static ssize_t pinmux_select(struct file *file, const char __user *user_buf,
+				   size_t len, loff_t *ppos)
+{
+	struct seq_file *sfile = file->private_data;
+	struct pinctrl_dev *pctldev = sfile->private;
+	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
+	const char *const *groups;
+	char *buf, *fname, *gname;
+	unsigned int num_groups;
+	int fsel, gsel, ret;
+
+	if (len > (PINMUX_MAX_NAME * 2)) {
+		dev_err(pctldev->dev, "write too big for buffer");
+		return -EINVAL;
+	}
+
+	buf = kzalloc(PINMUX_MAX_NAME * 2, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	fname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+	if (!fname) {
+		ret = -ENOMEM;
+		goto free_buf;
+	}
+
+	gname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+	if (!buf) {
+		ret = -ENOMEM;
+		goto free_fname;
+	}
+
+	ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to copy buffer from userspace");
+		goto free_gname;
+	}
+	buf[len-1] = '\0';
+
+	ret = sscanf(buf, "%s %s", fname, gname);
+	if (ret != 2) {
+		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+		goto free_gname;
+	}
+
+	fsel = pinmux_func_name_to_selector(pctldev, fname);
+	if (fsel < 0) {
+		dev_err(pctldev->dev, "invalid function %s in map table\n", fname);
+		ret = -EINVAL;
+		goto free_gname;
+	}
+
+	ret = pmxops->get_function_groups(pctldev, fsel, &groups, &num_groups);
+	if (ret) {
+		dev_err(pctldev->dev, "no groups for function %d (%s)", fsel, fname);
+		goto free_gname;
+
+	}
+
+	ret = match_string(groups, num_groups, gname);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "invalid group %s", gname);
+		goto free_gname;
+	}
+
+	ret = pinctrl_get_group_selector(pctldev, gname);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to get group selectorL %s", gname);
+		goto free_gname;
+	}
+	gsel = ret;
+
+	ret = pmxops->set_mux(pctldev, fsel, gsel);
+	if (ret) {
+		dev_err(pctldev->dev, "set_mux() failed: %d", ret);
+		goto free_gname;
+	}
+
+	return len;
+
+free_gname:
+	devm_kfree(pctldev->dev, gname);
+free_fname:
+	devm_kfree(pctldev->dev, fname);
+free_buf:
+	devm_kfree(pctldev->dev, buf);
+
+	return ret;
+}
+
+static int pinmux_select_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, NULL, inode->i_private);
+}
+
+static const struct file_operations pinmux_select_ops = {
+	.owner = THIS_MODULE,
+	.open = pinmux_select_open,
+	.read = seq_read,
+	.write = pinmux_select,
+	.llseek = no_llseek,
+	.release = single_release,
+};
+
 void pinmux_init_device_debugfs(struct dentry *devroot,
 			 struct pinctrl_dev *pctldev)
 {
@@ -680,6 +785,8 @@ void pinmux_init_device_debugfs(struct dentry *devroot,
 			    devroot, pctldev, &pinmux_functions_fops);
 	debugfs_create_file("pinmux-pins", 0444,
 			    devroot, pctldev, &pinmux_pins_fops);
+	debugfs_create_file("pinmux-select", 0200,
+			    devroot, pctldev, &pinmux_select_ops);
 }
 
 #endif /* CONFIG_DEBUG_FS */
Signature · 1 line
2.25.1
#5 lore raw

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 719

Quoted 11 lines · Drew Fustini
drivers/pinctrl/pinmux.c +11 -0
+	ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to copy buffer from userspace");
+		goto free_gname;
+	}
+	buf[len-1] = '\0';
+
+	ret = sscanf(buf, "%s %s", fname, gname);
+	if (ret != 2) {
+		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+		goto free_gname;

We need a "ret = -EINVAL;" before the goto. sscanf doesn't return error codes. Normally we would write it like so:

	if (sscanf(buf, "%s %s", fname, gname) != 2) {
		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
		ret = -EINVAL;
		goto free_gname;
	}

I'm going to write a Smatch check for this today.

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 725

Quoted 6 lines
drivers/pinctrl/pinmux.c +6 -0
+	}
+
+	fsel = pinmux_func_name_to_selector(pctldev, fname);
+	if (fsel < 0) {
+		dev_err(pctldev->dev, "invalid function %s in map table\n", fname);
+		ret = -EINVAL;

ret = fsel;

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 715

Quoted 3 lines
drivers/pinctrl/pinmux.c +3 -0
+		goto free_gname;
+	}
+

regards,
dan carpenter

#6 lore raw
Quoted 16 lines · Dan Carpenter

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 719

Quoted 11 lines · Drew Fustini
drivers/pinctrl/pinmux.c +11 -0
+	ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to copy buffer from userspace");
+		goto free_gname;
+	}
+	buf[len-1] = '\0';
+
+	ret = sscanf(buf, "%s %s", fname, gname);
+	if (ret != 2) {
+		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+		goto free_gname;

We need a "ret = -EINVAL;" before the goto. sscanf doesn't return error codes. Normally we would write it like so:

Quoted 7 lines
	if (sscanf(buf, "%s %s", fname, gname) != 2) {
		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
		ret = -EINVAL;
		goto free_gname;
	}

I'm going to write a Smatch check for this today.

It's a pretty frequently used style:

$ git grep -P '\w+\s*=\s+sscanf\b' | wc -l
327

A grep with -A5 seems to show most use some additional error assignment when checking the return value.

$ git grep -P -A5 '\w+\s*=\s+sscanf\b' | grep -P '(?:return|=)\s*\-E' | wc -l
174
#7 lore raw
Quoted 23 lines · Joe Perches
Quoted 22 lines · Dan Carpenter

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 719

Quoted 11 lines · Drew Fustini
drivers/pinctrl/pinmux.c +11 -0
+	ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to copy buffer from userspace");
+		goto free_gname;
+	}
+	buf[len-1] = '\0';
+
+	ret = sscanf(buf, "%s %s", fname, gname);
+	if (ret != 2) {
+		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+		goto free_gname;

We need a "ret = -EINVAL;" before the goto. sscanf doesn't return error codes. Normally we would write it like so:

	if (sscanf(buf, "%s %s", fname, gname) != 2) {
		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
		ret = -EINVAL;
		goto free_gname;
	}
Quoted 6 lines
Quoted 1 line

I'm going to write a Smatch check for this today.

It's a pretty frequently used style:

$ git grep -P '\w+\s*=\s+sscanf\b' | wc -l
327

Yeah. That's true. I looked through a couple of those and they were fine. (Sample size 2) But the other format is more common.

$ git grep sscanf | grep = | wc -l
803

I have written a Smatch check to complain whenever we propogate the return value from sscanf. I'll let you know tomorrow how that goes.

I should write another check which says "On this error path, we know sscanf was not equal to the value we wanted but we are still returning success".

regards,
dan carpenter

#8 lore raw
Quoted 40 lines · Dan Carpenter
Quoted 23 lines · Joe Perches
Quoted 22 lines · Dan Carpenter

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 719

Quoted 11 lines · Drew Fustini
drivers/pinctrl/pinmux.c +11 -0
+	ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to copy buffer from userspace");
+		goto free_gname;
+	}
+	buf[len-1] = '\0';
+
+	ret = sscanf(buf, "%s %s", fname, gname);
+	if (ret != 2) {
+		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+		goto free_gname;

We need a "ret = -EINVAL;" before the goto. sscanf doesn't return error codes. Normally we would write it like so:

	if (sscanf(buf, "%s %s", fname, gname) != 2) {
		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
		ret = -EINVAL;
		goto free_gname;
	}
Quoted 6 lines
Quoted 1 line

I'm going to write a Smatch check for this today.

It's a pretty frequently used style:

$ git grep -P '\w+\s*=\s+sscanf\b' | wc -l
327

Yeah. That's true. I looked through a couple of those and they were fine. (Sample size 2) But the other format is more common.

$ git grep sscanf | grep = | wc -l
803

I have written a Smatch check to complain whenever we propogate the return value from sscanf. I'll let you know tomorrow how that goes.

Quoted 7 lines

I should write another check which says "On this error path, we know sscanf was not equal to the value we wanted but we are still returning success".

regards,
dan carpenter

Thank you for comments regarding sscanf(). And also thank you for the LF mentorship session on smatch this morning. It helped me understand it much better.

Based on further comments, it seems there are better ways for me to pull the strings out of the write buffer, but I will keep this in mind if I need to use sscanf() in the future.

-Drew

#9 lore raw
Quoted 45 lines · Drew Fustini
Quoted 44 lines · Dan Carpenter
Quoted 23 lines · Joe Perches
Quoted 22 lines · Dan Carpenter

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 719

Quoted 11 lines · Drew Fustini
drivers/pinctrl/pinmux.c +11 -0
+	ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to copy buffer from userspace");
+		goto free_gname;
+	}
+	buf[len-1] = '\0';
+
+	ret = sscanf(buf, "%s %s", fname, gname);
+	if (ret != 2) {
+		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+		goto free_gname;

We need a "ret = -EINVAL;" before the goto. sscanf doesn't return error codes. Normally we would write it like so:

	if (sscanf(buf, "%s %s", fname, gname) != 2) {
		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
		ret = -EINVAL;
		goto free_gname;
	}
Quoted 6 lines
Quoted 1 line

I'm going to write a Smatch check for this today.

It's a pretty frequently used style:

$ git grep -P '\w+\s*=\s+sscanf\b' | wc -l
327

Yeah. That's true. I looked through a couple of those and they were fine. (Sample size 2) But the other format is more common.

$ git grep sscanf | grep = | wc -l
803

I have written a Smatch check to complain whenever we propogate the return value from sscanf. I'll let you know tomorrow how that goes.

I should write another check which says "On this error path, we know sscanf was not equal to the value we wanted but we are still returning success".

Quoted 7 lines
Quoted 3 lines

regards,
dan carpenter

Thank you for comments regarding sscanf(). And also thank you for the LF mentorship session on smatch this morning. It helped me understand it much better.

Good deal!

The warning about propagating errors from sscanf caught a couple bugs. The one about returning success if sscanf failed didn't catch anything.

The sscanf overflow patch didn't find anything either, but I think we've had those bugs in the past and so I expect some in the future so I will keep that one in my private tests without pushing it.

regards,
dan carpenter

#10 lore raw
In reply to Drew Fustini

Hi Drew,

Quoted 15 lines · Drew Fustini

Add "pinmux-select" to debugfs which will activate a function and group when "<function-name group-name>" are written to the file. The write operation pinmux_select() handles this by checking that the names map to valid selectors and then calling ops->set_mux().

The existing "pinmux-functions" debugfs file lists the pin functions registered for the pin controller. For example:

function: pinmux-uart0, groups = [ pinmux-uart0-pins ]
function: pinmux-mmc0, groups = [ pinmux-mmc0-pins ]
function: pinmux-mmc1, groups = [ pinmux-mmc1-pins ]
function: pinmux-i2c0, groups = [ pinmux-i2c0-pins ]
function: pinmux-i2c1, groups = [ pinmux-i2c1-pins ]
function: pinmux-spi1, groups = [ pinmux-spi1-pins ]

Quoted 5 lines

To activate function pinmux-i2c1 and group pinmux-i2c1-pins:

echo "pinmux-i2c1 pinmux-i2c1-pins" > pinmux-select

Thanks for your patch!

Quoted 30 lines
drivers/pinctrl/pinmux.c +24 -0
@@ -673,6 +673,111 @@ void pinmux_show_setting(struct seq_file *s,
 DEFINE_SHOW_ATTRIBUTE(pinmux_functions);
 DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
 
+#define PINMUX_MAX_NAME 64
+static ssize_t pinmux_select(struct file *file, const char __user *user_buf,
+                                  size_t len, loff_t *ppos)
+{
+       struct seq_file *sfile = file->private_data;
+       struct pinctrl_dev *pctldev = sfile->private;
+       const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
+       const char *const *groups;
+       char *buf, *fname, *gname;
+       unsigned int num_groups;
+       int fsel, gsel, ret;
+
+       if (len > (PINMUX_MAX_NAME * 2)) {
+               dev_err(pctldev->dev, "write too big for buffer");
+               return -EINVAL;
+       }
+
+       buf = kzalloc(PINMUX_MAX_NAME * 2, GFP_KERNEL);
+       if (!buf)
+               return -ENOMEM;
+
+       fname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+       if (!fname) {
+               ret = -ENOMEM;

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 709

Quoted 10 lines
drivers/pinctrl/pinmux.c +10 -0
+               goto free_buf;
+       }
+
+       gname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+       if (!buf) {
+               ret = -ENOMEM;
+               goto free_fname;
+       }
+
+       ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);

While this guarantees buf is not overflowed...

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 716

Quoted 7 lines
drivers/pinctrl/pinmux.c +7 -0
+       if (ret < 0) {
+               dev_err(pctldev->dev, "failed to copy buffer from userspace");
+               goto free_gname;
+       }
+       buf[len-1] = '\0';
+
+       ret = sscanf(buf, "%s %s", fname, gname);

... one of the two strings can still be longer than PINMUX_MAX_NAME, thus overflowing fname or gname.

As buf is already a copy, it may be easier to just find the strings in buf, write the NUL terminators into buf, and set up fname and gname to point to the strings inside buf.

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 775

Quoted 9 lines
drivers/pinctrl/pinmux.c +8 -0
+       if (ret != 2) {
+               dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+               goto free_gname;
+       }
 
+static const struct file_operations pinmux_select_ops = {
+       .owner = THIS_MODULE,
+       .open = pinmux_select_open,
+       .read = seq_read,

I don't think you need to fill in .read for a write-only file.

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 783

Quoted 8 lines
drivers/pinctrl/pinmux.c +5 -0
+       .write = pinmux_select,
+       .llseek = no_llseek,
+       .release = single_release,
+};
+
 void pinmux_init_device_debugfs(struct dentry *devroot,
                         struct pinctrl_dev *pctldev)
 {

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
                                -- Linus Torvalds
#11 lore raw
Quoted 24 lines · Geert Uytterhoeven

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 709

Quoted 10 lines · Drew Fustini
drivers/pinctrl/pinmux.c +8 -0
+#define PINMUX_MAX_NAME 64
 
+       if (len > (PINMUX_MAX_NAME * 2)) {
+               dev_err(pctldev->dev, "write too big for buffer");
+               return -EINVAL;
+       }
+
+       buf = kzalloc(PINMUX_MAX_NAME * 2, GFP_KERNEL);
 
+       ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);

While this guarantees buf is not overflowed...

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 716

Quoted 7 lines
drivers/pinctrl/pinmux.c +7 -0
+       if (ret < 0) {
+               dev_err(pctldev->dev, "failed to copy buffer from userspace");
+               goto free_gname;
+       }
+       buf[len-1] = '\0';
+
+       ret = sscanf(buf, "%s %s", fname, gname);
Quoted 6 lines

... one of the two strings can still be longer than PINMUX_MAX_NAME, thus overflowing fname or gname.

As buf is already a copy, it may be easier to just find the strings in buf, write the NUL terminators into buf, and set up fname and gname to point to the strings inside buf.

You beat me up to it. I was about to comment the same.

So, indeed, instead of sscanf it's simply better and faster to do just something like

fname = strstrip(buf) ;
if (*fname == '\0') {
...
return -EINVAL;
}

gname = strchr(fname, ' ');
if (!gname) {
...
return -EINVAL;
}
*gname++ = '\0';

on top of the buf pointer.

Quoted 4 lines
Quoted 4 lines
drivers/pinctrl/pinmux.c +4 -0
+       if (ret != 2) {
+               dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+               goto free_gname;
+       }
Signature · 2 lines
With Best Regards,
Andy Shevchenko
#12 lore raw
Quoted 44 lines · Andy Shevchenko
Quoted 24 lines · Geert Uytterhoeven

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 709

Quoted 10 lines · Drew Fustini
drivers/pinctrl/pinmux.c +8 -0
+#define PINMUX_MAX_NAME 64
 
+       if (len > (PINMUX_MAX_NAME * 2)) {
+               dev_err(pctldev->dev, "write too big for buffer");
+               return -EINVAL;
+       }
+
+       buf = kzalloc(PINMUX_MAX_NAME * 2, GFP_KERNEL);
 
+       ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);

While this guarantees buf is not overflowed...

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 716

Quoted 7 lines
drivers/pinctrl/pinmux.c +7 -0
+       if (ret < 0) {
+               dev_err(pctldev->dev, "failed to copy buffer from userspace");
+               goto free_gname;
+       }
+       buf[len-1] = '\0';
+
+       ret = sscanf(buf, "%s %s", fname, gname);
Quoted 6 lines

... one of the two strings can still be longer than PINMUX_MAX_NAME, thus overflowing fname or gname.

As buf is already a copy, it may be easier to just find the strings in buf, write the NUL terminators into buf, and set up fname and gname to point to the strings inside buf.

You beat me up to it. I was about to comment the same.

So, indeed, instead of sscanf it's simply better and faster to do just something like

fname = strstrip(buf) ;
if (*fname == '\0') {
...
return -EINVAL;
}

Quoted 9 lines

gname = strchr(fname, ' ');
if (!gname) {
...
return -EINVAL;
}
*gname++ = '\0';

on top of the buf pointer.

Thank you for the suggestion about how to implement this. I'll use that in the next revision.

-Drew

#13 lore raw
In reply to Geert Uytterhoeven
Quoted 77 lines · Geert Uytterhoeven

Hi Drew,

Quoted 15 lines · Drew Fustini

Add "pinmux-select" to debugfs which will activate a function and group when "<function-name group-name>" are written to the file. The write operation pinmux_select() handles this by checking that the names map to valid selectors and then calling ops->set_mux().

The existing "pinmux-functions" debugfs file lists the pin functions registered for the pin controller. For example:

function: pinmux-uart0, groups = [ pinmux-uart0-pins ]
function: pinmux-mmc0, groups = [ pinmux-mmc0-pins ]
function: pinmux-mmc1, groups = [ pinmux-mmc1-pins ]
function: pinmux-i2c0, groups = [ pinmux-i2c0-pins ]
function: pinmux-i2c1, groups = [ pinmux-i2c1-pins ]
function: pinmux-spi1, groups = [ pinmux-spi1-pins ]

Quoted 5 lines

To activate function pinmux-i2c1 and group pinmux-i2c1-pins:

echo "pinmux-i2c1 pinmux-i2c1-pins" > pinmux-select

Thanks for your patch!

Quoted 30 lines
drivers/pinctrl/pinmux.c +24 -0
@@ -673,6 +673,111 @@ void pinmux_show_setting(struct seq_file *s,
 DEFINE_SHOW_ATTRIBUTE(pinmux_functions);
 DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
 
+#define PINMUX_MAX_NAME 64
+static ssize_t pinmux_select(struct file *file, const char __user *user_buf,
+                                  size_t len, loff_t *ppos)
+{
+       struct seq_file *sfile = file->private_data;
+       struct pinctrl_dev *pctldev = sfile->private;
+       const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
+       const char *const *groups;
+       char *buf, *fname, *gname;
+       unsigned int num_groups;
+       int fsel, gsel, ret;
+
+       if (len > (PINMUX_MAX_NAME * 2)) {
+               dev_err(pctldev->dev, "write too big for buffer");
+               return -EINVAL;
+       }
+
+       buf = kzalloc(PINMUX_MAX_NAME * 2, GFP_KERNEL);
+       if (!buf)
+               return -ENOMEM;
+
+       fname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+       if (!fname) {
+               ret = -ENOMEM;

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 709

Quoted 10 lines
drivers/pinctrl/pinmux.c +10 -0
+               goto free_buf;
+       }
+
+       gname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+       if (!buf) {
+               ret = -ENOMEM;
+               goto free_fname;
+       }
+
+       ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);

While this guarantees buf is not overflowed...

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 716

Quoted 7 lines
drivers/pinctrl/pinmux.c +7 -0
+       if (ret < 0) {
+               dev_err(pctldev->dev, "failed to copy buffer from userspace");
+               goto free_gname;
+       }
+       buf[len-1] = '\0';
+
+       ret = sscanf(buf, "%s %s", fname, gname);
Quoted 6 lines

... one of the two strings can still be longer than PINMUX_MAX_NAME, thus overflowing fname or gname.

As buf is already a copy, it may be easier to just find the strings in buf, write the NUL terminators into buf, and set up fname and gname to point to the strings inside buf.

Thank you for pointing this out. I should have considered that one name could be much larger than the other name. I see Andy suggested alternative to sscanf() that gets around having to allocate seperate buffers for each name.

Quoted 11 lines

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 775

Quoted 9 lines
drivers/pinctrl/pinmux.c +8 -0
+       if (ret != 2) {
+               dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+               goto free_gname;
+       }
 
+static const struct file_operations pinmux_select_ops = {
+       .owner = THIS_MODULE,
+       .open = pinmux_select_open,
+       .read = seq_read,

I don't think you need to fill in .read for a write-only file.

Thanks, I'll remove it.

Quoted 20 lines

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 783

Quoted 9 lines
drivers/pinctrl/pinmux.c +5 -0
+       .write = pinmux_select,
+       .llseek = no_llseek,
+       .release = single_release,
+};
+
 void pinmux_init_device_debugfs(struct dentry *devroot,
                         struct pinctrl_dev *pctldev)
 {

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
                                -- Linus Torvalds
#14 lore raw
In reply to Drew Fustini
Quoted 109 lines · Drew Fustini

Add "pinmux-select" to debugfs which will activate a function and group when "<function-name group-name>" are written to the file. The write operation pinmux_select() handles this by checking that the names map to valid selectors and then calling ops->set_mux().

The existing "pinmux-functions" debugfs file lists the pin functions registered for the pin controller. For example:

function: pinmux-uart0, groups = [ pinmux-uart0-pins ]
function: pinmux-mmc0, groups = [ pinmux-mmc0-pins ]
function: pinmux-mmc1, groups = [ pinmux-mmc1-pins ]
function: pinmux-i2c0, groups = [ pinmux-i2c0-pins ]
function: pinmux-i2c1, groups = [ pinmux-i2c1-pins ]
function: pinmux-spi1, groups = [ pinmux-spi1-pins ]

To activate function pinmux-i2c1 and group pinmux-i2c1-pins:

echo "pinmux-i2c1 pinmux-i2c1-pins" > pinmux-select

---
 drivers/pinctrl/pinmux.c | 107 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
drivers/pinctrl/pinmux.c +77 -0
index c651b2db0925..23fa32f0a067 100644
@@ -673,6 +673,111 @@ void pinmux_show_setting(struct seq_file *s,
 DEFINE_SHOW_ATTRIBUTE(pinmux_functions);
 DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
 
+#define PINMUX_MAX_NAME 64
+static ssize_t pinmux_select(struct file *file, const char __user *user_buf,
+				   size_t len, loff_t *ppos)
+{
+	struct seq_file *sfile = file->private_data;
+	struct pinctrl_dev *pctldev = sfile->private;
+	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
+	const char *const *groups;
+	char *buf, *fname, *gname;
+	unsigned int num_groups;
+	int fsel, gsel, ret;
+
+	if (len > (PINMUX_MAX_NAME * 2)) {
+		dev_err(pctldev->dev, "write too big for buffer");
+		return -EINVAL;
+	}
+
+	buf = kzalloc(PINMUX_MAX_NAME * 2, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	fname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+	if (!fname) {
+		ret = -ENOMEM;
+		goto free_buf;
+	}
+
+	gname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+	if (!buf) {
+		ret = -ENOMEM;
+		goto free_fname;
+	}
+
+	ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to copy buffer from userspace");
+		goto free_gname;
+	}
+	buf[len-1] = '\0';
+
+	ret = sscanf(buf, "%s %s", fname, gname);
+	if (ret != 2) {
+		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+		goto free_gname;
+	}
+
+	fsel = pinmux_func_name_to_selector(pctldev, fname);
+	if (fsel < 0) {
+		dev_err(pctldev->dev, "invalid function %s in map table\n", fname);
+		ret = -EINVAL;
+		goto free_gname;
+	}
+
+	ret = pmxops->get_function_groups(pctldev, fsel, &groups, &num_groups);
+	if (ret) {
+		dev_err(pctldev->dev, "no groups for function %d (%s)", fsel, fname);
+		goto free_gname;
+
+	}
+
+	ret = match_string(groups, num_groups, gname);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "invalid group %s", gname);
+		goto free_gname;
+	}
+
+	ret = pinctrl_get_group_selector(pctldev, gname);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to get group selectorL %s", gname);
+		goto free_gname;
+	}
+	gsel = ret;
+
+	ret = pmxops->set_mux(pctldev, fsel, gsel);
+	if (ret) {
+		dev_err(pctldev->dev, "set_mux() failed: %d", ret);
+		goto free_gname;

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 762

Quoted 10 lines
drivers/pinctrl/pinmux.c +10 -0
+	}
+
+	return len;
+
+free_gname:
+	devm_kfree(pctldev->dev, gname);
+free_fname:
+	devm_kfree(pctldev->dev, fname);
+free_buf:
+	devm_kfree(pctldev->dev, buf);

Ugh... I honestly thought Smatch was supposed to print a warning when you used devm_kfree() on kzalloc()ed memory, but I guess the warning is only the other way around.

Smatch does complain about it as a leak because it was expecting a regular free.

drivers/pinctrl/pinmux.c:330 pinmux_func_name_to_selector() warn: potential NULL parameter dereference 'fname' drivers/pinctrl/pinmux.c:764 pinmux_select() warn: possible memory leak of 'gname' drivers/pinctrl/pinmux.c:764 pinmux_select() warn: sscanf doesn't return error codes drivers/pinctrl/pinmux.c:764 pinmux_select() warn: returning success when sscanf failed

And what about the success path? Shouldn't we free these on the success path as well?

regards,
dan carpenter

#15 lore raw
Quoted 125 lines · Dan Carpenter
Quoted 109 lines · Drew Fustini

Add "pinmux-select" to debugfs which will activate a function and group when "<function-name group-name>" are written to the file. The write operation pinmux_select() handles this by checking that the names map to valid selectors and then calling ops->set_mux().

The existing "pinmux-functions" debugfs file lists the pin functions registered for the pin controller. For example:

function: pinmux-uart0, groups = [ pinmux-uart0-pins ]
function: pinmux-mmc0, groups = [ pinmux-mmc0-pins ]
function: pinmux-mmc1, groups = [ pinmux-mmc1-pins ]
function: pinmux-i2c0, groups = [ pinmux-i2c0-pins ]
function: pinmux-i2c1, groups = [ pinmux-i2c1-pins ]
function: pinmux-spi1, groups = [ pinmux-spi1-pins ]

To activate function pinmux-i2c1 and group pinmux-i2c1-pins:

echo "pinmux-i2c1 pinmux-i2c1-pins" > pinmux-select

---
 drivers/pinctrl/pinmux.c | 107 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
drivers/pinctrl/pinmux.c +77 -0
index c651b2db0925..23fa32f0a067 100644
@@ -673,6 +673,111 @@ void pinmux_show_setting(struct seq_file *s,
 DEFINE_SHOW_ATTRIBUTE(pinmux_functions);
 DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
 
+#define PINMUX_MAX_NAME 64
+static ssize_t pinmux_select(struct file *file, const char __user *user_buf,
+				   size_t len, loff_t *ppos)
+{
+	struct seq_file *sfile = file->private_data;
+	struct pinctrl_dev *pctldev = sfile->private;
+	const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
+	const char *const *groups;
+	char *buf, *fname, *gname;
+	unsigned int num_groups;
+	int fsel, gsel, ret;
+
+	if (len > (PINMUX_MAX_NAME * 2)) {
+		dev_err(pctldev->dev, "write too big for buffer");
+		return -EINVAL;
+	}
+
+	buf = kzalloc(PINMUX_MAX_NAME * 2, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	fname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+	if (!fname) {
+		ret = -ENOMEM;
+		goto free_buf;
+	}
+
+	gname = kzalloc(PINMUX_MAX_NAME, GFP_KERNEL);
+	if (!buf) {
+		ret = -ENOMEM;
+		goto free_fname;
+	}
+
+	ret = strncpy_from_user(buf, user_buf, PINMUX_MAX_NAME * 2);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to copy buffer from userspace");
+		goto free_gname;
+	}
+	buf[len-1] = '\0';
+
+	ret = sscanf(buf, "%s %s", fname, gname);
+	if (ret != 2) {
+		dev_err(pctldev->dev, "expected format: <function-name> <group-name>");
+		goto free_gname;
+	}
+
+	fsel = pinmux_func_name_to_selector(pctldev, fname);
+	if (fsel < 0) {
+		dev_err(pctldev->dev, "invalid function %s in map table\n", fname);
+		ret = -EINVAL;
+		goto free_gname;
+	}
+
+	ret = pmxops->get_function_groups(pctldev, fsel, &groups, &num_groups);
+	if (ret) {
+		dev_err(pctldev->dev, "no groups for function %d (%s)", fsel, fname);
+		goto free_gname;
+
+	}
+
+	ret = match_string(groups, num_groups, gname);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "invalid group %s", gname);
+		goto free_gname;
+	}
+
+	ret = pinctrl_get_group_selector(pctldev, gname);
+	if (ret < 0) {
+		dev_err(pctldev->dev, "failed to get group selectorL %s", gname);
+		goto free_gname;
+	}
+	gsel = ret;
+
+	ret = pmxops->set_mux(pctldev, fsel, gsel);
+	if (ret) {
+		dev_err(pctldev->dev, "set_mux() failed: %d", ret);
+		goto free_gname;

drivers/pinctrl/pinmux.c void pinmux_show_setting(struct seq_file *s, · line 762

Quoted 10 lines
drivers/pinctrl/pinmux.c +10 -0
+	}
+
+	return len;
+
+free_gname:
+	devm_kfree(pctldev->dev, gname);
+free_fname:
+	devm_kfree(pctldev->dev, fname);
+free_buf:
+	devm_kfree(pctldev->dev, buf);

Ugh... I honestly thought Smatch was supposed to print a warning when you used devm_kfree() on kzalloc()ed memory, but I guess the warning is only the other way around.

Quoted 7 lines

Smatch does complain about it as a leak because it was expecting a regular free.

drivers/pinctrl/pinmux.c:330 pinmux_func_name_to_selector() warn: potential NULL parameter dereference 'fname' drivers/pinctrl/pinmux.c:764 pinmux_select() warn: possible memory leak of 'gname' drivers/pinctrl/pinmux.c:764 pinmux_select() warn: sscanf doesn't return error codes drivers/pinctrl/pinmux.c:764 pinmux_select() warn: returning success when sscanf failed

Thank you pointing this out. I should have switched back to normal free now that I no longer using a device managed buffer.

Quoted 3 lines

And what about the success path? Shouldn't we free these on the success path as well?

Good point. That is my fault. I will update it so that it correctly free's buffer no matter what happens in the function.

thanks,
drew