include/linux/init.h

   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 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  */
  63 typedef int (*initcall_t)(void);
  64 typedef void (*exitcall_t)(void);
  65
  66 extern initcall_t __con_initcall_start[], __con_initcall_end[];
  67 extern initcall_t __security_initcall_start[], __security_initcall_end[];
  68
  69 /* Defined in init/main.c */
  70 extern char saved_command_line[];
  71
  72 /* used by init/main.c */
  73 extern void setup_arch(char **);
  74
  75 #endif
  76
  77 #ifndef MODULE
  78
  79 #ifndef __ASSEMBLY__
  80
  81 /* initcalls are now grouped by functionality into separate
  82  * subsections. Ordering inside the subsections is determined
  83  * by link order.
  84  * For backwards compatibility, initcall() puts the call in
  85  * the device init subsection.
  86  */
  87
  88 #define __define_initcall(level,fn) \
  89         static initcall_t __initcall_##fn __attribute_used__ \
  90         __attribute__((__section__(".initcall" level ".init"))) = fn
  91
  92 #define core_initcall(fn)               __define_initcall("1",fn)
  93 #define postcore_initcall(fn)           __define_initcall("2",fn)
  94 #define arch_initcall(fn)               __define_initcall("3",fn)
  95 #define subsys_initcall(fn)             __define_initcall("4",fn)
  96 #define fs_initcall(fn)                 __define_initcall("5",fn)
  97 #define device_initcall(fn)             __define_initcall("6",fn)
  98 #define late_initcall(fn)               __define_initcall("7",fn)
  99
 100 #define __initcall(fn) device_initcall(fn)
 101
 102 #define __exitcall(fn) \
 103         static exitcall_t __exitcall_##fn __exit_call = fn
 104
 105 #define console_initcall(fn) \
 106         static initcall_t __initcall_##fn \
 107         __attribute_used__ __attribute__((__section__(".con_initcall.init")))=fn
 108
 109 #define security_initcall(fn) \
 110         static initcall_t __initcall_##fn \
 111         __attribute_used__ __attribute__((__section__(".security_initcall.init"))) = fn
 112
 113 struct obs_kernel_param {
 114         const char *str;
 115         int (*setup_func)(char *);
 116         int early;
 117 };
 118
 119 /*
 120  * Only for really core code.  See moduleparam.h for the normal way.
 121  *
 122  * Force the alignment so the compiler doesn't space elements of the
 123  * obs_kernel_param "array" too far apart in .init.setup.
 124  */
 125 #define __setup_param(str, unique_id, fn, early)                        \
 126         static char __setup_str_##unique_id[] __initdata = str; \
 127         static struct obs_kernel_param __setup_##unique_id      \
 128                 __attribute_used__                              \
 129                 __attribute__((__section__(".init.setup")))     \
 130                 __attribute__((aligned((sizeof(long)))))        \
 131                 = { __setup_str_##unique_id, fn, early }
 132
 133 #define __setup_null_param(str, unique_id)                      \
 134         __setup_param(str, unique_id, NULL, 0)
 135
 136 #define __setup(str, fn)                                        \
 137         __setup_param(str, fn, fn, 0)
 138
 139 #define __obsolete_setup(str)                                   \
 140         __setup_null_param(str, __LINE__)
 141
 142 /* NOTE: fn is as per module_param, not __setup!  Emits warning if fn
 143  * returns non-zero. */
 144 #define early_param(str, fn)                                    \
 145         __setup_param(str, fn, fn, 1)
 146
 147 /* Relies on saved_command_line being set */
 148 void __init parse_early_param(void);
 149 #endif /* __ASSEMBLY__ */
 150
 151 /**
 152  * module_init() - driver initialization entry point
 153  * @x: function to be run at kernel boot time or module insertion
 154  *
 155  * module_init() will either be called during do_initcalls (if
 156  * builtin) or at module insertion time (if a module).  There can only
 157  * be one per module.
 158  */
 159 #define module_init(x)  __initcall(x);
 160
 161 /**
 162  * module_exit() - driver exit entry point
 163  * @x: function to be run when driver is removed
 164  *
 165  * module_exit() will wrap the driver clean-up code
 166  * with cleanup_module() when used with rmmod when
 167  * the driver is a module.  If the driver is statically
 168  * compiled into the kernel, module_exit() has no effect.
 169  * There can only be one per module.
 170  */
 171 #define module_exit(x)  __exitcall(x);
 172
 173 #else /* MODULE */
 174
 175 /* Don't use these in modules, but some people do... */
 176 #define core_initcall(fn)               module_init(fn)
 177 #define postcore_initcall(fn)           module_init(fn)
 178 #define arch_initcall(fn)               module_init(fn)
 179 #define subsys_initcall(fn)             module_init(fn)
 180 #define fs_initcall(fn)                 module_init(fn)
 181 #define device_initcall(fn)             module_init(fn)
 182 #define late_initcall(fn)               module_init(fn)
 183
 184 #define security_initcall(fn)           module_init(fn)
 185
 186 /* These macros create a dummy inline: gcc 2.9x does not count alias
 187  as usage, hence the `unused function' warning when __init functions
 188  are declared static. We use the dummy __*_module_inline functions
 189  both to kill the warning and check the type of the init/cleanup
 190  function. */
 191
 192 /* Each module must use one module_init(), or one no_module_init */
 193 #define module_init(initfn)                                     \
 194         static inline initcall_t __inittest(void)               \
 195         { return initfn; }                                      \
 196         int init_module(void) __attribute__((alias(#initfn)));
 197
 198 /* This is only required if you want to be unloadable. */
 199 #define module_exit(exitfn)                                     \
 200         static inline exitcall_t __exittest(void)               \
 201         { return exitfn; }                                      \
 202         void cleanup_module(void) __attribute__((alias(#exitfn)));
 203
 204 #define __setup_param(str, unique_id, fn)       /* nothing */
 205 #define __setup_null_param(str, unique_id)      /* nothing */
 206 #define __setup(str, func)                      /* nothing */
 207 #define __obsolete_setup(str)                   /* nothing */
 208 #endif
 209
 210 /* Data marked not to be saved by software_suspend() */
 211 #define __nosavedata __attribute__ ((__section__ (".data.nosave")))
 212
 213 /* This means "can be init if no module support, otherwise module load
 214    may call it." */
 215 #ifdef CONFIG_MODULES
 216 #define __init_or_module
 217 #define __initdata_or_module
 218 #else
 219 #define __init_or_module __init
 220 #define __initdata_or_module __initdata
 221 #endif /*CONFIG_MODULES*/
 222
 223 #ifdef CONFIG_HOTPLUG
 224 #define __devinit
 225 #define __devinitdata
 226 #define __devexit
 227 #define __devexitdata
 228 #else
 229 #define __devinit __init
 230 #define __devinitdata __initdata
 231 #define __devexit __exit
 232 #define __devexitdata __exitdata
 233 #endif
 234
 235 #ifdef CONFIG_HOTPLUG_CPU
 236 #define __cpuinit
 237 #define __cpuinitdata
 238 #define __cpuexit
 239 #define __cpuexitdata
 240 #else
 241 #define __cpuinit       __init
 242 #define __cpuinitdata __initdata
 243 #define __cpuexit __exit
 244 #define __cpuexitdata   __exitdata
 245 #endif
 246
 247 #if defined(CONFIG_MEMORY_HOTPLUG) || defined(CONFIG_ACPI_HOTPLUG_MEMORY) \
 248         || defined(CONFIG_ACPI_HOTPLUG_MEMORY_MODULE)
 249 #define __meminit
 250 #define __meminitdata
 251 #define __memexit
 252 #define __memexitdata
 253 #else
 254 #define __meminit       __init
 255 #define __meminitdata __initdata
 256 #define __memexit __exit
 257 #define __memexitdata   __exitdata
 258 #endif
 259
 260 /* Functions marked as __devexit may be discarded at kernel link time, depending
 261    on config options.  Newer versions of binutils detect references from
 262    retained sections to discarded sections and flag an error.  Pointers to
 263    __devexit functions must use __devexit_p(function_name), the wrapper will
 264    insert either the function_name or NULL, depending on the config options.
 265  */
 266 #if defined(MODULE) || defined(CONFIG_HOTPLUG)
 267 #define __devexit_p(x) x
 268 #else
 269 #define __devexit_p(x) NULL
 270 #endif
 271
 272 #ifdef MODULE
 273 #define __exit_p(x) x
 274 #else
 275 #define __exit_p(x) NULL
 276 #endif
 277
 278 #endif /* _LINUX_INIT_H */