• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

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

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

到了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启动已经完成。有上面的代码分析可知,根文件系统只要即可实现。
 */


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
SQL 实现 C# Split 功能发布时间:2022-07-13
下一篇:
C++习题虚函数-计算图形面积发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap