Initialization of the Linux subsystem _subsys_initcall (): Those entry functions "go"

after the parsing of the kernel options is complete, the initialization of each subsystem enters the second part-the invocation of the entry function. Usually, USB, PCI subsystem will have a portal named Subsys_initcall, if you choose them as a starting point for the study of the kernel, then please find it first.

Zhu Deyong in the "about work this matter," said, spend half a day to find the entrance, spend the rest of the life to find the exit. See the search for the entrance for our life, for the core code this thing is extremely important.

But many times, the entrance is not only subsys_initcall one, such as PCI.

The following code is from the Linux kernel source include/linux/init.h file

2. 117 #define Pure_initcall (FN) __define_initcall ("0", fn,1)
4. 118
6. 119 #define Core_initcall (FN) __define_initcall ("1", fn,1)
8. #define CORE_INITCALL_SYNC (FN) __define_initcall ("1s", fn,1s)
10. 121 #define Postcore_initcall (FN) __define_initcall ("2", fn,2)
12. 122 #define POSTCORE_INITCALL_SYNC (FN) __define_initcall ("2s", fn,2s)
14. 123 #define Arch_initcall (FN) __define_initcall ("3", fn,3)
16. 124 #define ARCH_INITCALL_SYNC (FN) __define_initcall ("3s", fn,3s)
18. #define Subsys_initcall (FN) __define_initcall ("4", fn,4)
20. 126 #define SUBSYS_INITCALL_SYNC (FN) __define_initcall ("4s", fn,4s)
22. 127 #define Fs_initcall (FN) __define_initcall ("5", fn,5)
24. #define FS_INITCALL_SYNC (FN) __define_initcall ("5s", fn,5s)
26. 129 #define Rootfs_initcall (FN) __define_initcall ("Rootfs", Fn,rootfs)
28. #define Device_initcall (FN) __define_initcall ("6", fn,6)
30. 131 #define DEVICE_INITCALL_SYNC (FN) __define_initcall ("6s", fn,6s)
32. #define Late_initcall (FN) __define_initcall ("7", fn,7)
34. 133 #define LATE_INITCALL_SYNC (FN) __define_initcall ("7s", fn,7s)
36. 134
38. 135 #define __initcall (FN) Device_initcall (FN)

These portals have a common feature, which is defined using the __define_initcall macro. Their invocation is not random, but in a certain order, this order depends on the __define_initcall macro. The __define_initcall macro is used to place the specified function pointer in the. Initcall.init section.

. Initcall.init Festival

The kernel executable consists of many object files that are linked together. Object files have many sections, such as text, data, init data, bass, and so on. These object files are linked and loaded by a file called a linker script. The function of this linker script is to map the sections of the input object file to the output file, in other words, it links all the input object files to a single executable file, loading the sections of the executable file at the specified address. Vmlinux.lds is a kernel linker script that exists in the arch/<target>/directory, which is responsible for linking sections of the kernel and loading them into memory at a specific offset. Find the Initcall.init in the Vmlinux.lds file to see the following content

1. __inicall_start =.;
2. . Initcall.init:AT (ADDR (. initcall.init) –0xc0000000) {
3. * (. Initcall1.init)
4. * (. Initcall2.init)
5. * (. Initcall3.init)
6. * (. Initcall4.init)
7. * (. Initcall5.init)
8. * (. Initcall6.init)
9. * (. Initcall7.init)
10. }
11. __initcall_end =.;

That tells us. The Initcall.init section is divided into 7 sub-sections, and the Xxx_initcall entry function pointer is specifically placed in which sub-section is defined by the Xxx_initcall, __define_initcall macro parameters, For example, Core_initcall puts the function pointer in the. Initcall1.init subsection, Device_initcall places the function pointer in the. Initcall6.init subsection, and so on. The order of the individual sub-sections is determined, that is, the function pointer in the. Initcall1.init is called before calling. Function pointers in Initcall2.init, and so on. The different entry functions are placed in different sub-sections, and therefore the order in which they are called is determined.

