LCOV - code coverage report
Current view: top level - lkbce/include/linux - init.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          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 */

Generated by: LCOV version 1.10