~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/init.h

Version: ~ [ linux-6.4-rc3 ] ~ [ linux-6.3.4 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.30 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.113 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.180 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.243 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.283 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.315 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 #ifndef _LINUX_INIT_H
  3 #define _LINUX_INIT_H
  4 
  5 #include <linux/build_bug.h>
  6 #include <linux/compiler.h>
  7 #include <linux/stringify.h>
  8 #include <linux/types.h>
  9 
 10 /* Built-in __init functions needn't be compiled with retpoline */
 11 #if defined(__noretpoline) && !defined(MODULE)
 12 #define __noinitretpoline __noretpoline
 13 #else
 14 #define __noinitretpoline
 15 #endif
 16 
 17 /* These macros are used to mark some functions or 
 18  * initialized data (doesn't apply to uninitialized data)
 19  * as `initialization' functions. The kernel can take this
 20  * as hint that the function is used only during the initialization
 21  * phase and free up used memory resources after
 22  *
 23  * Usage:
 24  * For functions:
 25  * 
 26  * You should add __init immediately before the function name, like:
 27  *
 28  * static void __init initme(int x, int y)
 29  * {
 30  *    extern int z; z = x * y;
 31  * }
 32  *
 33  * If the function has a prototype somewhere, you can also add
 34  * __init between closing brace of the prototype and semicolon:
 35  *
 36  * extern int initialize_foobar_device(int, int, int) __init;
 37  *
 38  * For initialized data:
 39  * You should insert __initdata or __initconst between the variable name
 40  * and equal sign followed by value, e.g.:
 41  *
 42  * static int init_variable __initdata = 0;
 43  * static const char linux_logo[] __initconst = { 0x32, 0x36, ... };
 44  *
 45  * Don't forget to initialize data not at file scope, i.e. within a function,
 46  * as gcc otherwise puts the data into the bss section and not into the init
 47  * section.
 48  */
 49 
 50 /* These are for everybody (although not all archs will actually
 51    discard it in modules) */
 52 #define __init          __section(".init.text") __cold  __latent_entropy __noinitretpoline
 53 #define __initdata      __section(".init.data")
 54 #define __initconst     __section(".init.rodata")
 55 #define __exitdata      __section(".exit.data")
 56 #define __exit_call     __used __section(".exitcall.exit")
 57 
 58 /*
 59  * modpost check for section mismatches during the kernel build.
 60  * A section mismatch happens when there are references from a
 61  * code or data section to an init section (both code or data).
 62  * The init sections are (for most archs) discarded by the kernel
 63  * when early init has completed so all such references are potential bugs.
 64  * For exit sections the same issue exists.
 65  *
 66  * The following markers are used for the cases where the reference to
 67  * the *init / *exit section (code or data) is valid and will teach
 68  * modpost not to issue a warning.  Intended semantics is that a code or
 69  * data tagged __ref* can reference code or data from init section without
 70  * producing a warning (of course, no warning does not mean code is
 71  * correct, so optimally document why the __ref is needed and why it's OK).
 72  *
 73  * The markers follow same syntax rules as __init / __initdata.
 74  */
 75 #define __ref            __section(".ref.text") noinline
 76 #define __refdata        __section(".ref.data")
 77 #define __refconst       __section(".ref.rodata")
 78 
 79 #ifdef MODULE
 80 #define __exitused
 81 #else
 82 #define __exitused  __used
 83 #endif
 84 
 85 #define __exit          __section(".exit.text") __exitused __cold notrace
 86 
 87 /* Used for MEMORY_HOTPLUG */
 88 #define __meminit        __section(".meminit.text") __cold notrace \
 89                                                   __latent_entropy
 90 #define __meminitdata    __section(".meminit.data")
 91 #define __meminitconst   __section(".meminit.rodata")
 92 #define __memexit        __section(".memexit.text") __exitused __cold notrace
 93 #define __memexitdata    __section(".memexit.data")
 94 #define __memexitconst   __section(".memexit.rodata")
 95 
 96 /* For assembly routines */
 97 #define __HEAD          .section        ".head.text","ax"
 98 #define __INIT          .section        ".init.text","ax"
 99 #define __FINIT         .previous
100 
101 #define __INITDATA      .section        ".init.data","aw",%progbits
102 #define __INITRODATA    .section        ".init.rodata","a",%progbits
103 #define __FINITDATA     .previous
104 
105 #define __MEMINIT        .section       ".meminit.text", "ax"
106 #define __MEMINITDATA    .section       ".meminit.data", "aw"
107 #define __MEMINITRODATA  .section       ".meminit.rodata", "a"
108 
109 /* silence warnings when references are OK */
110 #define __REF            .section       ".ref.text", "ax"
111 #define __REFDATA        .section       ".ref.data", "aw"
112 #define __REFCONST       .section       ".ref.rodata", "a"
113 
114 #ifndef __ASSEMBLY__
115 /*
116  * Used for initialization calls..
117  */
118 typedef int (*initcall_t)(void);
119 typedef void (*exitcall_t)(void);
120 
121 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
122 typedef int initcall_entry_t;
123 
124 static inline initcall_t initcall_from_entry(initcall_entry_t *entry)
125 {
126         return offset_to_ptr(entry);
127 }
128 #else
129 typedef initcall_t initcall_entry_t;
130 
131 static inline initcall_t initcall_from_entry(initcall_entry_t *entry)
132 {
133         return *entry;
134 }
135 #endif
136 
137 extern initcall_entry_t __con_initcall_start[], __con_initcall_end[];
138 
139 /* Used for constructor calls. */
140 typedef void (*ctor_fn_t)(void);
141 
142 struct file_system_type;
143 
144 /* Defined in init/main.c */
145 extern int do_one_initcall(initcall_t fn);
146 extern char __initdata boot_command_line[];
147 extern char *saved_command_line;
148 extern unsigned int saved_command_line_len;
149 extern unsigned int reset_devices;
150 
151 /* used by init/main.c */
152 void setup_arch(char **);
153 void prepare_namespace(void);
154 void __init init_rootfs(void);
155 extern struct file_system_type rootfs_fs_type;
156 
157 #if defined(CONFIG_STRICT_KERNEL_RWX) || defined(CONFIG_STRICT_MODULE_RWX)
158 extern bool rodata_enabled;
159 #endif
160 #ifdef CONFIG_STRICT_KERNEL_RWX
161 void mark_rodata_ro(void);
162 #endif
163 
164 extern void (*late_time_init)(void);
165 
166 extern bool initcall_debug;
167 
168 #endif
169   
170 #ifndef MODULE
171 
172 #ifndef __ASSEMBLY__
173 
174 /*
175  * initcalls are now grouped by functionality into separate
176  * subsections. Ordering inside the subsections is determined
177  * by link order. 
178  * For backwards compatibility, initcall() puts the call in 
179  * the device init subsection.
180  *
181  * The `id' arg to __define_initcall() is needed so that multiple initcalls
182  * can point at the same handler without causing duplicate-symbol build errors.
183  *
184  * Initcalls are run by placing pointers in initcall sections that the
185  * kernel iterates at runtime. The linker can do dead code / data elimination
186  * and remove that completely, so the initcall sections have to be marked
187  * as KEEP() in the linker script.
188  */
189 
190 /* Format: <modname>__<counter>_<line>_<fn> */
191 #define __initcall_id(fn)                                       \
192         __PASTE(__KBUILD_MODNAME,                               \
193         __PASTE(__,                                             \
194         __PASTE(__COUNTER__,                                    \
195         __PASTE(_,                                              \
196         __PASTE(__LINE__,                                       \
197         __PASTE(_, fn))))))
198 
199 /* Format: __<prefix>__<iid><id> */
200 #define __initcall_name(prefix, __iid, id)                      \
201         __PASTE(__,                                             \
202         __PASTE(prefix,                                         \
203         __PASTE(__,                                             \
204         __PASTE(__iid, id))))
205 
206 #ifdef CONFIG_LTO_CLANG
207 /*
208  * With LTO, the compiler doesn't necessarily obey link order for
209  * initcalls. In order to preserve the correct order, we add each
210  * variable into its own section and generate a linker script (in
211  * scripts/link-vmlinux.sh) to specify the order of the sections.
212  */
213 #define __initcall_section(__sec, __iid)                        \
214         #__sec ".init.." #__iid
215 
216 /*
217  * With LTO, the compiler can rename static functions to avoid
218  * global naming collisions. We use a global stub function for
219  * initcalls to create a stable symbol name whose address can be
220  * taken in inline assembly when PREL32 relocations are used.
221  */
222 #define __initcall_stub(fn, __iid, id)                          \
223         __initcall_name(initstub, __iid, id)
224 
225 #define __define_initcall_stub(__stub, fn)                      \
226         int __init __stub(void);                                \
227         int __init __stub(void)                                 \
228         {                                                       \
229                 return fn();                                    \
230         }                                                       \
231         __ADDRESSABLE(__stub)
232 #else
233 #define __initcall_section(__sec, __iid)                        \
234         #__sec ".init"
235 
236 #define __initcall_stub(fn, __iid, id)  fn
237 
238 #define __define_initcall_stub(__stub, fn)                      \
239         __ADDRESSABLE(fn)
240 #endif
241 
242 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
243 #define ____define_initcall(fn, __stub, __name, __sec)          \
244         __define_initcall_stub(__stub, fn)                      \
245         asm(".section   \"" __sec "\", \"a\"            \n"     \
246             __stringify(__name) ":                      \n"     \
247             ".long      " __stringify(__stub) " - .     \n"     \
248             ".previous                                  \n");   \
249         static_assert(__same_type(initcall_t, &fn));
250 #else
251 #define ____define_initcall(fn, __unused, __name, __sec)        \
252         static initcall_t __name __used                         \
253                 __attribute__((__section__(__sec))) = fn;
254 #endif
255 
256 #define __unique_initcall(fn, id, __sec, __iid)                 \
257         ____define_initcall(fn,                                 \
258                 __initcall_stub(fn, __iid, id),                 \
259                 __initcall_name(initcall, __iid, id),           \
260                 __initcall_section(__sec, __iid))
261 
262 #define ___define_initcall(fn, id, __sec)                       \
263         __unique_initcall(fn, id, __sec, __initcall_id(fn))
264 
265 #define __define_initcall(fn, id) ___define_initcall(fn, id, .initcall##id)
266 
267 /*
268  * Early initcalls run before initializing SMP.
269  *
270  * Only for built-in code, not modules.
271  */
272 #define early_initcall(fn)              __define_initcall(fn, early)
273 
274 /*
275  * A "pure" initcall has no dependencies on anything else, and purely
276  * initializes variables that couldn't be statically initialized.
277  *
278  * This only exists for built-in code, not for modules.
279  * Keep main.c:initcall_level_names[] in sync.
280  */
281 #define pure_initcall(fn)               __define_initcall(fn, 0)
282 
283 #define core_initcall(fn)               __define_initcall(fn, 1)
284 #define core_initcall_sync(fn)          __define_initcall(fn, 1s)
285 #define postcore_initcall(fn)           __define_initcall(fn, 2)
286 #define postcore_initcall_sync(fn)      __define_initcall(fn, 2s)
287 #define arch_initcall(fn)               __define_initcall(fn, 3)
288 #define arch_initcall_sync(fn)          __define_initcall(fn, 3s)
289 #define subsys_initcall(fn)             __define_initcall(fn, 4)
290 #define subsys_initcall_sync(fn)        __define_initcall(fn, 4s)
291 #define fs_initcall(fn)                 __define_initcall(fn, 5)
292 #define fs_initcall_sync(fn)            __define_initcall(fn, 5s)
293 #define rootfs_initcall(fn)             __define_initcall(fn, rootfs)
294 #define device_initcall(fn)             __define_initcall(fn, 6)
295 #define device_initcall_sync(fn)        __define_initcall(fn, 6s)
296 #define late_initcall(fn)               __define_initcall(fn, 7)
297 #define late_initcall_sync(fn)          __define_initcall(fn, 7s)
298 
299 #define __initcall(fn) device_initcall(fn)
300 
301 #define __exitcall(fn)                                          \
302         static exitcall_t __exitcall_##fn __exit_call = fn
303 
304 #define console_initcall(fn)    ___define_initcall(fn, con, .con_initcall)
305 
306 struct obs_kernel_param {
307         const char *str;
308         int (*setup_func)(char *);
309         int early;
310 };
311 
312 /*
313  * Only for really core code.  See moduleparam.h for the normal way.
314  *
315  * Force the alignment so the compiler doesn't space elements of the
316  * obs_kernel_param "array" too far apart in .init.setup.
317  */
318 #define __setup_param(str, unique_id, fn, early)                        \
319         static const char __setup_str_##unique_id[] __initconst         \
320                 __aligned(1) = str;                                     \
321         static struct obs_kernel_param __setup_##unique_id              \
322                 __used __section(".init.setup")                         \
323                 __aligned(__alignof__(struct obs_kernel_param))         \
324                 = { __setup_str_##unique_id, fn, early }
325 
326 /*
327  * NOTE: __setup functions return values:
328  * @fn returns 1 (or non-zero) if the option argument is "handled"
329  * and returns 0 if the option argument is "not handled".
330  */
331 #define __setup(str, fn)                                                \
332         __setup_param(str, fn, fn, 0)
333 
334 /*
335  * NOTE: @fn is as per module_param, not __setup!
336  * I.e., @fn returns 0 for no error or non-zero for error
337  * (possibly @fn returns a -errno value, but it does not matter).
338  * Emits warning if @fn returns non-zero.
339  */
340 #define early_param(str, fn)                                            \
341         __setup_param(str, fn, fn, 1)
342 
343 #define early_param_on_off(str_on, str_off, var, config)                \
344                                                                         \
345         int var = IS_ENABLED(config);                                   \
346                                                                         \
347         static int __init parse_##var##_on(char *arg)                   \
348         {                                                               \
349                 var = 1;                                                \
350                 return 0;                                               \
351         }                                                               \
352         early_param(str_on, parse_##var##_on);                          \
353                                                                         \
354         static int __init parse_##var##_off(char *arg)                  \
355         {                                                               \
356                 var = 0;                                                \
357                 return 0;                                               \
358         }                                                               \
359         early_param(str_off, parse_##var##_off)
360 
361 /* Relies on boot_command_line being set */
362 void __init parse_early_param(void);
363 void __init parse_early_options(char *cmdline);
364 #endif /* __ASSEMBLY__ */
365 
366 #else /* MODULE */
367 
368 #define __setup_param(str, unique_id, fn)       /* nothing */
369 #define __setup(str, func)                      /* nothing */
370 #endif
371 
372 /* Data marked not to be saved by software suspend */
373 #define __nosavedata __section(".data..nosave")
374 
375 #ifdef MODULE
376 #define __exit_p(x) x
377 #else
378 #define __exit_p(x) NULL
379 #endif
380 
381 #endif /* _LINUX_INIT_H */
382 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp