linux 0.11 内核学习 -- main.c，调用函数而已。

到了main.c，其实main.c中的大部分的内容是调用函数来实现初始化的工作，但是还是将它看完了。下面就是代码了。主要参考的是linux内核完全注释，在一些不太明白的地方，参考网上的介绍。废话少说。还有很长的路啊。努力啊O(∩_∩)O~。

/*
* main.c功能描述。
*/
//main.c程序的主要功能是利用setup.s程序取得的系统参数设置系统的
// 的根文件设备号和一些全局变量。这些变量至两名了内存的开始地址
// 系统包含的内存容量和作为高速缓存区内存末端地址。如果还定义了
// 虚拟盘，则主存将会相应的减少。整个内存的镜像如下 :
//
// -------------------------------------------
// | kernel　| buffer | ramdisk | main memory |
// -------------------------------------------
//
// 高速缓存部分还要扣除显存和rom bios占用的部分。高速缓冲区主要
// 是磁盘等设备的临时存放数据的场所。主存的区域主要是由内存管理
// 模块mm通过分页机制进行内存的管理分配，以4k字节为一个页单位。
// 内核程序可以直接访问自由的高速缓冲区，但是对于页面的访问，则
// 需要通过mm模块才能实现将其分配到内存页面。
//
// 然后内核进行所有方面的硬件初始化工作。设置陷阱门，块设备，字符设备
// 和tty，包括人工创建的第一个任务task 0.待所有的设置工作完成时，开启
// 中断。在阅读这些初始化程序时最好跟着这些被调用函数深入看下去。
//
// 整个内核的初始化完成后，内核将执行权限切换到用户模式，即是cpu从
// 0特权级切换到3特权级。然后系统第一次调用函数fork，创建出第一个用于
// 运行的init子程序。
//
// 在该进程中系统将运行控制台程序。如果控制台环境监理成功，则在生成一
// 个子进程，用于运行/bin/sh.
//
// 对于linux而言，所有的任务都是在用户模式下运行的。包括很多系统应用
// 程序，入Shell程序，网络子程序系统。

/*
* linux/init/main.c
*
* (C) 1991 Linus Torvalds
*/

#define __LIBRARY__// 在unistd.h中使用了如下的预处理命令，#ifdef __LIBRARY__，
// 所以这里包含这个定义。
#include <unistd.h>

#include <time.h>// 时间类型的头文件。其中最主要的是tm
// 结构的定义。

/*
* we need this inline - forking from kernel space will result
* in NO COPY ON WRITE (!!!), until an execve is executed. This
* is no problem, but for the stack. This is handled by not letting
* main() use the stack at all after fork(). Thus, no function
* calls - which means inline code for fork too, as otherwise we
* would use the stack upon exit from 'fork()'.
*
* Actually only pause and fork are needed inline, so that there
* won't be any messing with the stack from main(), but we define
* some others too.
*/

