你真的知道什么是系统调用吗?

在现代操作系统里,由于系统资源可能同时被多个应用程序访问,如果不加保护,那各个应用程序之间可能会产生冲突,对于恶意应用程序更可能导致系统奔溃。这里所说的系统资源包括文件、网络、各种硬件设备等。比如要操作文件必须借助操作系统提供的api(比如linux下的fopen)。

系统调用在我们工作中无时无刻不打着交道,那系统调用的原理是什么呢?在其过程中做了哪些事情呢?

本文将阐述系统调用原理,让大家对于系统调用有一个清晰的认识。

更多文章见个人博客:https://github.com/farmerjohngit/myblog

概述

现代cpu通常有多种特权级别,一般来说特权级总共有4个,编号从Ring 0(最高特权)到Ring 3(最低特权),在Linux上之用到Ring 0和RIng 3,用户态对应Ring 3,内核态对应Ring 0。

普通应用程序运行在用户态下,其诸多操作都受到限制,比如改变特权级别、访问硬件等。特权高的代码能将自己降至低等级的级别,但反之则是不行的。而系统调用是运行在内核态的,那么运行在用户态的应用程序如何运行内核态的代码呢?操作系统一般是通过中断来从用户态切换到内核态的。学过操作系统课程的同学对中断这个词肯定都不陌生。

中断一般有两个属性,一个是中断号,一个是中断处理程序。不同的中断有不同的中断号,每个中断号都对应了一个中断处理程序。在内核中有一个叫中断向量表的数组来映射这个关系。当中断到来时,cpu会暂停正在执行的代码,根据中断号去中断向量表找出对应的中断处理程序并调用。中断处理程序执行完成后,会继续执行之前的代码。

中断分为硬件中断和软件中断,我们这里说的是软件中断,软件中断通常是一条指令,使用这条指令用户可以手动触发某个中断。例如在i386下,对应的指令是int,在int指令后指定对应的中断号,如int 0x80代表你调用第0x80号的中断处理程序。

中断号是有限的,所有不会用一个中断来对应一个系统调用(系统调用有很多)。Linux下用int 0x80触发所有的系统调用,那如何区分不同的调用呢?对于每个系统调用都有一个系统调用号,在触发中断之前,会将系统调用号放入到一个固定的寄存器,0x80对应的中断处理程序会读取该寄存器的值,然后决定执行哪个系统调用的代码。

在Linux2.5(具体版本不是很确定)之前的版本,是使用int 0x80这样的方式实现系统调用的,但其实int指令这样的形式性能不太好,原因如下(出自这篇文章):

在 x86 保护模式中,处理 INT 中断指令时,CPU 首先从中断描述表 IDT 取出对应的门描述符,判断门描述符的种类,然后检查门描述符的级别 DPL 和 INT 指令调用者的级别 CPL,当 CPL<=DPL 也就是说 INT 调用者级别高于描述符指定级别时,才能成功调用,最后再根据描述符的内容,进行压栈、跳转、权限级别提升。内核代码执行完毕之后,调用 IRET 指令返回,IRET 指令恢复用户栈,并跳转会低级别的代码。

其实,在发生系统调用,由 Ring3 进入 Ring0 的这个过程浪费了不少的 CPU 周期,例如,系统调用必然需要由 Ring3 进入 Ring0(由内核调用 INT 指令的方式除外,这多半属于 Hacker 的内核模块所为),权限提升之前和之后的级别是固定的,CPL 肯定是 3,而 INT 80 的 DPL 肯定也是 3,这样 CPU 检查门描述符的 DPL 和调用者的 CPL 就是完全没必要。

正是由于如此,在linux2.5开始支持一种新的系统调用,其基于Intel 奔腾2代处理器就开始支持的一组专门针对系统调用的指令sysenter/sysexitsysenter 指令用于由 Ring3 进入 Ring0,sysexit指令用于由 Ring0 返回 Ring3。由于没有特权级别检查的处理,也没有压栈的操作,所以执行速度比 INT n/IRET 快了不少。

本文分析的是int指令,新型的系统调用机制可以参见下面几篇文章:

https://www.ibm.com/developerworks/cn/linux/kernel/l-k26ncpu/index.html

https://www.jianshu.com/p/f4c04cf8e406

基于int的系统调用

触发中断

我们以系统调用fork为例,fork函数的定义在glibc(2.17版本)的unistd.h

/* Clone the calling process, creating an exact copy.
   Return -1 for errors, 0 to the new process,
   and the process ID of the new process to the old process.  */
extern __pid_t fork (void) __THROWNL;

fork函数的实现代码比较难找,在nptl\sysdeps\unix\sysv\linux\fork.c中有这么一段代码

weak_alias (__libc_fork, __fork)
libc_hidden_def (__fork)
weak_alias (__libc_fork, fork)

其作用简单的说就是将__libc_fork当作__fork的别名,所以fork函数的实现是在__libc_fork中,核心代码如下

#ifdef ARCH_FORK
  pid = ARCH_FORK ();
#else
# error "ARCH_FORK must be defined so that the CLONE_SETTID flag is used"
  pid = INLINE_SYSCALL (fork, 0);
