linux内核（0.12）-main.c分析

关于写时复制技术(copy-on-write)介绍：

在查看内核时,发现注释中有讲到写时复制技术。下面补充介绍一下，写时复制技术：

    在Linux程序中，fork（）会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，linux中引入了“写时复制“技术，也就是只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。

    那么子进程的物理空间没有代码，怎么去取指令执行exec系统调用呢？

    在fork之后exec之前两个进程用的是相同的物理空间（内存区），子进程的代码段、数据段、堆栈都是指向父进程的物理空间，也就是说，两者的虚拟空间不同，但其对应的物理空间是同一个。当父子进程中有更改相应段的行为发生时，再为子进程相应的段分配物理空间，如果不是因为exec，内核会给子进程的数据段、堆栈段分配相应的物理空间（至此两者有各自的进程空间，互不影响），而代码段继续共享父进程的物理空间（两者的代码完全相同）。而如果是因为exec，由于两者执行的代码不同，子进程的代码段也会分配单独的物理空间。      

    在网上看到还有个细节问题就是，fork之后内核会通过将子进程放在队列的前面，以让子进程先执行，以免父进程执行导致写时复制，而后子进程执行exec系统调用，因无意义的复制而造成效率的下降。

参考地址：http://www.cnblogs.com/biyeymyhjob/archive/2012/07/20/2601655.html

fork（）函数功能介绍和代码讲解

在main.c函数中，定义了fork()函数。这里用_syscall0宏来定义fork()函数。

下面是fork()函数的定义和_syscall0(type,name)宏定义：

static inline _syscall0(int,fork)

#define _syscall0(type,name) \
type name(void) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
    : "=a" (__res) \
    : "0" (__NR_##name)); \
if (__res >= 0) \
    return (type) __res; \
errno = -__res; \
return -1; \
}

将函数定义和宏嵌套起来，将会是下面的结果：

##：表示连接符号

#define _syscall0(int,fork) \
int fork(void) 
{ 
    long __res; 
    __asm__ volatile ("int $0x80" 
                      : "=a" (__res) 
                      : "0" (__NR_fork)
                      ); 
    if (__res >= 0)
        return (int) __res; 
    errno = -__res;
    return -1;
}

// int 0x80调用中断，ax中为功能号。当ax等于2的时候，调用系统fork()函数。
// 因为__NR_fork为宏定义，其内容为2。所以这个fork()函数调用系统fork()函数。

fork()函数功能

fork函数将运行着的程序分成2个（几乎）完全一样的进程，每个进程都启动一个从代码的同一位置开始执行的线程。这两个进程中的线程继续执行，就像是两个用户同时启动了该应用程序的两个副本。

fork()函数返回值

• 父进程中，返回创建的子进程的进程ID.
• 子进程中，返回 0.
• 如果出错返回负数.

在main.c文件中，有如下调用fork()函数的调用方式

if (!fork()) {      /* we count on this going ok */
        init();
    }

// 之前讲解过，在子进程中fork()函数返回值为0，在父进程中fork()函数的返回值为子进程的ID。
// 因此，init()函数只有在子进程中可以调用。

解释代码

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

#define __LIBRARY__ // 定义该变量是为了包括定义在unistd.h 中的内嵌汇编代码等信息。

// *.h头文件所在的默认目录是include/,则在代码中就不必明确指明其位置。如果不是UNIX的
// 标准头文件，则需要指明所在的目录，并用双引号括住。unistd.h是标准符号常数与类型文件。
// 其中定义了各种符号常数和类型，并声明了各种函数。如果还定义了符号__LIBRARY__,则还会
// 包含系统调用号和内嵌汇编代码syscall0(),syscall1()等
#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()中不会弄乱堆栈， * 但是我们同时还定义了其它一些函数。 */
static inline _syscall0(int,fork)       // 是unistd.h 中的内嵌宏代码。以嵌入汇编的形式调用
                                        // Linux 的系统调用中断0x80。该中断是所有系统调用的
                                        // 入口。该条语句实际上是int fork()创建进程系统调用。
                                        // syscall0 名称中最后的0 表示无参数，1 表示1 个参数。

static inline _syscall0(int,pause)      // int pause()系统调用：暂停进程的执行，直到
                                        // 收到一个信号。

static inline _syscall1(int,setup,void *,BIOS)  // int setup(void * BIOS)系统调用，仅用于
                                                // linux 初始化（仅在这个程序中被调用）。

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 <fcntl.h> // 文件控制头文件。用于文件及其描述符的操作控制常数
                            // 符号的定义。
#include <sys/types.h> // 类型头文件。定义了基本的系统数据类型。

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

#include <string.h> // 字符串头文件。主要定义了一些有关内存或字符串操作的嵌入函数。

static char printbuf[1024];

