Skip to contentSkip to conversation

introduce __init_exit function annotation

PATCH In review Domen Puncer 4 participants 13 messages Jul 17, 2007

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 introduce __init_exit function annotation

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

---
 include/linux/init.h |    2 ++
 1 file changed, 2 insertions(+)
include/linux/init.h +2 -0
Index: work-powerpc.git/include/linux/init.h
===================================================================
@@ -60,8 +60,10 @@
 
 #ifdef MODULE
 #define __exit		__attribute__ ((__section__(".exit.text")))
+#define __init_exit
 #else
 #define __exit		__attribute_used__ __attribute__ ((__section__(".exit.text")))
+#define __init_exit	__init
 #endif
 
 /* For assembly routines */
#1 lore raw
Quoted 14 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

---
 include/linux/init.h |    2 ++
 1 file changed, 2 insertions(+)

Index: work-powerpc.git/include/linux/init.h
===================================================================

include/linux/init.h line 69

Quoted 10 lines
include/linux/init.h +2 -0
@@ -60,8 +60,10 @@
 
 #ifdef MODULE
 #define __exit		__attribute__ ((__section__(".exit.text")))
+#define __init_exit
 #else
 #define __exit		__attribute_used__ __attribute__ ((__section__(".exit.text")))
+#define __init_exit	__init
 #endif
 
 /* For assembly routines */

This doesn't work on architectures like i386 where __exit code is discarded at runtime.

cu
Adrian

Signature · 4 lines
       "Is there not promise of rain?" Ling Tan asked suddenly out
        of the darkness. There had been need of rain for many days.
       "Only a promise," Lao Er said.
                                       Pearl S. Buck - Dragon Seed
#2 lore raw
Quoted 24 lines · Adrian Bunk
Quoted 23 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

---
 include/linux/init.h |    2 ++
 1 file changed, 2 insertions(+)

Index: work-powerpc.git/include/linux/init.h
===================================================================

include/linux/init.h +2 -0
@@ -60,8 +60,10 @@
 
 #ifdef MODULE
 #define __exit		__attribute__ ((__section__(".exit.text")))
+#define __init_exit
 #else
 #define __exit		__attribute_used__ __attribute__ ((__section__(".exit.text")))
+#define __init_exit	__init
 #endif
 
Quoted 4 lines

include/linux/init.h line 69

Quoted 1 line
include/linux/init.h +0 -0
 /* For assembly routines */

This doesn't work on architectures like i386 where __exit code is discarded at runtime.

If it's a module, then it shouldn't be discarded until unload anyway. If it's in-kernel, then it'll be discarded as __init stuff. I don't see a problem?

BTW. can you point me to reasoning for discarding __exit at runtime?

Domen

Quoted 10 lines

cu
Adrian

Signature · 4 lines
       "Is there not promise of rain?" Ling Tan asked suddenly out
        of the darkness. There had been need of rain for many days.
       "Only a promise," Lao Er said.
                                       Pearl S. Buck - Dragon Seed
#3 lore raw
In reply to Domen Puncer
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

The real solution is only to declare functiones used solely during exit as __exit.
The whole point of using __exit is to tell that this can be safely dropped when built-in because it is not used then.

Sam

#4 lore raw

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 9 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

Takashi

#5 lore raw
Quoted 7 lines · Takashi Iwai

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 5 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

Quoted 7 lines
Quoted 4 lines

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

The cleanup functions are marked __exit in the referenced case.

Sam

#6 lore raw

At Tue, 17 Jul 2007 17:14:32 +0200,

Quoted 14 lines · Sam Ravnborg
Quoted 12 lines · Takashi Iwai

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 9 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Quoted 4 lines
Quoted 2 lines

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

The cleanup functions are marked __exit in the referenced case.

My understanding is that it's the very purpose of this patch -- change the mark from __exit to __init_exit for such clean-up functions.

Takashi

#7 lore raw
Quoted 16 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:14:32 +0200,

Quoted 14 lines · Sam Ravnborg
Quoted 12 lines · Takashi Iwai

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 9 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Quoted 8 lines
Quoted 4 lines
Quoted 2 lines

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

