Line data Source code
1 : #ifndef _LINUX_INIT_H
2 : #define _LINUX_INIT_H
3 :
4 : #include <linux/compiler.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 const char linux_logo[] __initconst = { 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 : * Also note, that this data cannot be "const".
39 : */
40 :
41 : /* These are for everybody (although not all archs will actually
42 : discard it in modules) */
43 : #define __init __section(.init.text) __cold notrace
44 : #define __initdata __section(.init.data)
45 : #define __initconst __section(.init.rodata)
46 : #define __exitdata __section(.exit.data)
47 : #define __exit_call __used __section(.exitcall.exit)
48 :
49 : /* modpost check for section mismatches during the kernel build.
50 : * A section mismatch happens when there are references from a
51 : * code or data section to an init section (both code or data).
52 : * The init sections are (for most archs) discarded by the kernel
53 : * when early init has completed so all such references are potential bugs.
54 : * For exit sections the same issue exists.
55 : * The following markers are used for the cases where the reference to
56 : * the *init / *exit section (code or data) is valid and will teach
57 : * modpost not to issue a warning.
58 : * The markers follow same syntax rules as __init / __initdata. */
59 : #define __ref __section(.ref.text) noinline
60 : #define __refdata __section(.ref.data)
61 : #define __refconst __section(.ref.rodata)
62 :
63 : /* compatibility defines */
64 : #define __init_refok __ref
65 : #define __initdata_refok __refdata
66 : #define __exit_refok __ref
67 :
68 :
69 : #ifdef MODULE
70 : #define __exitused
71 : #else
72 : #define __exitused __used
73 : #endif
74 :
75 : #define __exit __section(.exit.text) __exitused __cold
76 :
77 : /* Used for HOTPLUG */
78 : #define __devinit __section(.devinit.text) __cold
79 : #define __devinitdata __section(.devinit.data)
80 : #define __devinitconst __section(.devinit.rodata)
81 : #define __devexit __section(.devexit.text) __exitused __cold
82 : #define __devexitdata __section(.devexit.data)
83 : #define __devexitconst __section(.devexit.rodata)
84 :
85 : /* Used for HOTPLUG_CPU */
86 : #define __cpuinit __section(.cpuinit.text) __cold
87 : #define __cpuinitdata __section(.cpuinit.data)
88 : #define __cpuinitconst __section(.cpuinit.rodata)
89 : #define __cpuexit __section(.cpuexit.text) __exitused __cold
90 : #define __cpuexitdata __section(.cpuexit.data)
91 : #define __cpuexitconst __section(.cpuexit.rodata)
92 :
93 : /* Used for MEMORY_HOTPLUG */
94 : #define __meminit __section(.meminit.text) __cold
95 : #define __meminitdata __section(.meminit.data)
96 : #define __meminitconst __section(.meminit.rodata)
97 : #define __memexit __section(.memexit.text) __exitused __cold
98 : #define __memexitdata __section(.memexit.data)
99 : #define __memexitconst __section(.memexit.rodata)
100 :
101 : /* For assembly routines */
102 : #define __HEAD .section ".head.text","ax"
103 : #define __INIT .section ".init.text","ax"
104 : #define __FINIT .previous
105 :
106 : #define __INITDATA .section ".init.data","aw",%progbits
107 : #define __INITRODATA .section ".init.rodata","a",%progbits
108 : #define __FINITDATA .previous
109 :
110 : #define __DEVINIT .section ".devinit.text", "ax"
111 : #define __DEVINITDATA .section ".devinit.data", "aw"
112 : #define __DEVINITRODATA .section ".devinit.rodata", "a"
113 :
114 : #define __CPUINIT .section ".cpuinit.text", "ax"
115 : #define __CPUINITDATA .section ".cpuinit.data", "aw"
116 : #define __CPUINITRODATA .section ".cpuinit.rodata", "a"
117 :
118 : #define __MEMINIT .section ".meminit.text", "ax"
119 : #define __MEMINITDATA .section ".meminit.data", "aw"
120 : #define __MEMINITRODATA .section ".meminit.rodata", "a"
121 :
122 : /* silence warnings when references are OK */
123 : #define __REF .section ".ref.text", "ax"
124 : #define __REFDATA .section ".ref.data", "aw"
125 : #define __REFCONST .section ".ref.rodata", "a"
126 :
127 : #ifndef __ASSEMBLY__
128 : /*
129 : * Used for initialization calls..
130 : */
131 : typedef int (*initcall_t)(void);
132 : typedef void (*exitcall_t)(void);
133 :
134 : extern initcall_t __con_initcall_start[], __con_initcall_end[];
135 : extern initcall_t __security_initcall_start[], __security_initcall_end[];
136 :
137 : /* Used for contructor calls. */
138 : typedef void (*ctor_fn_t)(void);
139 :
140 : /* Defined in init/main.c */
141 : extern int do_one_initcall(initcall_t fn);
142 : extern char __initdata boot_command_line[];
143 : extern char *saved_command_line;
144 : extern unsigned int reset_devices;
145 :
146 : /* used by init/main.c */
147 : void setup_arch(char **);
148 : void prepare_namespace(void);
149 :
150 : extern void (*late_time_init)(void);
151 :
152 : extern int initcall_debug;
153 :
154 : #endif
155 :
156 : #ifndef MODULE
157 :
158 : #ifndef __ASSEMBLY__
159 :
160 : /* initcalls are now grouped by functionality into separate
161 : * subsections. Ordering inside the subsections is determined
162 : * by link order.
163 : * For backwards compatibility, initcall() puts the call in
164 : * the device init subsection.
165 : *
166 : * The `id' arg to __define_initcall() is needed so that multiple initcalls
167 : * can point at the same handler without causing duplicate-symbol build errors.
168 : */
169 :
170 : #define __define_initcall(level,fn,id) \
171 : static initcall_t __initcall_##fn##id __used \
172 : __attribute__((__section__(".initcall" level ".init"))) = fn
173 :
174 : /*
175 : * Early initcalls run before initializing SMP.
176 : *
177 : * Only for built-in code, not modules.
178 : */
179 : #define early_initcall(fn) __define_initcall("early",fn,early)
180 :
181 : /*
182 : * A "pure" initcall has no dependencies on anything else, and purely
183 : * initializes variables that couldn't be statically initialized.
184 : *
185 : * This only exists for built-in code, not for modules.
186 : */
187 : #define pure_initcall(fn) __define_initcall("0",fn,0)
188 :
189 : #define core_initcall(fn) __define_initcall("1",fn,1)
190 : #define core_initcall_sync(fn) __define_initcall("1s",fn,1s)
191 : #define postcore_initcall(fn) __define_initcall("2",fn,2)
192 : #define postcore_initcall_sync(fn) __define_initcall("2s",fn,2s)
193 : #define arch_initcall(fn) __define_initcall("3",fn,3)
194 : #define arch_initcall_sync(fn) __define_initcall("3s",fn,3s)
195 : #define subsys_initcall(fn) __define_initcall("4",fn,4)
196 : #define subsys_initcall_sync(fn) __define_initcall("4s",fn,4s)
197 : #define fs_initcall(fn) __define_initcall("5",fn,5)
198 : #define fs_initcall_sync(fn) __define_initcall("5s",fn,5s)
199 : #define rootfs_initcall(fn) __define_initcall("rootfs",fn,rootfs)
200 : #define device_initcall(fn) __define_initcall("6",fn,6)
201 : #define device_initcall_sync(fn) __define_initcall("6s",fn,6s)
202 : #define late_initcall(fn) __define_initcall("7",fn,7)
203 : #define late_initcall_sync(fn) __define_initcall("7s",fn,7s)
204 :
205 : #define __initcall(fn) device_initcall(fn)
206 :
207 : #define __exitcall(fn) \
208 : static exitcall_t __exitcall_##fn __exit_call = fn
209 :
210 : #define console_initcall(fn) \
211 : static initcall_t __initcall_##fn \
212 : __used __section(.con_initcall.init) = fn
213 :
214 : #define security_initcall(fn) \
215 : static initcall_t __initcall_##fn \
216 : __used __section(.security_initcall.init) = fn
217 :
218 : struct obs_kernel_param {
219 : const char *str;
220 : int (*setup_func)(char *);
221 : int early;
222 : };
223 :
224 : /*
225 : * Only for really core code. See moduleparam.h for the normal way.
226 : *
227 : * Force the alignment so the compiler doesn't space elements of the
228 : * obs_kernel_param "array" too far apart in .init.setup.
229 : */
230 : #define __setup_param(str, unique_id, fn, early) \
231 : static const char __setup_str_##unique_id[] __initconst \
232 : __aligned(1) = str; \
233 : static struct obs_kernel_param __setup_##unique_id \
234 : __used __section(.init.setup) \
235 : __attribute__((aligned((sizeof(long))))) \
236 : = { __setup_str_##unique_id, fn, early }
237 :
238 : #define __setup(str, fn) \
239 : __setup_param(str, fn, fn, 0)
240 :
241 : /* NOTE: fn is as per module_param, not __setup! Emits warning if fn
242 : * returns non-zero. */
243 : #define early_param(str, fn) \
244 : __setup_param(str, fn, fn, 1)
245 :
246 : /* Relies on boot_command_line being set */
247 : void __init parse_early_param(void);
248 : void __init parse_early_options(char *cmdline);
249 1 : #endif /* __ASSEMBLY__ */
250 :
251 : /**
252 : * module_init() - driver initialization entry point
253 : * @x: function to be run at kernel boot time or module insertion
254 : *
255 : * module_init() will either be called during do_initcalls() (if
256 : * builtin) or at module insertion time (if a module). There can only
257 : * be one per module.
258 : */
259 : #define module_init(x) __initcall(x);
260 :
261 : /**
262 : * module_exit() - driver exit entry point
263 : * @x: function to be run when driver is removed
264 : *
265 : * module_exit() will wrap the driver clean-up code
266 : * with cleanup_module() when used with rmmod when
267 : * the driver is a module. If the driver is statically
268 : * compiled into the kernel, module_exit() has no effect.
269 : * There can only be one per module.
270 : */
271 : #define module_exit(x) __exitcall(x);
272 :
273 : #else /* MODULE */
274 :
275 : /* Don't use these in modules, but some people do... */
276 : #define early_initcall(fn) module_init(fn)
277 : #define core_initcall(fn) module_init(fn)
278 : #define postcore_initcall(fn) module_init(fn)
279 : #define arch_initcall(fn) module_init(fn)
280 : #define subsys_initcall(fn) module_init(fn)
281 : #define fs_initcall(fn) module_init(fn)
282 : #define device_initcall(fn) module_init(fn)
283 : #define late_initcall(fn) module_init(fn)
284 :
285 : #define security_initcall(fn) module_init(fn)
286 :
287 : /* Each module must use one module_init(). */
288 : #define module_init(initfn) \
289 : static inline initcall_t __inittest(void) \
290 : { return initfn; } \
291 : int init_module(void) __attribute__((alias(#initfn)));
292 :
293 : /* This is only required if you want to be unloadable. */
294 : #define module_exit(exitfn) \
295 : static inline exitcall_t __exittest(void) \
296 : { return exitfn; } \
297 : void cleanup_module(void) __attribute__((alias(#exitfn)));
298 :
299 : #define __setup_param(str, unique_id, fn) /* nothing */
300 : #define __setup(str, func) /* nothing */
301 : #endif
302 :
303 : /* Data marked not to be saved by software suspend */
304 : #define __nosavedata __section(.data.nosave)
305 :
306 : /* This means "can be init if no module support, otherwise module load
307 : may call it." */
308 : #ifdef CONFIG_MODULES
309 : #define __init_or_module
310 : #define __initdata_or_module
311 : #define __initconst_or_module
312 : #define __INIT_OR_MODULE .text
313 : #define __INITDATA_OR_MODULE .data
314 : #define __INITRODATA_OR_MODULE .section ".rodata","a",%progbits
315 : #else
316 : #define __init_or_module __init
317 : #define __initdata_or_module __initdata
318 : #define __initconst_or_module __initconst
319 : #define __INIT_OR_MODULE __INIT
320 : #define __INITDATA_OR_MODULE __INITDATA
321 : #define __INITRODATA_OR_MODULE __INITRODATA
322 : #endif /*CONFIG_MODULES*/
323 :
324 : /* Functions marked as __devexit may be discarded at kernel link time, depending
325 : on config options. Newer versions of binutils detect references from
326 : retained sections to discarded sections and flag an error. Pointers to
327 : __devexit functions must use __devexit_p(function_name), the wrapper will
328 : insert either the function_name or NULL, depending on the config options.
329 : */
330 : #if defined(MODULE) || defined(CONFIG_HOTPLUG)
331 : #define __devexit_p(x) x
332 : #else
333 : #define __devexit_p(x) NULL
334 : #endif
335 :
336 : #ifdef MODULE
337 : #define __exit_p(x) x
338 : #else
339 : #define __exit_p(x) NULL
340 : #endif
341 :
342 : #endif /* _LINUX_INIT_H */
|