extern char *strcpy();      
extern int vsprintf();      // 送格式化输出到一字符串中（在kernel/vsprintf.c）。
extern void init(void);     // 函数原形，初始化（在后面）。
extern void blk_dev_init(void);     // 块设备初始化子程序（kernel/blk_drv/ll_rw_blk.c）
extern void chr_dev_init(void);     // 字符设备初始化（kernel/chr_drv/tty_io.c）
extern void hd_init(void);          // 硬盘初始化程序（kernel/blk_drv/hd.c）
extern void floppy_init(void);      // 软驱初始化程序（kernel/blk_drv/floppy.c）
extern void mem_init(long start, long end);     // 内存管理初始化（mm/memory.c）
extern long rd_init(long mem_start, int length);        //虚拟盘初始化(kernel/blk_drv/ramdisk.c)
extern long kernel_mktime(struct tm * tm);      // 计算系统开机启动时间（秒）

// 内核专用的sprintf()函数。该函数用于产生格式化信息并输出到指定缓冲区str中。参数'*fmt'
// 指定输出将采用的格式，参见标准C语言书籍。该子程序正好是vsprintf如何使用的一个简单例子。
// 函数使用vsprintf()将格式化字符串放入str缓冲区。
static int sprintf(char * str, const char *fmt, ...)
{
    va_list args;
    int i;

    va_start(args, fmt);
    i = vsprintf(str, fmt, args);
    va_end(args);
    return i;
}

/* * This is set up by the setup-routine at boot-time */
/* * 以下这些数据是由setup.s 程序在引导时间设置的。 */
// 下面三行分别将指定的线性地址强行转换为给定数据类型的指针，并获取指针所指内容。由于内核代
// 码段被映射到物理地址零开始的地方，因此这些线性地址正好也是对应的物理地址。
#define EXT_MEM_K (*(unsigned short *)0x90002) // 1MB以后的扩展内存的大小(KB)
#define CON_ROWS ((*(unsigned short *)0x9000e) & 0xff) // 选定的控制台屏幕行数量
#define CON_COLS (((*(unsigned short *)0x9000e) & 0xff00) >> 8) // 选定的控制台屏幕列数量
#define DRIVE_INFO (*(struct drive_info *)0x90080) // 硬盘参数表32字节内容
#define ORIG_ROOT_DEV (*(unsigned short *)0x901FC) // 根文件系统所在设备号
#define ORIG_SWAP_DEV (*(unsigned short *)0x901FA) // 交换文件所在设备号

/* * 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. */
/* * 是啊，是啊，下面这段程序很差劲，但我不知道如何正确地实现，而且好象 * 它还能运行。如果有关于实时时钟更多的资料，那我很感兴趣。这些都是试 * 探出来的，以及看了一些bios 程序，呵！ */
// 这段宏读取CMOS 实时时钟信息。
// 0x70 是写端口号，0x80|addr 是要读取的CMOS 内存地址。
// 0x71 是读端口号。
#define CMOS_READ(addr) ({ \
outb_p(0x80|addr,0x70); \
inb_p(0x71); \
})

// 什么是BCD码：BCD码是利用半个字节（4位）表示一个10进制数，因此一个字节可以表示2个10进制数。
// 将BCD 码转换成数字。
#define BCD_TO_BIN(val) ((val)=((val)&15) + ((val)>>4)*10)

