Linux init main.c源代码分析

1 /*
2 * linux/init/main.c
3 *
4 * (C) 1991 Linus Torvalds
5 */
6
7 #define __LIBRARY__ // 定义该变量是为了包括定义在unistd.h 中的内嵌汇编代码等信息。
8 #include <unistd.h> // *.h 头文件所在的默认目录是include/，则在代码中就不用明确指明位置。
// 如果不是UNIX 的标准头文件，则需要指明所在的目录，并用双引号括住。
// 标准符号常数与类型文件。定义了各种符号常数和类型，并申明了各种函数。
// 如果定义了__LIBRARY__，则还含系统调用号和内嵌汇编代码syscall0()等。
9 #include <time.h> // 时间类型头文件。其中最主要定义了tm 结构和一些有关时间的函数原形。
10
11 /*
12 * we need this inline - forking from kernel space will result
13 * in NO COPY ON WRITE (!!!), until an execve is executed. This
14 * is no problem, but for the stack. This is handled by not letting
15 * main() use the stack at all after fork(). Thus, no function
16 * calls - which means inline code for fork too, as otherwise we
17 * would use the stack upon exit from 'fork()'.
18 *
19 * Actually only pause and fork are needed inline, so that there
20 * won't be any messing with the stack from main(), but we define
21 * some others too.
22 */
/*
* 我们需要下面这些内嵌语句 - 从内核空间创建进程(forking)将导致没有写时复制（COPY ON
WRITE）!!!
* 直到执行一个execve 调用。这对堆栈可能带来问题。处理的方法是在fork()调用之后不让main()使
用
* 任何堆栈。因此就不能有函数调用 - 这意味着fork 也要使用内嵌的代码，否则我们在从fork()退出
* 时就要使用堆栈了。
* 实际上只有pause 和fork 需要使用内嵌方式，以保证从main()中不会弄乱堆栈，但是我们同时还
* 定义了其它一些函数。
*/
// 本程序将会在移动到用户模式（切换到任务0）后才执行fork()，因此避免了在内核空间写时复制问
题。
// 在执行了moveto_user_mode()之后，本程序就以任务0 的身份在运行了。而任务0 是所有将创建的子
// 进程的父进程。当创建第一个子进程时，任务0 的堆栈也会被复制。因此希望在main.c 运行在任务0
// 的环境下时不要有对堆栈的任何操作，以免弄乱堆栈，从而也不会弄乱所有子进程的堆栈。
23 static inline _syscall0(int,fork)
// 这是unistd.h 中的内嵌宏代码。以嵌入汇编的形式调用Linux 的系统调用中断0x80。该中断是所有
// 系统调用的入口。该条语句实际上是int fork()创建进程系统调用。
// syscall0 名称中最后的0 表示无参数，1 表示1 个参数。参见include/unistd.h，133 行。
24 static inline _sys
call0(int,pause) // int pause()系统调用：暂停进程的执行，直到
// 收到一个信号。
25 static inline _syscall1(int,setup,void *,BIOS) // int setup(void * BIOS)系统调用，仅用于

