Skip to contentSkip to conversation

linux/io.h: Add cleanup defination for iounmap() and memunmap()

PATCH Superseded Frank Li 2 participants 4 messages Jul 31, 2024 – Aug 2, 2024 Arm i.MX and Layerscape

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Frank Li

author maintainer
#0 lore raw

PATCH 1/1 linux/io.h: Add cleanup defination for iounmap() and memunmap()

Add DEFINE_FREE for iounmap() and memunmap() to support scope based cleanup.

---
 include/linux/io.h | 3 +++
 1 file changed, 3 insertions(+)
include/linux/io.h +3 -0
index 59ec5eea696c4..7695d7973c8ff 100644
@@ -163,6 +163,9 @@ enum {
 void *memremap(resource_size_t offset, size_t size, unsigned long flags);
 void memunmap(void *addr);
 
+DEFINE_FREE(iounmap, void __iomem *, if (!IS_ERR_OR_NULL(_T)) iounmap(_T))
+DEFINE_FREE(memunmap, void *, if (!IS_ERR_OR_NULL(_T)) memunmap(_T))
+
 /*
  * On x86 PAT systems we have memory tracking that keeps track of
  * the allowed mappings on memory ranges. This tracking works for
Signature · 1 line
2.34.1
#1 lore raw
Quoted 13 lines · Frank Li

Add DEFINE_FREE for iounmap() and memunmap() to support scope based cleanup.

---
 include/linux/io.h | 3 +++
 1 file changed, 3 insertions(+)
include/linux/io.h +0 -0
index 59ec5eea696c4..7695d7973c8ff 100644

include/linux/io.h enum { · line 167

Quoted 5 lines
include/linux/io.h +2 -0
@@ -163,6 +163,9 @@ enum {
 void *memremap(resource_size_t offset, size_t size, unsigned long flags);
 void memunmap(void *addr);
 
+DEFINE_FREE(iounmap, void __iomem *, if (!IS_ERR_OR_NULL(_T)) iounmap(_T))
+DEFINE_FREE(memunmap, void *, if (!IS_ERR_OR_NULL(_T)) memunmap(_T))

I don't like the use of IS_ERR_OR_NULL(), which tends to indicate a problem in the interface design.

In which cases do you expect to need scope based cleanup on an error pointer here? The only interfaces I see that returns an __iomem error pointer are the devm_* ones, but those have their own cleanup method.

Arnd

author maintainer
#2 lore raw
Quoted 17 lines · Arnd Bergmann
Quoted 16 lines · Frank Li

Add DEFINE_FREE for iounmap() and memunmap() to support scope based cleanup.

---
 include/linux/io.h | 3 +++
 1 file changed, 3 insertions(+)
include/linux/io.h +0 -0
index 59ec5eea696c4..7695d7973c8ff 100644
@@ -163,6 +163,9 @@ enum {
 void *memremap(resource_size_t offset, size_t size, unsigned long flags);
 void memunmap(void *addr);
 
Quoted 5 lines

include/linux/io.h enum { · line 167

Quoted 2 lines
include/linux/io.h +2 -0
+DEFINE_FREE(iounmap, void __iomem *, if (!IS_ERR_OR_NULL(_T)) iounmap(_T))
+DEFINE_FREE(memunmap, void *, if (!IS_ERR_OR_NULL(_T)) memunmap(_T))

I don't like the use of IS_ERR_OR_NULL(), which tends to indicate a problem in the interface design.

Just !(_T) ? I just refer kfree()'s implementation.

Quoted 5 lines

In which cases do you expect to need scope based cleanup on an error pointer here? The only interfaces I see that returns an __iomem error pointer are the devm_* ones, but those have their own cleanup method.

devm_* can help much especial in probe() function. but scope base cleanup also useful.

Give a existed example:

drivers/clocksource/timer-fsl-ftm.c

static int __init ftm_timer_init(struct device_node *np) {
	...
	priv->clksrc_base = of_iomap(np, 1);
        if (!priv->clksrc_base) {
                pr_err("ftm: unable to map source timer registers\n");
                goto err_clksrc;
        }
	...

err_clksrc:

        iounmap(priv->clkevt_base);
}

If use scoped base cleanup it will be simple.
ftm_timer_init()

{
	base __free(ioumap) =  of_iomap(np, 1);

	...
	priv->clksrc_base = no_free_ptr(base);
	return 0;
}

drivers/clocksource/arm_arch_timer.c
Some example need map and unmap in function such as:
arch_timer_mem_frame_get_cntfrq()

{
	base = ioremap(frame->cntbase, frame->size);
	...
	iounmap(base);
}

of course this example is too simple. If there are many error branch between ioremap() and iounmap(), scoped based clean up make code simple.

Frank

Quoted 2 lines

Arnd

#3 lore raw
Quoted 10 lines · Frank Li
Quoted 9 lines · Arnd Bergmann
Quoted 8 lines · Frank Li
include/linux/io.h +0 -0
index 59ec5eea696c4..7695d7973c8ff 100644
@@ -163,6 +163,9 @@ enum {
 void *memremap(resource_size_t offset, size_t size, unsigned long flags);
 void memunmap(void *addr);
 
Quoted 7 lines
Quoted 5 lines

include/linux/io.h enum { · line 167

Quoted 2 lines
include/linux/io.h +2 -0
+DEFINE_FREE(iounmap, void __iomem *, if (!IS_ERR_OR_NULL(_T)) iounmap(_T))
+DEFINE_FREE(memunmap, void *, if (!IS_ERR_OR_NULL(_T)) memunmap(_T))

I don't like the use of IS_ERR_OR_NULL(), which tends to indicate a problem in the interface design.

Just !(_T) ? I just refer kfree()'s implementation.

Right, I think !(_T) is what we want here. I did see that kfree has the same construct you are adding here, but did not read up on how it got there.

Quoted 8 lines
Quoted 4 lines

In which cases do you expect to need scope based cleanup on an error pointer here? The only interfaces I see that returns an __iomem error pointer are the devm_* ones, but those have their own cleanup method.

devm_* can help much especial in probe() function. but scope base cleanup also useful.

Yes, that's fine. My only point here is that you can't combine the cleanup function you added with devm_ioremap(), as that needs to be paired with either implicit cleanup or with devm_iounmap() but not plain iounmap().

Arnd