// 该子程序取CMOS 时钟，并设置开机时间 startup_time(为从1970-1-1-0 时起到开机时的秒数)。
static void time_init(void)
{
    struct tm time;

// CMOS的访问速度很慢。为了减小时间误差，在读取了下面循环中所有数值后，若此时CMOS中
// 秒值发生了变化，那么久重新读取所有值。这样内核就能把CMOS时间误差控制在1秒之内了。
    do {
        //均是BCD码值
        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--;              // tm_mon中月份范围为0~11
    startup_time = kernel_mktime(&time);
}

// 下面定义一些局部变量。
static long memory_end = 0;             // 机器具有的内存（字节数）。
static long buffer_memory_end = 0;      // 高速缓冲区末端地址。
static long main_memory_start = 0;      // 主内存（将用于分页）开始的位置。
static char term[32];                   // 用于存放硬盘参数表信息。

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

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

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

// 内核初始化主程序。初始化结束后将以任务0（idle任务，即空闲任务）的身份运行。
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 */
/* * 此时中断仍被禁止着，做完必要的设置后就将其开启。 */
// 首先保存根文件系统设备号和交换文件设备号，并根据setup.s程序中获取的信息设置控制台终端
// 屏幕行，列数环境变量TERM，并用其设置初始init进程中执行stc/rc文件和shell程序使用的
// 环境变量，以及复制内存0x90080处的硬盘参数表。
// 其中ROOT_DEV已在前面包含进的include/linux/fs.h文件上被声明为extern int，
// 而SWAP_DEV在include/linux/mm.h文件内也作了相同声明。这里mm.h文件并没有显示地列在
// 本程序前部，因为前面包含进的include/linux/sched.h文件中已经含有他。
    ROOT_DEV = ORIG_ROOT_DEV;
    SWAP_DEV = ORIG_SWAP_DEV;
    sprintf(term, "TERM=con%dx%d", CON_COLS, CON_ROWS);
    envp[1] = term; 
    envp_rc[1] = term;
    drive_info = DRIVE_INFO;
// 接着根据机器物理内存容量设置高速缓冲区和主内存区的位置和范围。
// 高速缓冲末端地址->buffer_momery_end; 机器内存容量->memory_end;
// 主内存开始地址->main_memory_start;
    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;      // 主内存起始位置 = 缓冲区末端。

// 如果Makefile文件中定义了内存虚拟盘符号RAMDISK，则初始化虚拟盘。此时主内存减少。
#ifdef RAMDISK
    main_memory_start += rd_init(main_memory_start, RAMDISK*1024);
#endif

// 以下是内核进行所有方面的初始化工作。阅读时最好跟着调用的程序深入进去看，实在看
// 不下去了，就先放一放，看下一个初始化调用-- 这是经验之谈:)
    mem_init(main_memory_start,memory_end);
    trap_init();            // 陷阱门（硬件中断向量）初始化。（kernel/traps.c）
    blk_dev_init();         // 块设备初始化。（kernel/blk_dev/ll_rw_blk.c）
    chr_dev_init();         // 字符设备初始化。（kernel/chr_dev/tty_io.c）空，为以后扩展做准备。
    tty_init();             // tty 初始化。（kernel/chr_dev/tty_io.c）
    time_init();            // 设置开机启动时间 -> startup_time。
    sched_init();           // 调度程序初始化(加载了任务0 的tr, ldtr) （kernel/sched.c）
    buffer_init(buffer_memory_end);     // 缓冲管理初始化，建内存链表等。（fs/buffer.c）
    hd_init();              // 硬盘初始化。（kernel/blk_dev/hd.c）
    floppy_init();          // 软驱初始化。（kernel/blk_dev/floppy.c）
    sti();                  // 所有初始化工作都做完了，开启中断。

// 执行完下面函数""之后，切换到用户模式，同时进入任务0。
    move_to_user_mode();    // 移到用户模式。

// fork()函数，拷贝任务，两个任务同时运行。
    if (!fork()) {      /* we count on this going ok */
    // 在子进程中，fork()返回0。因此，init()函数在子进程中执行。
        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. */
// 下面代码开始以任务0身份运行。
/* * 注意!! 对于任何其它的任务，'pause()'将意味着我们必须等待收到一个信号才会返 * 回就绪运行态，但任务0（task0）是唯一的意外情况（参见'schedule()'），因为任 * 务0 在任何空闲时间里都会被激活（当没有其它任务在运行时）， * 因此对于任务0'pause()'仅意味着我们返回来查看是否有其它任务可以运行，如果没 * 有的话我们就回到这里，一直循环执行'pause()'。 */
    for(;;)
        __asm__("int $0x80"::"a" (__NR_pause):"ax");
}

// 产生格式化信息并输出到标准输出设备stdout(1)，这里是指屏幕上显示。参数'*fmt'
// 指定输出将采用的格式，参见各种标准C 语言书籍。该子程序正好是vsprintf 如何使
// 用的一个例子。
// 该程序使用vsprintf()将格式化的字符串放入printbuf 缓冲区，然后用write()
// 将缓冲区的内容输出到标准设备（1--stdout）。
static int printf(const char *fmt, ...)
{
    va_list args;
    int i;

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

void init(void)
{
    int pid,i;

// 读取硬盘参数包括分区表信息并建立虚拟盘和安装根文件系统设备。
// 该函数是在25 行上的宏定义的，对应函数是sys_setup()，在kernel/blk_drv/hd.c。
    setup((void *) &drive_info);

// 下面以读写访问方式打开设备“/dev/tty0”，它对应终端控制台。由于这是第一次打开文件
// 操作，因此产生的文件句柄号（文件描述符）肯定是0。该句柄是UNIX类操作系统默认的控
// 制台标准输入句柄stdbin。这里再把它以读和写的方式分别打开是为了复制产生标准输出（写）
// 句柄stdout和标准出错输出句柄stderr。函数前面的“（void）”前缀用于表示强制函数无需
// 返回值。
    (void) open("/dev/tty1",O_RDWR,0);
    (void) dup(0);      // 复制句柄，产生句柄1号--stdout标准输出设备。
    (void) dup(0);      // 复制句柄，产生句柄2号--stderr标准出错输出设备。 

// 下面打印缓冲区块数和总字节数，每块1024字节，以及主内存空闲内存字节数。
    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);

// 下面fork()用于创建一个子进程(子任务)。对于被创建的子进程，fork()将返回0 值，
// 对于原(父进程)将返回子进程的进程号。所以if (!(pid=fork())) {...} 内是子进程执行的内容。
// 该子进程关闭了句柄0(stdin)，以只读方式打开/etc/rc 文件，并执行/bin/sh 程序，所带参数和
// 环境变量分别由argv_rc 和envp_rc 数组给出。参见后面的描述。
    if (!(pid=fork())) {
        close(0);
        if (open("/etc/rc",O_RDONLY,0))
            _exit(1);
        execve("/bin/sh",argv_rc,envp_rc);
        _exit(2);
    }

// 下面是父进程执行的语句。wait()是等待子进程停止或终止，其返回值应是子进程的
// 进程号(pid)。这三句的作用是父进程等待子进程的结束。&i 是存放返回状态信息的
// 位置。如果wait()返回值不等于子进程号，则继续等待。
    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/tty1",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() */
}