blob: e290a010e3f2dec2555f7c2f243b20702a86e5fe [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_INIT_H
2#define _LINUX_INIT_H
3
Linus Torvalds1da177e2005-04-16 15:20:36 -07004#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 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 * 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 __attribute__ ((__section__ (".init.text")))
44#define __initdata __attribute__ ((__section__ (".init.data")))
45#define __exitdata __attribute__ ((__section__(".exit.data")))
46#define __exit_call __attribute_used__ __attribute__ ((__section__ (".exitcall.exit")))
47
48#ifdef MODULE
49#define __exit __attribute__ ((__section__(".exit.text")))
50#else
51#define __exit __attribute_used__ __attribute__ ((__section__(".exit.text")))
52#endif
53
54/* For assembly routines */
55#define __INIT .section ".init.text","ax"
56#define __FINIT .previous
57#define __INITDATA .section ".init.data","aw"
58
59#ifndef __ASSEMBLY__
60/*
61 * Used for initialization calls..
62 */
63typedef int (*initcall_t)(void);
64typedef void (*exitcall_t)(void);
65
66extern initcall_t __con_initcall_start[], __con_initcall_end[];
67extern initcall_t __security_initcall_start[], __security_initcall_end[];
68
69/* Defined in init/main.c */
Alon Bar-Lev30d7e0d2007-02-12 00:53:52 -080070extern char __initdata boot_command_line[];
71extern char *saved_command_line;
Vivek Goyal7e962872006-09-27 01:50:44 -070072extern unsigned int reset_devices;
Adrian Bunk77d47582006-03-25 03:07:39 -080073
74/* used by init/main.c */
75extern void setup_arch(char **);
76
Linus Torvalds1da177e2005-04-16 15:20:36 -070077#endif
78
79#ifndef MODULE
80
81#ifndef __ASSEMBLY__
82
83/* initcalls are now grouped by functionality into separate
84 * subsections. Ordering inside the subsections is determined
85 * by link order.
86 * For backwards compatibility, initcall() puts the call in
87 * the device init subsection.
Andrew Morton735a7ff2006-10-27 11:42:37 -070088 *
89 * The `id' arg to __define_initcall() is needed so that multiple initcalls
90 * can point at the same handler without causing duplicate-symbol build errors.
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 */
92
Andrew Morton735a7ff2006-10-27 11:42:37 -070093#define __define_initcall(level,fn,id) \
94 static initcall_t __initcall_##fn##id __attribute_used__ \
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 __attribute__((__section__(".initcall" level ".init"))) = fn
96
Linus Torvaldsb3438f82006-11-20 11:47:18 -080097/*
98 * A "pure" initcall has no dependencies on anything else, and purely
99 * initializes variables that couldn't be statically initialized.
100 *
101 * This only exists for built-in code, not for modules.
102 */
103#define pure_initcall(fn) __define_initcall("0",fn,1)
104
Andrew Morton735a7ff2006-10-27 11:42:37 -0700105#define core_initcall(fn) __define_initcall("1",fn,1)
106#define core_initcall_sync(fn) __define_initcall("1s",fn,1s)
107#define postcore_initcall(fn) __define_initcall("2",fn,2)
108#define postcore_initcall_sync(fn) __define_initcall("2s",fn,2s)
109#define arch_initcall(fn) __define_initcall("3",fn,3)
110#define arch_initcall_sync(fn) __define_initcall("3s",fn,3s)
111#define subsys_initcall(fn) __define_initcall("4",fn,4)
112#define subsys_initcall_sync(fn) __define_initcall("4s",fn,4s)
113#define fs_initcall(fn) __define_initcall("5",fn,5)
114#define fs_initcall_sync(fn) __define_initcall("5s",fn,5s)
Linus Torvalds8d610dd2006-12-11 12:12:04 -0800115#define rootfs_initcall(fn) __define_initcall("rootfs",fn,rootfs)
Andrew Morton735a7ff2006-10-27 11:42:37 -0700116#define device_initcall(fn) __define_initcall("6",fn,6)
117#define device_initcall_sync(fn) __define_initcall("6s",fn,6s)
118#define late_initcall(fn) __define_initcall("7",fn,7)
119#define late_initcall_sync(fn) __define_initcall("7s",fn,7s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121#define __initcall(fn) device_initcall(fn)
122
123#define __exitcall(fn) \
124 static exitcall_t __exitcall_##fn __exit_call = fn
125
126#define console_initcall(fn) \
127 static initcall_t __initcall_##fn \
128 __attribute_used__ __attribute__((__section__(".con_initcall.init")))=fn
129
130#define security_initcall(fn) \
131 static initcall_t __initcall_##fn \
132 __attribute_used__ __attribute__((__section__(".security_initcall.init"))) = fn
133
134struct obs_kernel_param {
135 const char *str;
136 int (*setup_func)(char *);
137 int early;
138};
139
140/*
141 * Only for really core code. See moduleparam.h for the normal way.
142 *
143 * Force the alignment so the compiler doesn't space elements of the
144 * obs_kernel_param "array" too far apart in .init.setup.
145 */
146#define __setup_param(str, unique_id, fn, early) \
147 static char __setup_str_##unique_id[] __initdata = str; \
148 static struct obs_kernel_param __setup_##unique_id \
149 __attribute_used__ \
150 __attribute__((__section__(".init.setup"))) \
151 __attribute__((aligned((sizeof(long))))) \
152 = { __setup_str_##unique_id, fn, early }
153
154#define __setup_null_param(str, unique_id) \
155 __setup_param(str, unique_id, NULL, 0)
156
157#define __setup(str, fn) \
158 __setup_param(str, fn, fn, 0)
159
160#define __obsolete_setup(str) \
161 __setup_null_param(str, __LINE__)
162
163/* NOTE: fn is as per module_param, not __setup! Emits warning if fn
164 * returns non-zero. */
165#define early_param(str, fn) \
166 __setup_param(str, fn, fn, 1)
167
Alon Bar-Lev30d7e0d2007-02-12 00:53:52 -0800168/* Relies on boot_command_line being set */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169void __init parse_early_param(void);
170#endif /* __ASSEMBLY__ */
171
172/**
173 * module_init() - driver initialization entry point
174 * @x: function to be run at kernel boot time or module insertion
175 *
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800176 * module_init() will either be called during do_initcalls() (if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 * builtin) or at module insertion time (if a module). There can only
178 * be one per module.
179 */
180#define module_init(x) __initcall(x);
181
182/**
183 * module_exit() - driver exit entry point
184 * @x: function to be run when driver is removed
185 *
186 * module_exit() will wrap the driver clean-up code
187 * with cleanup_module() when used with rmmod when
188 * the driver is a module. If the driver is statically
189 * compiled into the kernel, module_exit() has no effect.
190 * There can only be one per module.
191 */
192#define module_exit(x) __exitcall(x);
193
194#else /* MODULE */
195
196/* Don't use these in modules, but some people do... */
197#define core_initcall(fn) module_init(fn)
198#define postcore_initcall(fn) module_init(fn)
199#define arch_initcall(fn) module_init(fn)
200#define subsys_initcall(fn) module_init(fn)
201#define fs_initcall(fn) module_init(fn)
202#define device_initcall(fn) module_init(fn)
203#define late_initcall(fn) module_init(fn)
204
205#define security_initcall(fn) module_init(fn)
206
207/* These macros create a dummy inline: gcc 2.9x does not count alias
208 as usage, hence the `unused function' warning when __init functions
209 are declared static. We use the dummy __*_module_inline functions
210 both to kill the warning and check the type of the init/cleanup
211 function. */
212
213/* Each module must use one module_init(), or one no_module_init */
214#define module_init(initfn) \
215 static inline initcall_t __inittest(void) \
216 { return initfn; } \
217 int init_module(void) __attribute__((alias(#initfn)));
218
219/* This is only required if you want to be unloadable. */
220#define module_exit(exitfn) \
221 static inline exitcall_t __exittest(void) \
222 { return exitfn; } \
223 void cleanup_module(void) __attribute__((alias(#exitfn)));
224
225#define __setup_param(str, unique_id, fn) /* nothing */
226#define __setup_null_param(str, unique_id) /* nothing */
227#define __setup(str, func) /* nothing */
228#define __obsolete_setup(str) /* nothing */
229#endif
230
231/* Data marked not to be saved by software_suspend() */
232#define __nosavedata __attribute__ ((__section__ (".data.nosave")))
233
234/* This means "can be init if no module support, otherwise module load
235 may call it." */
236#ifdef CONFIG_MODULES
237#define __init_or_module
238#define __initdata_or_module
239#else
240#define __init_or_module __init
241#define __initdata_or_module __initdata
242#endif /*CONFIG_MODULES*/
243
244#ifdef CONFIG_HOTPLUG
245#define __devinit
246#define __devinitdata
247#define __devexit
248#define __devexitdata
249#else
250#define __devinit __init
251#define __devinitdata __initdata
252#define __devexit __exit
253#define __devexitdata __exitdata
254#endif
255
Ashok Raje6982c62005-06-25 14:54:58 -0700256#ifdef CONFIG_HOTPLUG_CPU
257#define __cpuinit
258#define __cpuinitdata
259#define __cpuexit
260#define __cpuexitdata
261#else
262#define __cpuinit __init
263#define __cpuinitdata __initdata
264#define __cpuexit __exit
265#define __cpuexitdata __exitdata
266#endif
267
Andi Kleen9d99aaa2006-04-07 19:49:15 +0200268#if defined(CONFIG_MEMORY_HOTPLUG) || defined(CONFIG_ACPI_HOTPLUG_MEMORY) \
269 || defined(CONFIG_ACPI_HOTPLUG_MEMORY_MODULE)
Matt Tolentinoc09b4242006-01-17 07:03:44 +0100270#define __meminit
271#define __meminitdata
272#define __memexit
273#define __memexitdata
274#else
275#define __meminit __init
276#define __meminitdata __initdata
277#define __memexit __exit
278#define __memexitdata __exitdata
279#endif
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281/* Functions marked as __devexit may be discarded at kernel link time, depending
282 on config options. Newer versions of binutils detect references from
283 retained sections to discarded sections and flag an error. Pointers to
284 __devexit functions must use __devexit_p(function_name), the wrapper will
285 insert either the function_name or NULL, depending on the config options.
286 */
287#if defined(MODULE) || defined(CONFIG_HOTPLUG)
288#define __devexit_p(x) x
289#else
290#define __devexit_p(x) NULL
291#endif
292
293#ifdef MODULE
294#define __exit_p(x) x
295#else
296#define __exit_p(x) NULL
297#endif
298
299#endif /* _LINUX_INIT_H */