我们已经了解了操作系统启动的过程, 现在我们需要更进一步的了解软件是如何调用硬件的

介绍

当我们在编写一段代码时,比如 printf("Hello World")执行后,会在屏幕中输出我们的内容, 但是这部分内容是如何输出到屏幕中的, 我们毫不知情,因为这部分调用是由编译软件负责帮助我们进行沟通的, 编译软件通过调用 OS 的接口来实现这些功能.

那么 OS 接口是什么? 在底层他是如何实现的?

我们都学过编程, 当我们想要调用一个产生随机数的函数时,我们会通过调用 random函数来获取一个随机数, 那么 OS 接口就类似于这里的 random() (这里得出 OS 接口其实就是一些函数) 同时我们需要注意的是因为这些函数是操作系统提供给我们的,为了和普通调用区别我们将其称为 System Call (系统调用).

标准接口

现在我们对 OS 接口已经有了基本的了解, 那么另一个问题出现了,你搞一个 A 系统然后出一个 A_OS 接口 , 我搞一个 B系统 出一个 B_OS 接口, 这时候 C 写了一个程序,在 A_OS 上使用的好好的, 放到 B_OS 上就死了, 这时候还得为了 B_OS 专门在写一个程序,这时候就很不友好,为了解决这一乱象,IEEE 协会制定了一个 标准接口

系统调用是必要的?

在 Linux 中我们有时候需要知道自己的当前登陆的用户,我们可以在 Linux 使用 whoami来查看当前用户是谁, 但是这部分数据是存储在内存中的,所以我们需要进行一个 系统调用来进行操作.

这时候我们提出几个问题?

• 为什么需要使用系统调用实现,而不是函数调用?
• 如何防止直接访问修改
• 如何进入内核

为什么需要使用系统调用实现,而不是函数调用?

对于第一个问题,我们可以直接给出答案: 因为内存中会存在很多重要的数据比如用户密码等等数据, 如果我们可以通过函数调用来进行读取, 我们就可以通过编写一个函数来实现随意的修改和读取机器内存中数据,进而获取到用户密码或者破坏机器的目的.

如何防止直接访问内核

我们是依靠硬件实现的,那么如何实现的?

我们的 OS 会将内存分为很多的区域, 但是一般我们都以两种类别: 用户态对应的内存区域叫用户段, 核心态对应的内存区域为内核态

特点和示意图如下:

1. 内核段的代码只在内核态下运行，也只用它可以操作内核段；
2. 用户态的程序不能操作内核段（访问或者跳转都不行）
3. 我们可以用数字来表示特权级。数字越低，级别越高

上面只是简述了简单的一个例子, 我们再次精进进行一波思考如何实现的?

内核段，用户段，其实都得靠段寄存器来保存段基址；我们可以用CS段寄存器的低两位（称为CPL），和DS的低两位（称为DPL）来实现区分。其全称和含义如下：

DPL：Descriptor Privilege Level，D也可以解释为Destination 目标段
CPL：Current Privilege Level 当前的特权级

在每次访问的时候，都要看一看当前的特权级和访问的区域特权级并比较。这里检查：CPL ≤ DPL?

如果当前特权级CPL是0的话，当DPL是0，可以访问；当CPL是0，DPL的是3，也可以访问，也就是说当前特权级是内核级，可以访问用户内存，也可以访问内核态内存， 如果当前特权级CPL3的话，例如3，只能访问用户特权级3，不能访问内核段0，也就是说，我们一开始的C语言程序里要调用系统函数，但CS对应的当前特权当前特权级是3，就不允许直接跳到这里系统函数里，因为系统函数的DPL等于0。

如何进入内核? 中断

:::success 一个新的问题: 在第二个问题中解释了如何防止直接访问内核数据, 那么 OS 应该提供另一个方法来操作硬件?

这里计算机提供了唯一的方法: 中断, 只有通过中断才能进入内核. 当然也不是所有的中断都可以进入内核，只有部分才可以

:::