/*
* 我们需要下面这些内嵌语句 - 从内核空间创建进程(forking)将导致没有
* 写时复制（COPY ON WRITE）!!! 直到一个执行execve 调用。这对堆栈可
* 能带来问题。处理的方法是在fork()调用之后不让main()使用任何堆栈。
*　因此就不能有函数调用 - 这意味着fork 也要使用内嵌的代码，否则我
* 们在从fork()退出时就要使用堆栈了。实际上只有pause 和fork 需要使用
* 内嵌方式，以保证从main()中不会弄乱堆栈，但是我们同时还定义了其它
* 一些函数。
*
* 下面介绍linux对于堆栈使用，然后介绍对于上述注释的解释。
* 1.开机初始化时（bootsect.s,setup.s）
* 当bootsect代码被ROM BIOS引导加载到物理内存0x7c00处时，并没有设置
* 堆栈段，程序也没有使用堆栈，直到bootsect被移动到0x9000:0处时，才把
* 堆栈段寄存器SS设置为0x9000，堆栈指针esp寄存器设置为0xff00，所以堆
* 栈堆栈在0x9000:0xff00处（boot/bootsect.s L61,62）setup.s也使用这个堆栈
* 2.进入保护模式时候（head.s，L31）
* 此时堆栈段被设置为内核数据段（0x10），堆栈指针esp设置成指向user_stack
* 数组（sched.c L67～72）的顶端，保留了1页内存作为堆栈使用.
* 3.初始化时（main.c）
* 在执行move_to_user_mode()代码把控制权移交给任务0之前，系统一直使用
* 上述堆栈，而在执行过move_to_user_mode()之后，main.c的代码被“切换”成
* 任务0中执行。通过执行fork()系统调用，main.c中的init()将在任务1中执行，
* 并使用任务1的堆栈，而main()本身则在被“切换”成为任务0后，仍热继续使
* 用上述内核程序自己的堆栈作为任务0的用户态堆栈
*
* 上面的注释不是很清楚，现解释如下 :
* Linux在内核空间创建进程时不使用写时复制技术。main()在移动到用户模
* 式（移到任务0）后执行内嵌方式的fork()和pause()，因此可保证不使用任
* 务0的用户栈。在执行moveto_user_mode(),之后，本程序main()就以任务0
* 的身份在运行了。而任务0是所有将创建子进程的父进程。当它创建一个子
* 进程时（init进程），由于任务1代码属于内核空间，因此没有使用写时复制功能。
* 此时任务0的用户栈就是任务1的用户栈，即它共同使用一个栈空间。因此
* 希望在main.c运行,在任务0的环境下时不要有对堆栈的任何操作，以免弄
* 乱堆栈。而在再次执行fork()并执行过execve()函数后，被加载程序已不
* 属于内核空间，因此可以使用写时复制技术了.由上面的分析可知，使用
* 内联函数时为了使init进程1不修改main.c进程0不修改堆栈空间。
*
*/
static inline _syscall0(int,fork)
static inline _syscall0(int,pause)
static inline _syscall1(int,setup,void *,BIOS)
static inline _syscall0(int,sync)// int sync ()系统调用。

#include <linux/tty.h>// tty 头文件，定义了有关tty_io，串行通信方面的参数、常数。
// 所谓“串行通信“是指外设和计算机间使用一根数据信号线,
// 数据在一根数据信号线上按位进行传输，每一位数据都占据一个固定的时间长度。
#include <linux/sched.h>// 调度程序头文件，定义了任务结构task_struct、第1 个初始任务
// 的数据。还有一些以宏的形式定义的有关描述符参数设置和获取的
// 嵌入式汇编函数程序。
#include <linux/head.h>// head 头文件，定义了段描述符的简单结构，和几个选择符常量。
#include <asm/system.h>// 系统头文件。以宏的形式定义了许多有关设置或修改
// 描述符/中断门等的嵌入式汇编子程序。
#include <asm/io.h>// io 头文件。以宏的嵌入汇编程序形式定义对io 端口操作的函数。
#include <stddef.h>// 标准定义头文件。定义了NULL, offsetof(TYPE, MEMBER)。
#include <stdarg.h>// 标准参数头文件。以宏的形式定义变量参数列表。主要说明了-个
// 类型(va_list)和三个宏(va_start, va_arg 和va_end)，vsprintf
// vprintf、vfprintf。
#include <unistd.h>
#include <fcntl.h>// 文件控制头文件。用于文件及其描述符的操作控制常数符号的定义。
#include <sys/types.h>// 类型头文件。定义了基本的系统数据类型

#include <linux/fs.h>// 文件系统头文件。定义文件表结构（file,buffer_head,m_inode 等）

static char printbuf[1024];

extern int vsprintf();
extern void init(void);
extern void blk_dev_init(void);// 块设备初始化。
extern void chr_dev_init(void);// 字符设备初始化。
extern void hd_init(void);// 硬盘初始化程序。
extern void floppy_init(void);// 软盘初始化程序。
extern void mem_init(long start, long end);// 内存管理程序初始化。
extern long rd_init(long mem_start, int length);// 虚拟盘初始化
extern long kernel_mktime(struct tm * tm);// 建立内核时间
extern long startup_time;// 内核启动时间（开机时间）（秒）.

/*
* This is set up by the setup-routine at boot-time
*/
/*
* 以下这些数据是由setup.s 程序在引导时间设置的.
*/
#define EXT_MEM_K (*(unsigned short *)0x90002)// 1m以后的拓展内存大小。
#define DRIVE_INFO (*(struct drive_info *)0x90080)// 硬盘参数表基址。
#define ORIG_ROOT_DEV (*(unsigned short *)0x901FC)// 根文件系统所在设备号。

