main.c是BIOS各种初始化后进入的第一个C主程序，其作用简单的讲就是进行各种外围硬件的初始化，然后fork第一个进程，然后开始执行第一个程序bash，具体代码如下：
#define __LIBRARY__
#include <unistd.h>
#include <time.h>
/*
* 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.
*/
static inline _syscall0(int,fork)
static inline _syscall0(int,pause)
static inline _syscall1(int,setup,void *,BIOS)
static inline _syscall0(int,sync)
#include <linux/tty.h>
#include <linux/sched.h>
#include <linux/head.h>
#include <asm/system.h>
#include <asm/io.h>
#include <stddef.h>
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <linux/fs.h> ///包含的各种头文件，定义各种内嵌函数
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
*/
#define EXT_MEM_K (*(unsigned short *)0x90002)
#define DRIVE_INFO (*(struct drive_info *)0x90080)
#define ORIG_ROOT_DEV (*(unsigned short *)0x901FC) //宏定义，声明函数，定义部分变量
#define CMOS_READ(addr) ({ \
outb_p(0x80|addr,0x70); \
inb_p(0x71); \
})
#define BCD_TO_BIN(val) ((val)=((val)&15) + ((val)>>4)*10) //宏定义函数
static void time_init(void)
{
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--;
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; //设备信息结构体
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 = ORIG_ROOT_DEV;
drive_info = DRIVE_INFO;
memory_end = (1<<20) + (EXT_MEM_K<<10);
memory_end &= 0xfffff000;
if (memory_end > 16*1024*1024)
memory_end = 16*1024*1024;
if (memory_end > 12*1024*1024)
buffer_memory_end = 4*1024*1024;
else if (memory_end > 6*1024*1024)
buffer_memory_end = 2*1024*1024;
else
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();
time_init();
sched_init();
buffer_init(buffer_memory_end);
hd_init();
floppy_init();
sti(); //各种外围硬件初始化
move_to_user_mode(); //切换CPU到用户模式，要知道linux中，所有的进程都是在用户态模式下运行的
//只有在BIOS时，才是实模式，其他的为保护模式
if (!fork()){ //创建的第一个进程0，这里的判断条件，只有返回为0时，才会执行下面的程序
//而返回值0代表的是子进程，所以init会在子进程中执行，这也是fork的巧妙
//所在，类似于ucos中的oscreate，不过更灵活
/* we count on this going ok */
init(); //正如作者所注释的，我们全靠这个init了，靠他才能真正启动linux干活
}
/*
* 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.
*/
for(;;) pause(); //很显然，这个时候，这条语句是在父进程下执行，这里pause将意味着
//该调用它的人物必须要等待收到一个信号才会返回就绪运行态，但是task0
//是唯一比较特殊的（它必须特殊），因为task0是在任何空闲时间都会被激活
//前提是没有其他任务运行，因此对于task0，pause仅仅意味着我们返回查看
//是否有其他任务可以运行，如果没有，则就回到这里，一直循环执行pause
//这是为了防止CPU闲着没事儿做，因为cpu没有事儿干，就会疯掉的
//这个类似与ucos中的idle任务，看来操作系统都异曲同工
}
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;
} //打印函数
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 }; //定义变量
void init(void) //init函数，重要人员出场了
{
int pid,i;
setup((void *) &drive_info);
(void) open("/dev/tty0",O_RDWR,0); //打开串口，到现在这个套路还在
(void) dup(0);
(void) dup(0);
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);
if (!(pid=fork())) { //创建一个进程，分析如果pid=0，也就是表示下面的程序
//是在子进程中执行的
close(0);
if (open("/etc/rc",O_RDONLY,0)) //打开/etc/rc，那会儿应该就是些自启动程序，参数等等
_exit(1);
execve("/bin/sh",argv_rc,envp_rc); //执行/bin/sh ,这是linux的最大特征，神马桌面都是给麻瓜用的，
//大神是不用的
_exit(2); //如果打开失败，则退出
}
if (pid>0) //这个很明显是在父进程中执行，依然就是等待子进程执行完毕，停止
while (pid != wait(&i))
/* nothing */;
while (1) { //进入下一个循环，也是主循环
if ((pid=fork())<0) { //再次创建1个任务
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)); //再次执行/bin/sh，这里的参数跟前面的不一样了，这里也是进入到真正与
//用户直接对接操作的sh中，到这里，用户其实就可以通过bash来进行各种
//操作了
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() */
}
}
小记：这个fork满有意思，老子（父进程）生了儿子（子进程），就是希望儿子来完成自己的梦想，而这个老子，基本上也就退休了，充满爱意的一直循环等待
着儿子完成梦想，再次回到他身边。