Note: The common module_init (x) function in the device driver, viewing the init.h file discovery,

#define MODULE_INIT (x) __initcall (x);

#define __initcall (FN) Device_initcall (FN)

#define Device_initcall (FN) __define_initcall ("6", fn,6)

This infers that the Module_init call priority is 6 lower than the Subsys_initcall call Priority 4.

Do_initcalls () function

The invocation of those entry functions is done by the Do_initcalls function.

The Do_initcall function passes the for loop, starting with __initcall_start until the end of the __initcall_end, calling the recognized initialization function in turn. The area between __initcall_start and __initcall_end is composed of the. Initcall.init section, which holds the function address of a macro tag in the form of Xxx_initcall, Do_ The Initcall function makes it easy to get a function address and execute the function it points to.

The function address saved by the. Initcall.init section has a certain precedence, and the higher the previous function priority, the higher it is called than the function at the back.

Functions that are called by the Do_initcalls function should not change their priority state and prohibit interrupts. Therefore, after each function is executed, do_initcalls checks whether the function has made any changes and, if necessary, corrects the priority and interrupt state.

In addition, these executed functions can accomplish some tasks that need to be performed asynchronously, and the Flush_scheduled_work function is used to ensure that the Do_initcalls function waits for the end of these asynchronous tasks before returning.

2. 666 static void __init do_initcalls (void)
4. 667 {
6. 668 initcall_t *call;
8. 669 int count = Preempt_count ();
10. 670
12. 671 for (call = __initcall_start, call < __initcall_end; call++) {
14. 672 ktime_t t0, T1, Delta;
16. 673 char *msg = NULL;
18. 674 Char msgbuf[40];
20. 675 int result;
22. 676
24. 677 if (initcall_debug) {
26. 678 PRINTK ("Calling Initcall 0x%p", *call);
28. 679 Print_fn_descriptor_symbol (":%s ()",
30. 680 (unsigned long) *call);
32. 681 PRINTK ("/n");
34. 682 t0 = Ktime_get ();
36. 683}
38. 684
40. 685 result = (*call) ();
42. 686
44. 687 if (initcall_debug) {
46. 688 T1 = Ktime_get ();
48. 689 Delta = ktime_sub (t1, t0);
50. 690
52. 691 PRINTK ("Initcall 0x%p", *call);
54. 692 Print_fn_descriptor_symbol (":%s ()",
56. 693 (unsigned long) *call);
58. 694 PRINTK ("returned%d./n", result);
60. 695
62. 696 PRINTK ("Initcall 0x%p ran for%ld msecs:",
64. 697 *call, (unsigned long long) delta.tv64 >> 20);
66. 698 Print_fn_descriptor_symbol ("%s ()/n",
68. 699 (unsigned long) *call);
70. 700}
72. 701
74. 702 if (Result && result! =-enodev && initcall_debug) {
76. 703 sprintf (msgbuf, "error code%d", result);
78. 704 msg = MSGBUF;
80. 705}
82. 706 if (Preempt_count ()! = count) {
84. 707 msg = "preemption imbalance";
86. 708 Preempt_count () = count;
88. 709}
90. 710 if (irqs_disabled ()) {
92. 711 msg = "disabled interrupts";
94. 712 local_irq_enable ();
96. 713}
98. 714 if (msg) {
100. 715 PRINTK (kern_warning "Initcall at 0x%p", *call);
102. 716 Print_fn_descriptor_symbol (":%s ()",
104. 717 (unsigned long) *call);
106. 718 PRINTK (": Returned with%s/n", msg);
108. 719}
110. 720}
112. 721
114. 722/* Make sure there are no pending stuff from the initcall sequence */
116. 723 Flush_scheduled_work ();
118. 724}

at present, the startup process of Linux driver is researched, this article explains the order of the Linux subsystem calls in detail, and also explains the sequence of call of the device driver, which is worth collecting.

This article comes from: http://blog.csdn.net/yimiyangguang1314/article/details/7312209

Initialization of the Linux subsystem _subsys_initcall (): Those entry functions "go"