// linux 初始化（仅在这个程序中被调用）。
26 static inline _syscall0(int,sync) // int sync()系统调用：更新文件系统。
27
28 #include <linux/tty.h> // tty 头文件，定义了有关tty_io，串行通信方面的参数、常数。
29 #include <linux/sched.h> // 调度程序头文件，定义了任务结构task_struct、第1 个初始任务
// 的数据。还有一些以宏的形式定义的有关描述符参数设置和获取的
// 嵌入式汇编函数程序。
30 #include <linux/head.h> // head 头文件，定义了段描述符的简单结构，和几个选择符常量。
31 #include <asm/system.h> // 系统头文件。以宏的形式定义了许多有关设置或修改
// 描述符/中断门等的嵌入式汇编子程序。
32 #include <asm/io.h> // io 头文件。以宏的嵌入汇编程序形式定义对io 端口操作的函数。
33
34 #include <stddef.h> // 标准定义头文件。定义了NULL, offsetof(TYPE, MEMBER)。
35 #include <stdarg.h> // 标准参数头文件。以宏的形式定义变量参数列表。主要说明了-个
// 类型(va_list)和三个宏(va_start, va_arg 和va_end)，vsprintf、
// vprintf、vfprintf。
36 #include <unistd.h>
37 #include <fcntl.h> // 文件控制头文件。用于文件及其描述符的操作控制常数符号的定义。
38 #include <sys/types.h> // 类型头文件。定义了基本的系统数据类型。
39
40 #include <linux/fs.h> // 文件系统头文件。定义文件表结构（file,buffer_head,m_inode 等）。
41
42 static char printbuf[1024]; // 静态字符串数组，用作内核显示信息的缓存。
43
44 extern int vsprintf(); // 送格式化输出到一字符串中（在kernel/vsprintf.c，92 行）。
45 extern void init(void); // 函数原形，初始化（在168 行）。
46 extern void blk_dev_init(void); // 块设备初始化子程序（kernel/blk_drv/ll_rw_blk.c,157 行）
47 extern void chr_dev_init(void); // 字符设备初始化（kernel/chr_drv/tty_io.c, 347 行）
48 extern void hd_init(void); // 硬盘初始化程序（kernel/blk_drv/hd.c, 343 行）
49 extern void floppy_init(void); // 软驱初始化程序（kernel/blk_drv/floppy.c, 457 行）
50 extern void mem_init(long start, long end); // 内存管理初始化（mm/memory.c, 399 行）
51 extern long rd_init(long mem_start, int length); // 虚拟盘初始化(kernel/blk_drv/ramdisk.c,52)
52 extern long kernel_mktime(struct tm * tm); // 计算系统开机启动时间（秒）。
53 extern long startup_time; // 内核启动时间（开机时间）（秒）。
54
55 /*
56 * This is set up by the setup-routine at boot-time
57 */
/*
* 以下这些数据是由setup.s 程序在引导时间设置的（参见第3 章中表3.2）。
*/
58 #define EXT_MEM_K (*(unsigned short *)
0x90002) // 1M 以后的扩展内存大小（KB）。
59 #define DRIVE_INFO (*(struct drive_info *)0x90080) // 硬盘参数表基址。
60 #define ORIG_ROOT_DEV (*(unsigned short *)0