我们在前面提到过一个 whoami指令,在该指令查阅就是一段包含中断的代码, 在C语言的库函数里，实际上写了一段包含中断的代码。因此C语言执行的过程大致是这样的：

用户编写程序调用printf函数 → printf调用C语言的库函数 → 库函数里实现系统调用 → 根据中断进入内核 → 执行中断程序，处理系统调用 → 返回

用户编写程序调用printf函数 
↓
printf调用C语言的库函数 
↓
库函数里实现系统调用 
↓
根据中断进入内核
↓
执行中断程序，处理系统调用 
↓
返回

系统调用的实现过程

系统调用是通过int 0x80 这个中断进去内核的，这是操作系统的规定。

/*
 *  linux/lib/write.c
 *
 *  (C) 1991  Linus Torvalds
 */
#define __LIBRARY__
#include <unistd.h>
// fd: 要进行写操作的文件描述此
// buf : 需要输出的缓冲区
// count : 最大输出字节数
_syscall3(int,write,int,fd,const char *,buf,off_t,count)

那么 _syscall3是如何执行的? 使用 宏替换, 我们可以看linux-0.11\include\unistd.h的关键代码，第5行有int 0x80中断的字眼

#define _syscall3(type,name,atype,a,btype,b,ctype,c) \
type name(atype a,btype b,ctype c) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
    : "=a" (__res) \
    : "0" (__NR_##name),"b" ((long)(a)),"c" ((long)(b)),"d" ((long)(c))); \
if (__res>=0) \
    return (type) __res; \
errno=-__res; \
return -1; \
}

宏展开—准备中断的传参

#define __NR_setup    0
#define __NR_exit    1
#define __NR_fork    2
#define __NR_read    3
#define __NR_write    4

_syscall3(int,write,int,fd,const char *,buf,off_t,count)

print("ECHO:%s\n", argv[1])

#define _syscall3(type,name,atype,a,btype,b,ctype,c) \
type name(atype a,btype b,ctype c) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
    : "=a" (__res) \
    : "0" (__NR_##name),"b" ((long)(a)),"c" ((long)(b)),"d" ((long)(c))); \
if (__res>=0) \
    return (type) __res; \
errno=-__res; \
return -1; \
}

_syscall3(int, write, int,  fd, const char *, buf, off_t,count)  //write.c
_syscall3(type, name, atype, a,  btype,        b,  ctype,  c) //unistd.h

进行参数替换,结果变为:

type=int,name=write,atype=int,a=fd,btype=const char * ,b=buf,ctype=off_t,c=count;

