File: /usr/include/linux/init.h
1 #ifndef _LINUX_INIT_H
2 #define _LINUX_INIT_H
3
4 #include <linux/config.h>
5
6 /* These macros are used to mark some functions or
7 * initialized data (doesn't apply to uninitialized data)
8 * as `initialization' functions. The kernel can take this
9 * as hint that the function is used only during the initialization
10 * phase and free up used memory resources after
11 *
12 * Usage:
13 * For functions:
14 *
15 * You should add __init immediately before the function name, like:
16 *
17 * static void __init initme(int x, int y)
18 * {
19 * extern int z; z = x * y;
20 * }
21 *
22 * If the function has a prototype somewhere, you can also add
23 * __init between closing brace of the prototype and semicolon:
24 *
25 * extern int initialize_foobar_device(int, int, int) __init;
26 *
27 * For initialized data:
28 * You should insert __initdata between the variable name and equal
29 * sign followed by value, e.g.:
30 *
31 * static int init_variable __initdata = 0;
32 * static char linux_logo[] __initdata = { 0x32, 0x36, ... };
33 *
34 * Don't forget to initialize data not at file scope, i.e. within a function,
35 * as gcc otherwise puts the data into the bss section and not into the init
36 * section.
37 */
38
39 #ifndef MODULE
40
41 #ifndef __ASSEMBLY__
42
43 /*
44 * Used for initialization calls..
45 */
46 typedef int (*initcall_t)(void);
47 typedef void (*exitcall_t)(void);
48
49 extern initcall_t __initcall_start, __initcall_end;
50
51 #define __initcall(fn) \
52 static initcall_t __initcall_##fn __init_call = fn
53 #define __exitcall(fn) \
54 static exitcall_t __exitcall_##fn __exit_call = fn
55
56 /*
57 * Used for kernel command line parameter setup
58 */
59 struct kernel_param {
60 const char *str;
61 int (*setup_func)(char *);
62 };
63
64 extern struct kernel_param __setup_start, __setup_end;
65
66 #define __setup(str, fn) \
67 static char __setup_str_##fn[] __initdata = str; \
68 static struct kernel_param __setup_##fn __attribute__((unused)) __initsetup = { __setup_str_##fn, fn }
69
70 #endif /* __ASSEMBLY__ */
71
72 /*
73 * Mark functions and data as being only used at initialization
74 * or exit time.
75 */
76 #define __init __attribute__ ((__section__ (".text.init")))
77 #define __exit __attribute__ ((unused, __section__(".text.exit")))
78 #define __initdata __attribute__ ((__section__ (".data.init")))
79 #define __exitdata __attribute__ ((unused, __section__ (".data.exit")))
80 #define __initsetup __attribute__ ((unused,__section__ (".setup.init")))
81 #define __init_call __attribute__ ((unused,__section__ (".initcall.init")))
82 #define __exit_call __attribute__ ((unused,__section__ (".exitcall.exit")))
83
84 /* For assembly routines */
85 #define __INIT .section ".text.init","ax"
86 #define __FINIT .previous
87 #define __INITDATA .section ".data.init","aw"
88
89 /**
90 * module_init() - driver initialization entry point
91 * @x: function to be run at kernel boot time or module insertion
92 *
93 * module_init() will add the driver initialization routine in
94 * the "__initcall.int" code segment if the driver is checked as
95 * "y" or static, or else it will wrap the driver initialization
96 * routine with init_module() which is used by insmod and
97 * modprobe when the driver is used as a module.
98 */
99 #define module_init(x) __initcall(x);
100
101 /**
102 * module_exit() - driver exit entry point
103 * @x: function to be run when driver is removed
104 *
105 * module_exit() will wrap the driver clean-up code
106 * with cleanup_module() when used with rmmod when
107 * the driver is a module. If the driver is statically
108 * compiled into the kernel, module_exit() has no effect.
109 */
110 #define module_exit(x) __exitcall(x);
111
112 #else
113
114 #define __init
115 #define __exit
116 #define __initdata
117 #define __exitdata
118 #define __initcall(fn)
119 /* For assembly routines */
120 #define __INIT
121 #define __FINIT
122 #define __INITDATA
123
124 /* These macros create a dummy inline: gcc 2.9x does not count alias
125 as usage, hence the `unused function' warning when __init functions
126 are declared static. We use the dummy __*_module_inline functions
127 both to kill the warning and check the type of the init/cleanup
128 function. */
129 typedef int (*__init_module_func_t)(void);
130 typedef void (*__cleanup_module_func_t)(void);
131 #define module_init(x) \
132 int init_module(void) __attribute__((alias(#x))); \
133 extern inline __init_module_func_t __init_module_inline(void) \
134 { return x; }
135 #define module_exit(x) \
136 void cleanup_module(void) __attribute__((alias(#x))); \
137 extern inline __cleanup_module_func_t __cleanup_module_inline(void) \
138 { return x; }
139
140 #define __setup(str,func) /* nothing */
141
142 #endif
143
144 #ifdef CONFIG_HOTPLUG
145 #define __devinit
146 #define __devinitdata
147 #define __devexit
148 #define __devexitdata
149 #else
150 #define __devinit __init
151 #define __devinitdata __initdata
152 #define __devexit __exit
153 #define __devexitdata __exitdata
154 #endif
155
156 #endif /* _LINUX_INIT_H */
157