/*
* Yeah, yeah, it's ugly, but I cannot find how to do this correctly
* and this seems to work. I anybody has more info on the real-time
* clock I'd be interested. Most of this was trial and error, and some
* bios-listing reading. Urghh.
*/

#define CMOS_READ(addr) ({ /// 这段宏读取cmos实时时钟信息。
outb_p(0x80|addr,0x70); /// 0x70是些端口号，0x80|addr 是要读取的CMOS 内存地址
inb_p(0x71); /// 0x71 是读端口号。
})

#define BCD_TO_BIN(val) ((val)=((val)&15) + ((val)>>4)*10)// 将BCD 码转换成数字.

//----------------------------------------------------------------------------------
//time_init
//------------------------------------------------------------------------------------
static void time_init(void)// 读取cmos中的信息，初始化全局变量startup_time
{
struct tm time;

do {
time.tm_sec = CMOS_READ(0);
time.tm_min = CMOS_READ(2);
time.tm_hour = CMOS_READ(4);
time.tm_mday = CMOS_READ(7);
time.tm_mon = CMOS_READ(8);
time.tm_year = CMOS_READ(9);
} while (time.tm_sec != CMOS_READ(0));

BCD_TO_BIN(time.tm_sec);
BCD_TO_BIN(time.tm_min);
BCD_TO_BIN(time.tm_hour);
BCD_TO_BIN(time.tm_mday);
BCD_TO_BIN(time.tm_mon);
BCD_TO_BIN(time.tm_year);
time.tm_mon--;// months since January - [0,11]
startup_time = kernel_mktime(&time);
}

static long memory_end = 0;// 机器具有的内存（字节数）
static long buffer_memory_end = 0;// 高速缓冲区末端地址
static long main_memory_start = 0;// 主内存（将用于分页）开始的位置

struct drive_info { char dummy[32]; } drive_info;// 用于存放硬盘信息

//---------------------------------------------------------------------------
//main
//-------------------------------------------------------------------------
void main(void)/* This really IS void, no error here. */
// 此时中断仍然是关着，在必要的设置完成之后。
// 打开中断。
{/* The startup routine assumes (well, ...) this */
/*
* Interrupts are still disabled. Do necessary setups, then
* enable them
*/
// 下面这段代码用于保存
// 根设备号 -- ROOT_DEV； 高速缓存末端地址 -- buffer_memory_end
// 机器内存数 -- memory_end；主内存开始地址 -- main_memory_start
ROOT_DEV = ORIG_ROOT_DEV;

drive_info = DRIVE_INFO;

memory_end = (1<<20) + (EXT_MEM_K<<10);// 内存大小=1Mb 字节+扩展内存(k)*1024 字节
memory_end &= 0xfffff000;// 忽略不到4Kb（1 页）的内存数
if (memory_end > 16*1024*1024)// 如果内存超过16Mb，则按16Mb 计
memory_end = 16*1024*1024;
if (memory_end > 12*1024*1024)// 如果内存>12Mb，则设置缓冲区末端=4Mb
buffer_memory_end = 4*1024*1024;
else if (memory_end > 6*1024*1024)// 否则如果内存>6Mb，则设置缓冲区末端=2Mb
buffer_memory_end = 2*1024*1024;
else// 否则则设置缓冲区末端=1Mb
buffer_memory_end = 1*1024*1024;
main_memory_start = buffer_memory_end;// 主内存(用于分页使用)起始位置=缓冲区末端
#ifdef RAMDISK
main_memory_start += rd_init(main_memory_start, RAMDISK*1024);
#endif

mem_init(main_memory_start,memory_end);//

trap_init();// 陷阱门（硬件中断向量）初始化

blk_dev_init();// 块设备初始化

chr_dev_init();// 字符设备初始化

tty_init();// tty 初始化

time_init();// 设置开机启动时间,startup_time

sched_init();// 调度程序初始化

buffer_init(buffer_memory_end);// 缓冲管理初始化，建内存链表等.

hd_init();// 硬盘初始化

floppy_init();// 软盘初始化

sti();// 设置完成，开启中断。

move_to_user_mode();// 移到用户模式

if (!fork()) {/* we count on this going ok */
init();
}
/*
* NOTE!! For any other task 'pause()' would mean we have to get a
* signal to awaken, but task0 is the sole exception (see 'schedule()')
* as task 0 gets activated at every idle moment (when no other tasks
* can run). For task0 'pause()' just means we go check if some other
* task can run, and if not we return here.
*/

/*
* 注意!! 对于任何其它的任务，'pause()'将意味着我们必须等待收到一个信号才会返
* 回就绪运行态，但任务0（task0）是唯一的意外情况（参见'schedule()'），因为任务0 在
* 任何空闲时间里都会被激活（当没有其它任务在运行时），因此对于任务0'pause()'仅意味着
* 我们返回来查看是否有其它任务可以运行，如果没有的话我们就回到这里，一直循环执行'pause()'。
*/
for(;;) pause();
}