x901FC) // 根文件系统所在设备号。
61
62 /*
63 * Yeah, yeah, it's ugly, but I cannot find how to do this correctly
64 * and this seems to work. I anybody has more info on the real-time
65 * clock I'd be interested. Most of this was trial and error, and some
66 * bios-listing reading. Urghh.
67 */
/*
* 是啊，是啊，下面这段程序很差劲，但我不知道如何正确地实现，而且好象它还能运行。如果有
* 关于实时时钟更多的资料，那我很感兴趣。这些都是试探出来的，以及看了一些bios 程序，呵！
*/
68
69 #define CMOS_READ(addr) ({ \ // 这段宏读取CMOS 实时时钟信息。
70 outb_p(0x80|addr,0x70); \ // 0x70 是写端口号，0x80|addr 是要读取的CMOS 内存地址。
71 inb_p(0x71); \ // 0x71 是读端口号。
72 })
73
// 定义宏。将BCD 码转换成二进制数值。
74 #define BCD_TO_BIN(val) ((val)=((val)&15) + ((val)>>4)*10)
75
// 该子程序取CMOS 时钟，并设置开机时间..startup_time(秒)。参见后面CMOS 内存列表。
76 static void time_init(void)
77 {
78 struct tm time; // 时间结构tm 定义在include/time.h 中。
79
// CMOS 的访问速度很慢。为了减小时间误差，在读取了下面循环中所有数值后，若此时CMOS 中秒值
// 发生了变化，那么就重新读取所有值。这样内核就能把与CMOS 的时间误差控制在1 秒之内。
80 do {
81 time.tm_sec = CMOS_READ(0); // 当前时间秒值（均是BCD 码值）。
82 time.tm_min = CMOS_READ(2); // 当前分钟值。
83 time.tm_hour = CMOS_READ(4); // 当前小时值。
84 time.tm_mday = CMOS_READ(7); // 一月中的当天日期。
85 time.tm_mon = CMOS_READ(8); // 当前月份（1—12）。
86 time.tm_year = CMOS_READ(9); // 当前年份。
87 } while (time.tm_sec != CMOS_READ(0));
88 BCD_TO_BIN(time.tm_sec); // 转换成二进制数值。
89 BCD_TO_BIN(time.tm_min);
90 BCD_TO_BIN(time.tm_hour);
91 BCD_TO_BIN(time.tm_mday);
92 BCD_TO_BIN(time.tm_mon);
93 BCD_TO_BIN(time.tm_year);
94 time.tm_mon--; // tm_mon 中月份范围是0—11。
// 调用kernel/mktime.c 中函数，计算从1970 年1 月1 日0 时起到开机当日经过的秒数，作为开机
// 时间。
95 startup_time = kernel_mktime(&time);
96 }
97
98 static long memory_end = 0; // 机器具有的物理内存容量（字节数）。
99 static long buffer_memory_end = 0; // 高速缓冲区末端地址。
100 static long main_memory_start = 0; // 主内存（将用于分页）开始的位置。
101
102 struct drive_info { char dummy[32]; } drive_info; // 用于存放硬盘参数表信息。
103
104 void main(void) /* This really IS void, no error here. */
105 { /* The startup routine assumes (well, ...) this */
/* 这里确实是void，并没错。在start
up 程序(head.s)中就是这样假设的*/
// 参见head.s 程序第136 行开始的几行代码。
106 /*
107 * Interrupts are still disabled. Do necessary setups, then
108 * enable them

109 */
/*
* 此时中断仍被禁止着，做完必要的设置后就将其开启。
*/
// 下面这段代码用于保存：
// 根设备号 ..ROOT_DEV； 高速缓存末端地址..buffer_memory_end；
// 机器内存数..memory_end；主内存开始地址 ..main_memory_start；
110 ROOT_DEV = ORIG_ROOT_DEV; // ROOT_DEV 定义在fs/super.c,29 行。
111 drive_info = DRIVE_INFO; // 复制0x90080 处的硬盘参数表。
112 memory_end = (1<<20) + (EXT_MEM_K<<10); // 内存大小=1Mb 字节+扩展内存(k)*1024 字节。
113 memory_end &= 0xfffff000; // 忽略不到4Kb（1 页）的内存数。
114 if (memory_end > 16*1024*1024) // 如果内存超过16Mb，则按16Mb 计。
115 memory_end = 16*1024*1024;
116 if (memory_end > 12*1024*1024) // 如果内存>12Mb，则设置缓冲区末端=4Mb
117 buffer_memory_end = 4*1024*1024;
118 else if (memory_end > 6*1024*1024) // 否则如果内存>6Mb，则设置缓冲区末端=2Mb
119 buffer_memory_end = 2*1024*1024;
120 else
121 buffer_memory_end = 1*1024*1024;// 否则则设置缓冲区末端=1Mb
122 main_memory_start = buffer_memory_end; // 主内存起始位置=缓冲区末端；
// 如果定义了内存虚拟盘，则初始化虚拟盘。此时主内存将减少。参见kernel/blk_drv/ramdisk.c。
123 #ifdef RAMDISK
124 main_memory_start += rd_init(main_memory_start, RAMDISK*1024);
125 #endif
// 以下是内核进行所有方面的初始化工作。阅读时最好跟着调用的程序深入进去看，若实在看
// 不下去了，就先放一放，继续看下一个初始化调用 -- 这是经验之谈.。
126 mem_init(main_memory_start,memory_end);
127 trap_init(); // 陷阱门（硬件中断向量）初始化。（kernel/traps.c，181）
128 blk_dev_init(); // 块设备初始化。 （kernel/blk_drv/ll_rw_blk.c，157）
129 chr_dev_init(); // 字符设备初始化。 （kernel/chr_drv/tty_io.c，347）
130 tty_init(); // tty 初始化。 （kernel/chr_drv/tty_io.c，105）
131 time_init(); // 设置开机启动时间..startup_time（见76 行）。
132 sched_init(); // 调度程序初始化(加载了任务0 的tr,ldtr)（kernel/sched.c，385）
133 buffer_init(buffer_memory_end); // 缓冲管理初始化，建内存链表等。（fs/buffer.c，348）
134 hd_init(); // 硬盘初始化。 （kernel/blk_drv/hd.c，343）
135 floppy_init(); // 软驱初始化。 （kernel/blk_drv/floppy.c，457）
136 sti(); // 所有初始化工作都做完了，开启中断。
// 下面过程通过在堆栈中设置的参数，利用中断返回指令启动任务0 执行。
137 move_to_user_mode(); // 移到用户模式下执行。（include/asm/system.h，第1 行）
138 if (!fork()) { /* we count on this going ok */
139 init(); // 在新建的子进程（任务1）中执行。
140 }
// 下面代码开始以任务0 的身份运行。

141 /*
142 * NOTE!! For any other task 'pause()' would mean we have to get a
143 * signal to awaken, but task0 is the sole exception (see 's

chedule()')
144 * as task 0 gets activated at every idle moment (when no other tasks
145 * can run). For task0 'pause()' just means we go check if some other
146 * task can run, and if not we return here.
147 */
/* 注意!! 对于任何其它的任务，'pause()'将意味着我们必须等待收到一个信号才会返
* 回就绪运行态，但任务0（task0）是唯一的例外情况（参见'schedule()'），因为任务0 在
* 任何空闲时间里都会被激活（当没有其它任务在运行时），因此对于任务0'pause()'仅意味着
* 我们返回来查看是否有其它任务可以运行，如果没有的话我们就回到这里，一直循环执行'pause()'。
*/
// pause()系统调用（kernel/sched.c,144）会把任务0 转换成可中断等待状态，再执行调度函数。
// 但是调度函数只要发现系统中没有其它任务可以运行时就会切换到任务0，而不依赖于任务0 的
// 状态。
148 for(;;) pause();
149 }
150
151 static int printf(const char *fmt, ...)
// 产生格式化信息并输出到标准输出设备stdout(1)，这里是指屏幕上显示。参数'*fmt'指定输出将
// 采用的格式，参见各种标准C 语言书籍。该子程序正好是vsprintf 如何使用的一个例子。
// 该程序使用vsprintf()将格式化的字符串放入printbuf 缓冲区，然后用write()将缓冲区的内容
// 输出到标准设备（1--stdout）。vsprintf()函数的实现见kernel/vsprintf.c。
152 {
153 va_list args;
154 int i;
155
156 va_start(args, fmt);
157 write(1,printbuf,i=vsprintf(printbuf, fmt, args));
158 va_end(args);
159 return i;
160 }
161
162 static char * argv_rc[] = { "/bin/sh", NULL }; // 调用执行程序时参数的字符串数组。
163 static char * envp_rc[] = { "HOME=/", NULL }; // 调用执行程序时的环境字符串数组。
164
165 static char * argv[] = { "-/bin/sh",NULL }; // 同上。
166 static char * envp[] = { "HOME=/usr/root", NULL };
// 上面165 行中argv[0]中的字符“-”是传递给shell 程序sh 的一个标志。通过识别该标志，sh
// 程序会作为登录shell 执行。其执行过程与在shell 提示符下执行sh 不太一样。
167
// 在main()中已经进行了系统初始化，包括内存管理、各种硬件设备和驱动程序。init()函数运行在
// 任务0 第1 次创建的子进程（任务1）中。它首先对第一个将要执行的程序（shell）的环境进行
// 初始化，然后加载该程序并执行之。
168 void init(void)
169 {
170 int pid,i;
171
// 这是一个系统调用。用于读取硬盘参数包括分区表信息并加载虚拟盘（若存在的话）和安装根文件
// 系统设备。该函数是用25 行上的
宏定义的，对应函数是sys_setup()，在kernel/blk_drv/hd.c,71
行。
172 setup((void *) &drive_info);
// 下面以读写访问方式打开设备“/dev/tty0”，它对应终端控制台。
// 由于这是第一次打开文件操作

，因此产生的文件句柄号（文件描述符）肯定是0。该句柄是UNIX 类
// 操作系统默认的控制台标准输入句柄stdin。这里把它以读和写的方式打开是为了复制产生标准
// 输出（写）句柄stdout 和标准出错输出句柄stderr。
173 (void) open("/dev/tty0",O_RDWR,0);
174 (void) dup(0); // 复制句柄，产生句柄1 号 -- stdout 标准输出设备。
175 (void) dup(0); // 复制句柄，产生句柄2 号 -- stderr 标准出错输出设备。
// 下面打印缓冲区块数和总字节数，每块1024 字节，以及主内存区空闲内存字节数。
176 printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS,
177 NR_BUFFERS*BLOCK_SIZE);
178 printf("Free mem: %d bytes\n\r",memory_end-main_memory_start);
// 下面fork()用于创建一个子进程(任务2)。对于被创建的子进程，fork()将返回0 值，对于原进程
// (父进程)则返回子进程的进程号pid。所以180-184 句是子进程执行的内容。该子进程关闭了句柄
// 0(stdin)、以只读方式打开/etc/rc 文件，并使用execve()函数将进程自身替换成/bin/sh 程序
// (即shell 程序)，然后执行/bin/sh 程序。所带参数和环境变量分别由argv_rc 和envp_rc 数组
// 给出。关于execve()请参见fs/exec.c 程序，182 行。
// 函数_exit()退出时的出错码1 – 操作未许可；2 -- 文件或目录不存在。
179 if (!(pid=fork())) {
180 close(0);
181 if (open("/etc/rc",O_RDONLY,0))
182 _exit(1); // 如果打开文件失败，则退出(lib/_exit.c,10)。
183 execve("/bin/sh",argv_rc,envp_rc); // 替换成/bin/sh 程序并执行。
184 _exit(2); // 若execve()执行失败则退出。
185 }
// 下面还是父进程（1）执行的语句。wait()等待子进程停止或终止，返回值应是子进程的进程号(pid)。
// 这三句的作用是父进程等待子进程的结束。&i 是存放返回状态信息的位置。如果wait()返回值不
// 等于子进程号，则继续等待。
186 if (pid>0)
187 while (pid != wait(&i))
188 /* nothing */; /* 空循环 */
// 如果执行到这里，说明刚创建的子进程的执行已停止或终止了。下面循环中首先再创建一个子进程，
// 如果出错，则显示“初始化程序创建子进程失败”信息并继续执行。对于所创建的子进程将关闭所
// 有以前还遗留的句柄(stdin, stdout, stderr)，新创建一个会话并设置进程组号，然后重新打开
// /dev/tty0 作为stdin，并复制成stdout 和stderr。再次执行系统解释程序/bin/sh。但这次执行所
// 选用的参数和环境数组另选了一套（见上面165-167 行）。然后父进程再次运行wait()等待。如果
// 子进程又停止了
执行，则在标准输出上显示出错信息“子进程pid 停止了运行，返回码是i”，然后
// 继续重试下去…，形成“大”死循环。
189 while (1) {
190 if ((pid=fork())<0) {
191 printf("Fork failed in in

it");
192 continue;
193 }
194 if (!pid) { // 新的子进程。
195 close(0);close(1);close(2);
196 setsid(); // 创建一新的会话期，见后面说明。
197 (void) open("/dev/tty0",O_RDWR,0);
198 (void) dup(0);
199 (void) dup(0);
200 _exit(execve("/bin/sh",argv,envp));
201 }
202 while (1)
203 if (pid == wait(&i))
204 break;
205 printf("\n\rchild %d died with code %04x\n\r",pid,i);
206 sync(); // 同步操作，刷新缓冲区。
207 }
208 _exit(0); /* NOTE! _exit, not exit() */ /* 注意！是_exit()，不是exit() */
// _exit()和
exit()都用于正常终止一个函数。但_exit()直接是一个sys_exit 系统调用，而exit()则
// 通常是普通函数库中的一个函数。它会先执行一些清除操作，例如调用执行各终止处理程序、关闭所
// 有标准IO 等，然后调用sys_exit。
209 }
210

本文来源：https://www.bwwdw.com/article/ufq1.html