introduce __init_exit function annotation
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
@@ -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 */
Quoted 14 lines · Domen Puncer
Introduce
__init_exit, which is useful ie. for drivers that call cleanup functions when they fail in__initfunctions.Signed-off-by Domen Puncer <[email protected]>--- 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 SeedQuoted 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__initfunctions.Signed-off-by Domen Puncer <[email protected]>--- 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
__exitcode 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
AdrianSignature · 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
Quoted 2 lines · Domen Puncer
Introduce
__init_exit, which is useful ie. for drivers that call cleanup functions when they fail in__initfunctions.
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
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__initfunctions.This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.
Hmm, from what I see, it adds __init to the function. There is no reference to __exit.
Takashi
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__initfunctions.
Quoted 7 lines
Quoted 4 lines
This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.Hmm, from what I see, it adds
__initto the function. There is no reference to__exit.
The cleanup functions are marked __exit in the referenced case.
Sam
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__initfunctions.This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.
Quoted 4 lines
Quoted 2 lines
Hmm, from what I see, it adds
__initto the function. There is no reference to__exit.The cleanup functions are marked
__exitin 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
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__initfunctions.This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
Hmm, from what I see, it adds
__initto the function. There is no reference to__exit.The cleanup functions are marked
__exitin the referenced case.My understanding is that it's the very purpose of this patch -- change the mark from
__exitto__init_exitfor 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
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__initfunctions.This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.Hmm, from what I see, it adds
__initto the function. There is no reference to__exit.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
The cleanup functions are marked
__exitin the referenced case.My understanding is that it's the very purpose of this patch -- change the mark from
__exitto__init_exitfor 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
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__initfunctions.This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.Hmm, from what I see, it adds
__initto the function. There is no reference to__exit.Quoted 7 lines
Quoted 5 lines
Quoted 1 line
The cleanup functions are marked
__exitin the referenced case.My understanding is that it's the very purpose of this patch -- change the mark from
__exitto__init_exitfor such clean-up functions.And that is wrong.
You misunderstood. What I meant is the case like this:
static void
__init_exitcleanup(){ ... }static void
__initfoo_init(){ if (error) cleanup(); }
Quoted 7 lines
static void
__exitfoo_exit(){ cleanup(); }Currently, there is no proper way to mark
cleanup(). Neither__init,__exit,__devinitnor__devexitcan 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
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__initfunctions.This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.Hmm, from what I see, it adds
__initto the function. There is no reference to__exit.Quoted 7 lines
Quoted 5 lines
Quoted 1 line
The cleanup functions are marked
__exitin the referenced case.My understanding is that it's the very purpose of this patch -- change the mark from
__exitto__init_exitfor such clean-up functions.And that is wrong.
You misunderstood. What I meant is the case like this:
static void
__init_exitcleanup(){ ... }static void
__initfoo_init(){ if (error) cleanup(); }Quoted 7 lines
static void
__exitfoo_exit(){ cleanup(); }Currently, there is no proper way to mark
cleanup(). Neither__init,__exit,__devinitnor__devexitcan 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
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__initfunctions.This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.Hmm, from what I see, it adds
__initto the function. There is no reference to__exit.Quoted 7 lines
Quoted 5 lines
Quoted 1 line
The cleanup functions are marked
__exitin the referenced case.My understanding is that it's the very purpose of this patch -- change the mark from
__exitto__init_exitfor such clean-up functions.And that is wrong.
You misunderstood. What I meant is the case like this:
static void
__init_exitcleanup(){ ... }static void
__initfoo_init(){ if (error) cleanup(); }Quoted 7 lines
static void
__exitfoo_exit(){ cleanup(); }Currently, there is no proper way to mark
cleanup(). Neither__init,__exit,__devinitnor__devexitcan 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
__initfrom__exitalso 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
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__initfunctions.This is wrong.
On arm (just one example of several) the__exitsection are discarded at buildtime so any reference from__initto__exitwill cause the linker to error out.Hmm, from what I see, it adds
__initto the function. There is no reference to__exit.Quoted 7 lines
Quoted 5 lines
Quoted 1 line
The cleanup functions are marked
__exitin the referenced case.My understanding is that it's the very purpose of this patch -- change the mark from
__exitto__init_exitfor such clean-up functions.And that is wrong.
You misunderstood. What I meant is the case like this:
static void
__init_exitcleanup(){ ... }static void
__initfoo_init(){ if (error) cleanup(); }
Quoted 4 lines
static void
__exitfoo_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,__devinitnor__devexitcan be used there.Takashi