//----------------------------------------------------------------------------
//printf
//----------------------------------------------------------------------------
static int printf(const char *fmt, ...)// 使用变长参数，调用write系统调用。
{
va_list args;
int i;

va_start(args, fmt);
write(1,printbuf,i=vsprintf(printbuf, fmt, args));
va_end(args);
return i;
}

static char * argv_rc[] = { "/bin/sh", NULL };// 调用执行程序时参数的字符串数组
static char * envp_rc[] = { "HOME=/", NULL };// 调用执行程序时的环境字符串数组

static char * argv[] = { "-/bin/sh",NULL };// 同上
static char * envp[] = { "HOME=/usr/root", NULL };

//------------------------------------------------------------------------------
//init
//------------------------------------------------------------------------------
void init(void)
{
int pid,i;

setup((void *) &drive_info);// 读取硬盘信息
(void) open("/dev/tty0",O_RDWR,0);// 用读写访问方式打开设备“/dev/tty0“
(void) dup(0);// 复制句柄，产生句柄1 号 -- stdout 标准输出设备
(void) dup(0);// 复制句柄，产生句柄2 号 -- stderr 标准出错输出设备

// 输出一些信息
printf("%d buffers = %d bytes buffer space/n/r",NR_BUFFERS,
NR_BUFFERS*BLOCK_SIZE);
printf("Free mem: %d bytes/n/r",memory_end-main_memory_start);

/*
* 下面的代码打开/etc/rc，然后执行/bin/sh。但是这里开辟了
* ；两个线程。
*/
if (!(pid=fork())) {
close(0);
if (open("/etc/rc",O_RDONLY,0))
_exit(1);
execve("/bin/sh",argv_rc,envp_rc);
_exit(2);
}
if (pid>0)
while (pid != wait(&i))
/* nothing */;

/*
* 如果执行到这里，说明刚创建的子进程的执行已停止或终止了。
* 下面循环中首先再创建一个子进程.如果出错，则显示“初始化
* 程序创建子进程失败”的信息并继续执行。对于所创建的子进
* 程关闭所有以前还遗留的句柄(stdin, stdout, stderr)，新创
* 建一个会话并设置进程组号，然后重新打开/dev/tty0 作为stdin，
* 并复制成stdout 和stderr。再次执行系统解释程序/bin/sh。但
* 这次执行所选用的参数和环境数组另选了一套。然后父进程再次
* 运行wait()等待。如果子进程又停止了执行，则在标准输出上显
* 示出错信息“子进程pid 停止了运行，返回码是i”，然后继续重
* 试下去…，形成“大”死循环
*
*/
while (1) {
if ((pid=fork())<0) {
printf("Fork failed in init/r/n");
continue;
}
if (!pid) {
close(0);
close(1);
close(2);
setsid();
(void) open("/dev/tty0",O_RDWR,0);
(void) dup(0);
(void) dup(0);
_exit(execve("/bin/sh",argv,envp));
}
while (1)
if (pid == wait(&i))
break;
printf("/n/rchild %d died with code %04x/n/r",pid,i);
sync();
}
_exit(0);/* NOTE! _exit, not exit() */
}

/*
* 至此linux启动已经完成。有上面的代码分析可知，根文件系统只要即可实现。
*/