The cleanup functions are marked __exit in the referenced case.

My understanding is that it's the very purpose of this patch -- change the mark from __exit to __init_exit for such clean-up functions.

And that is wrong.
See following example:

static void __init foo_init()

{
	if (error)
		foo_exit();
}

static void __exit foo_exit()
{
}

If foo_init is annotated with __init_exit then in the build-in case it become __init and there is a reference to a non existing function because functions marked __exit are discarded during link or run-time (depending on arch).

If foo_exit() are marked __init_exit then it becomes __init in the non-module case which seems coorrect. If this is the intention of the patch then it should be OK but then this intention should be spelled out.

Sam

#8 lore raw

At Tue, 17 Jul 2007 17:32:36 +0200,

Quoted 21 lines · Sam Ravnborg
Quoted 19 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:14:32 +0200,

Quoted 17 lines · Sam Ravnborg
Quoted 14 lines · Takashi Iwai

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 9 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

The cleanup functions are marked __exit in the referenced case.

My understanding is that it's the very purpose of this patch -- change the mark from __exit to __init_exit for such clean-up functions.

And that is wrong.

You misunderstood. What I meant is the case like this:

static void __init_exit cleanup()

{
	...
}

static void __init foo_init()

{
	if (error)
		cleanup();
}

static void __exit foo_exit()

{
	cleanup();
}

Currently, there is no proper way to mark cleanup(). Neither __init, __exit, __devinit nor __devexit can be used there.

Takashi

#9 lore raw
Quoted 44 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:32:36 +0200,

Quoted 21 lines · Sam Ravnborg
Quoted 19 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:14:32 +0200,

Quoted 17 lines · Sam Ravnborg
Quoted 14 lines · Takashi Iwai

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 9 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

The cleanup functions are marked __exit in the referenced case.

My understanding is that it's the very purpose of this patch -- change the mark from __exit to __init_exit for such clean-up functions.

And that is wrong.

You misunderstood. What I meant is the case like this:

static void __init_exit cleanup()

{
	...
}

static void __init foo_init()

{
	if (error)
		cleanup();
}
Quoted 7 lines

static void __exit foo_exit()

{
	cleanup();
}

Currently, there is no proper way to mark cleanup(). Neither __init, __exit, __devinit nor __devexit can be used there.

Then you get the annotation sorted out so cleanup() get discarded in the built-in case. But you leave no room for automated tools to detect this.

If this is really necessary (and I daught) then a specific section should be dedicated for this usage.

We have lot of issues with current __init/__exit, __devinit/__devexit, __cpuint/__cpuexit and introducing more of the kind does not help it.
So even if it saves a few bytes in some odd cases the added complaxity is IMHO not worth it.

Sam

#10 lore raw

At Tue, 17 Jul 2007 18:48:46 +0200,

Quoted 57 lines · Sam Ravnborg
Quoted 44 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:32:36 +0200,

Quoted 21 lines · Sam Ravnborg
Quoted 19 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:14:32 +0200,

Quoted 17 lines · Sam Ravnborg
Quoted 14 lines · Takashi Iwai

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 9 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

The cleanup functions are marked __exit in the referenced case.

My understanding is that it's the very purpose of this patch -- change the mark from __exit to __init_exit for such clean-up functions.

And that is wrong.

You misunderstood. What I meant is the case like this:

static void __init_exit cleanup()

{
	...
}

static void __init foo_init()

{
	if (error)
		cleanup();
}
Quoted 7 lines

static void __exit foo_exit()

{
	cleanup();
}

Currently, there is no proper way to mark cleanup(). Neither __init, __exit, __devinit nor __devexit can be used there.

Then you get the annotation sorted out so cleanup() get discarded in the built-in case. But you leave no room for automated tools to detect this.

Quoted 6 lines

If this is really necessary (and I daught) then a specific section should be dedicated for this usage.

We have lot of issues with current __init/__exit, __devinit/__devexit, __cpuint/__cpuexit and introducing more of the kind does not help it.
So even if it saves a few bytes in some odd cases the added complaxity is IMHO not worth it.