#endif

我们分析定义了ARCH_FORK的情况,ARCH_FORK定义在nptl\sysdeps\unix\sysv\linux\i386\fork.c中,代码如下:

#define ARCH_FORK() \
  INLINE_SYSCALL (clone, 5,                           \
          CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | SIGCHLD, 0,     \
          NULL, NULL, &THREAD_SELF->tid)

INLINE_SYSCALL代码在sysdeps\unix\sysv\linux\i386\sysdep.h

#undef INLINE_SYSCALL
#define INLINE_SYSCALL(name, nr, args...) \
  ({                                          \
    unsigned int resultvar = INTERNAL_SYSCALL (name, , nr, args);         \
    if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (resultvar, ), 0))         \
      {                                       \
    __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, ));           \
    resultvar = 0xffffffff;                           \
      }                                       \
    (int) resultvar; })

INLINE_SYSCALL主要是调用同文件下的INTERNAL_SYSCALL

# define INTERNAL_SYSCALL(name, err, nr, args...) \
  ({                                          \
    register unsigned int resultvar;                          \
    EXTRAVAR_##nr                                 \
    asm volatile (                                \
    LOADARGS_##nr                                 \
    "movl %1, %%eax\n\t"                              \
    "int $0x80\n\t"                               \
    RESTOREARGS_##nr                                  \
    : "=a" (resultvar)                                \
    : "i" (__NR_##name) ASMFMT_##nr(args) : "memory", "cc");              \
    (int) resultvar; })


#define __NR_clone 120

这里是一段内联汇编代码, 其中__NR_##name的值为 __NR_clone即120。这里主要是两个步骤:

  1. 设置eax寄存器的值为120
  2. 执行int $0x80陷入中断

int $0x80指令会让cpu陷入中断,执行对应的0x80中断处理函数。不过在这之前,cpu还需要进行栈切换

因为在linux中,用户态和内核态使用的是不同的栈(可以看看这篇文章),两者负责各自的函数调用,互不干扰。在执行int $0x80时,程序需要由用户态切换到内核态,所以程序当前栈也要从用户栈切换到内核栈。与之对应,当中断程序执行结束返回时,当前栈要从内核栈切换回用户栈

这里说的当前栈指的就是ESP寄存器的值所指向的栈。ESP的值位于用户栈的范围,那程序的当前栈就是用户栈,反之亦然。此外寄存器SS的值指向当前栈所在的页。因此,将用户栈切换到内核栈的过程是:

  1. 将当前ESP、SS等寄存器的值存到内核栈上。
  2. 将ESP、SS等值设置为内核栈的相应值。

反之,从内核栈切换回用户栈的过程:恢复ESP、SS等寄存器的值,也就是用保存在内核栈的原ESP、SS等值设置回对应寄存器。

中断处理程序

在切换到内核栈之后,就开始执行中断向量表的0x80号中断处理程序。中断处理程序除了系统调用(0x80)还有如除0异常(0x00)、缺页异常(0x14)等等,在arch\i386\kernel\traps.c文件的trap_init方法中描述了中断处理程序向中断向量表注册的过程:

void __init trap_init(void)
{
#ifdef CONFIG_EISA
    void __iomem *p = ioremap(0x0FFFD9, 4);
    if (readl(p) == 'E'+('I'<<8)+('S'<<16)+('A'<<24)) {
        EISA_bus = 1;
    }
    iounmap(p);
#endif

#ifdef CONFIG_X86_LOCAL_APIC
    init_apic_mappings();
#endif

    set_trap_gate(0,&divide_error);
    set_intr_gate(1,&debug);
    set_intr_gate(2,&nmi);
    set_system_intr_gate(3, &int3); /* int3-5 can be called from all */
    set_system_gate(4,&overflow);
    set_system_gate(5,&bounds);
    set_trap_gate(6,&invalid_op);
    set_trap_gate(7,&device_not_available);
    set_task_gate(8,GDT_ENTRY_DOUBLEFAULT_TSS);
    set_trap_gate(9,&coprocessor_segment_overrun);
    set_trap_gate(10,&invalid_TSS);
    set_trap_gate(11,&segment_not_present);
    set_trap_gate(12,&stack_segment);
    set_trap_gate(13,&general_protection);
    set_intr_gate(14,&page_fault);
    set_trap_gate(15,&spurious_interrupt_bug);
    set_trap_gate(16,&coprocessor_error);
    set_trap_gate(17,&alignment_check);
#ifdef CONFIG_X86_MCE
    set_trap_gate(18,&machine_check);
#endif
    set_trap_gate(19,&simd_coprocessor_error);

    set_system_gate(SYSCALL_VECTOR,&system_call);

    /*
     * Should be a barrier for any external CPU state.
     */
    cpu_init();

    trap_init_hook();
}

SYSCALL_VECTOR定义如下:

#define SYSCALL_VECTOR      0x80

所以0x80对应的处理程序就是system_call这个方法,该方法位于arch\i386\kernel\entry.S

ENTRY(system_call)
    //code 1: 保存各种寄存器
    SAVE_ALL
    ...
    jnz syscall_trace_entry
    //如果传入的系统调用号大于最大的系统调用号,则跳转到无效调用处理
    cmpl $(nr_syscalls), %eax
    jae syscall_badsys
    
syscall_call:
    //code 2: 根据系统调用号(存储在eax中)来调用对应的系统调用程序
    call *sys_call_table(,%eax,4)
    //保存系统调用返回值到eax寄存器中
    movl %eax,EAX(%esp)     # store the return value
    ...
restore_all:
    //code 3:恢复各种寄存器的值 以及执行iret指令
    RESTORE_ALL
    ...
 

主要分为几步:

1.保存各种寄存器

2.根据系统调用号执行对应的系统调用程序,将返回结果存入到eax中

3.恢复各种寄存器

其中保存各种寄存器的SAVE_ALL定义在entry.S中:

#define SAVE_ALL \
    cld; \
    pushl %es; \
    pushl %ds; \
    pushl %eax; \
    pushl %ebp; \
    pushl %edi; \
    pushl %esi; \
    pushl %edx; \
    pushl %ecx; \
    pushl %ebx; \
    movl $(__USER_DS), %edx; \
    movl %edx, %ds; \
    movl %edx, %es;

sys_call_table定义在entry.S中:

.data
ENTRY(sys_call_table)
    .long sys_restart_syscall   /* 0 - old "setup()" system call, used for restarting */
    .long sys_exit
    .long sys_fork
    .long sys_read
    .long sys_write
    .long sys_open      /* 5 */
    ...
    .long sys_sigreturn
    .long sys_clone     /* 120 */
    ...

sys_call_table就是系统调用表,每一个long元素(4字节)都是一个系统调用地址,所以 *sys_call_table(,%eax,4)的含义就是sys_call_table上偏移量为0+%eax*4元素所指向的系统调用,即第%eax个系统调用。上文中fork系统调用最终设置到eax的值是120,那最终执行的就是sys_clone这个函数,注意其实现和第2个系统调用sys_fork基本一样,只是参数不同,关于fork和clone的区别可以看这里,代码如下:

//kernel\fork.c
asmlinkage int sys_fork(struct pt_regs regs)
{
    return do_fork(SIGCHLD, regs.esp, &regs, 0, NULL, NULL);
}

asmlinkage int sys_clone(struct pt_regs regs)
{
    unsigned long clone_flags;
    unsigned long newsp;
    int __user *parent_tidptr, *child_tidptr;

    clone_flags = regs.ebx;
    newsp = regs.ecx;
    parent_tidptr = (int __user *)regs.edx;
    child_tidptr = (int __user *)regs.edi;
    if (!newsp)
        newsp = regs.esp;
    return do_fork(clone_flags, newsp, &regs, 0, parent_tidptr, child_tidptr);
}

一次系统调用的基本过程已经分析完,剩下的具体处理逻辑和本文无关就不分析了,有兴趣的同学可以自己看看。

整体调用流程图如下:

1550410105156.png

End

想写这篇文章的原因主要是年前在看《《程序员的自我修养》》这本书,之前对于系统调用这块有一些了解但很零碎和模糊,看完本书系统调用这一章后消除了我许多疑问。总体来说这是一本不错的书,但我相关的基础比较薄弱,所以收获不多。

推荐阅读更多精彩内容

  • 这一篇介绍一下系统调用,熟悉一下流程。很多做客户端的同学根本不知道这些内容。建议花时间看看相关的知识。最好的方式还...
    纸简书生阅读 764评论 1 3
  • 计算机系统漫游 代码从文本到可执行文件的过程(c语言示例):预处理阶段,处理 #inlcude , #defin...
    willdimagine阅读 2,329评论 0 5
  • 所有的程序员在写程序的时候都离不开通过库函数的方式和系统调用打交道 什么是用户态和内核态?(从CPU指令级别的角度...
    那只大象阅读 2,951评论 1 5
  • 安大大 + 原创作品转载请注明出处 + 《Linux操作系统分析》MOOC课程 用户态、内核态和中断处理过程 程序...
    夏天的篮球阅读 1,067评论 0 0
  • 一、温故而知新 1. 内存不够怎么办 内存简单分配策略的问题地址空间不隔离内存使用效率低程序运行的地址不确定 关于...
    SeanCST阅读 6,541评论 0 27
  • 古老的广场上,那静静盘坐的五道人影,几乎是在此时同时睁开了双目,而在双目睁开的那一刹那,五人身体表面竟然都是泛着淡...
    混沌天书阅读 186评论 0 0
  • 夜里十一点半了,仍不愿睡去,又看了一遍为女儿制作的小视频,万般思念,千般牵挂,只愿我的宝贝女儿千里之外,一切安好!
    雕琢灵魂阅读 96评论 0 1
  • 秋九,当我踏上校园的那一步,我渐渐的明白,有些决定是不能再去后悔。原本高于本科十几分的我是有机会去本科...
    对方正在输入_62f7阅读 59评论 0 0
  • 一. 线程池概述 在介绍线程池之前,先说一下为什么在开发中要使用线程池,个人认为主要有一下的原因: 开发中使用线程...
    BrightLoong阅读 393评论 0 0