type name(atype a, btype b, ctype c) {    // 函数定义
  long __res;    // 定义一个变量
  __asm__ volatile(    // 内联汇编 (注解1)
           "int $0x80"
                   : "=a"(__res)
                   : "0"(__NR_##name), "b"((long)(a)), "c"((long)(b)), "d"((long)(c)));
  if (__res >= 0)
    return (type)__res;
  errno = -__res;
  return -1;
}

asm (
  "汇编语句模板"
  :输出寄存器
  :输入寄存器
  :会被修改的寄存器
)

#define _syscall0(type,name)
#define _syscall1(type,name,atype,a)
#define _syscall2(type,name,atype,a,btype,b)

IDT 表的初始化

1. 在main.c 的第132行处的这个方法就是初始化：

sched_init();

1. 该方法在 linux-0.11\kernel\sched.c的385行，该方法的最后一行如下，也就是设置中断号为80时，调用system_call函数，也就说后续80号中断都由这个函数来执行IDT每一个表项的内容就是中断例程的地址，每个表项也可以称为中断处理门，这就是为什么函数名有个gate

void sched_init(void)
{
    //…… 这里省略其他代码
    set_system_gate(0x80,&system_call);
}

1. 在 include\asm\system.h的第39行，有这样一个宏定义：

#define set_system_gate(n,addr) \
    _set_gate(&idt[n],15,3,addr)   //这里IDT是中断向量表基址，addr就是system_call函数的地址

_set_gate(gate_addr,type,dpl,addr) {
   __asm__ ("movw %%dx,%%ax\n\t"     //表示用 dx 加载 ax；
    "movw %0,%%dx\n\t"     //表示用(0x8000+(dpl<<13)+(type<<8))加载 dx,
    "movl %%eax,%1\n\t" 
    "movl %%edx,%2" 
    : 
    : "i" ((short) (0x8000+(dpl<<13)+(type<<8))), 
    "o" (*((char *) (gate_addr))), 
    "o" (*(4+(char *) (gate_addr))), 
    "d" ((char *) (addr)),"a" (0x00080000))
}

• gate_addr是IDT的地址 addr就是sched.c里传的 &system_call地址
• 15传给type
• 关键是这个3 传给了DPL
• 后续的C内嵌汇编就是将相关信息（特别是system_call的地址和DPL的值）填充IDT表项

• "i" ((short) (0x8000+(dpl<<13)+(type<<8))) i 表示直接操作数，short表示操作字节，这是第0个操作数
• "o" (*((char *) (gate_addr))), o 表示内存单元 这是第一个操作数
• "o" (*(4+(char *) (gate_addr))), ，这是第二个操作数
• "d" ((char *) (addr)) 这是第3个操作数，d 表示寄存器edx，表示用addr加载edx
• 最后的一个 “a” (0x00080000)) 表示将0x0008 0000的前4个十六进制数（共16bit），赋值给段选择符

还记不记得我们在将操作系统引导的时候，setup.s 会开启32位汇编，jmpi 0， 8 最后会跳转到0地址处，执行system模块的代码？这里也是一样的，会跳转到0地址处，然后IP就是system_call的地址，开始执行system_call函数

中断处理函数system_call做了什么

_system_call:
  ; ……其他代码
  pushl %ebx
  movl $0x10,%edx
  mov %dx,%ds
  mov %dx,%es  ; ds和es都等于0x10, 二进制的最后2位是0，设置数据段为内核的数据段
  ; 关键就是下面的代码：
  call _sys_call_table(,%eax,4)
ret_from_sys_call:
    popl %eax

fn_ptr sys_call_table[] = { sys_setup, sys_exit, sys_fork, sys_read,
sys_write, sys_open, sys_close, sys_waitpid, sys_creat, sys_link,
sys_unlink, sys_execve, sys_chdir, sys_time, sys_mknod, sys_chmod,
sys_chown, sys_break, sys_stat, sys_lseek, sys_getpid, sys_mount,
sys_umount, sys_setuid, sys_getuid, sys_stime, sys_ptrace, sys_alarm,
sys_fstat, sys_pause, sys_utime, sys_stty, sys_gtty, sys_access,
sys_nice, sys_ftime, sys_sync, sys_kill, sys_rename, sys_mkdir,
sys_rmdir, sys_dup, sys_pipe, sys_times, sys_prof, sys_brk, sys_setgid,
sys_getgid, sys_signal, sys_geteuid, sys_getegid, sys_acct, sys_phys,
sys_lock, sys_ioctl, sys_fcntl, sys_mpx, sys_setpgid, sys_ulimit,
sys_uname, sys_umask, sys_chroot, sys_ustat, sys_dup2, sys_getppid,
sys_getpgrp, sys_setsid, sys_sigaction, sys_sgetmask, sys_ssetmask,
sys_setreuid,sys_setregid };

typedef int (*fn_ptr)();

#define __NR_setup    0
#define __NR_exit    1
#define __NR_fork    2
#define __NR_read    3
#define __NR_write    4

总结

1. 用户调用printf的时候，CPL = 3，会展开成一段包含int 0x80的代码
2. 在系统初始化的时候，设置了IDT表，将int 0x80的中断处理函数设置成system_call，并且设置DPL也等于3，所以才可以执行 “跳转到system_call”这条指令。进入system_call函数后，CPL是变成0的 ，接下来就在内核里处理
3. system_call 里 会根据系统调用号，查表sys_call_table
4. 这里printf的系统调用号是4
5. 因此最后会调用sys_write（这里就可以操作和访问内核的数据段）