Well, I don't think it's a few bytes and not so odd, but I agree that this solution isn't the best way. And, I now remember that this won't work anyway, too. Calling __init from __exit also causes error...

BTW, this reminds me why we have to add annotations for each subisdiary function manually. A tool to parse the code statically and give the proper annotations/hints would be really nice.

Takashi

#11 lore raw
Quoted 62 lines · Takashi Iwai

At Tue, 17 Jul 2007 18:48:46 +0200,

Quoted 60 lines · Sam Ravnborg
Quoted 44 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:32:36 +0200,

Quoted 21 lines · Sam Ravnborg
Quoted 19 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:14:32 +0200,

Quoted 17 lines · Sam Ravnborg
Quoted 14 lines · Takashi Iwai

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 9 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

The cleanup functions are marked __exit in the referenced case.

My understanding is that it's the very purpose of this patch -- change the mark from __exit to __init_exit for such clean-up functions.

And that is wrong.

You misunderstood. What I meant is the case like this:

static void __init_exit cleanup()

{
	...
}

static void __init foo_init()

{
	if (error)
		cleanup();
}
Quoted 7 lines

static void __exit foo_exit()

{
	cleanup();
}

Currently, there is no proper way to mark cleanup(). Neither __init, __exit, __devinit nor __devexit can be used there.

Then you get the annotation sorted out so cleanup() get discarded in the built-in case. But you leave no room for automated tools to detect this.

If this is really necessary (and I daught) then a specific section should be dedicated for this usage.

Quoted 7 lines
Quoted 3 lines

We have lot of issues with current __init/__exit, __devinit/__devexit, __cpuint/__cpuexit and introducing more of the kind does not help it.
So even if it saves a few bytes in some odd cases the added complaxity is IMHO not worth it.

Well, I don't think it's a few bytes and not so odd, but I agree that this solution isn't the best way. And, I now remember that this won't work anyway, too. Calling __init from __exit also causes error...

I made this patch because I saw __init calling __exit in yet another driver (gianfar). Guess I'll just send the old way fix, and remove __exit.

As for calling __init_exit from __exit:
1 - in kernel, there's no __exit => no problem
2 - module, __init_exit is a no-op => no problem

the code in question again:

Review

Quoted 7 lines

#ifdef MODULE
#define __exit __attribute__ ((__section__(".exit.text")))

(quoted diff) +2 -0
+#define __init_exit
 #else
 #define __exit               __attribute_used__ __attribute__ ((__section__(".exit.text")))
+#define __init_exit  __init
 #endif

Or maybe it's the name that is confuzing, but it makes sense to me:
__init_exit - you can call it from __init or __exit. __init_or_exit?

Domen

#12 lore raw
In reply to Takashi Iwai
Quoted 44 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:32:36 +0200,

Quoted 21 lines · Sam Ravnborg
Quoted 19 lines · Takashi Iwai

At Tue, 17 Jul 2007 17:14:32 +0200,

Quoted 17 lines · Sam Ravnborg
Quoted 14 lines · Takashi Iwai

At Tue, 17 Jul 2007 15:02:30 +0200,

Quoted 9 lines · Sam Ravnborg
Quoted 2 lines · Domen Puncer

Introduce __init_exit, which is useful ie. for drivers that call cleanup functions when they fail in __init functions.

This is wrong.
On arm (just one example of several) the __exit section are discarded at buildtime so any reference from __init to __exit will cause the linker to error out.

Hmm, from what I see, it adds __init to the function. There is no reference to __exit.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

The cleanup functions are marked __exit in the referenced case.

My understanding is that it's the very purpose of this patch -- change the mark from __exit to __init_exit for such clean-up functions.

And that is wrong.

You misunderstood. What I meant is the case like this:

static void __init_exit cleanup()

{
	...
}

static void __init foo_init()

{
	if (error)
		cleanup();
}
Quoted 4 lines

static void __exit foo_exit()

{
	cleanup();
}

Uh, yes, this, or just __init_exit foo_exit() as in Sam's example. It seemed obvious to me, sorry.

Quoted 6 lines

Currently, there is no proper way to mark cleanup(). Neither __init, __exit, __devinit nor __devexit can be used there.

Takashi