Linux 0.11-通过 fork 看一次系统调用-26

Posted 热爱编程的大忽悠

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Linux 0.11-通过 fork 看一次系统调用-26相关的知识,希望对你有一定的参考价值。

Linux 0.11-通过 fork 看一次系统调用-26


从fork看一次系统调用

书接上回,上回书咱们说到,我们通过自己设计了一遍进程调度,又看了一次 Linux 0.11 的进程调度的全过程。有了这两回做铺垫,我们下一回就该非常自信地回到我们的主流程!

void main(void) 
    ...    
    move_to_user_mode();
    if (!fork()) 
        init();
    
    for(;;) pause();

move_to_user_mode已经让我们目前正在运行的程序模式转入用户态,处于受限状态,如果需要进行特殊操作,需要通过中断陷入内核态才可以。

也就是这个 fork 函数干了啥?

这个 fork 函数稍稍绕了点,我们看如下代码。

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(type,name) \\
type name(void) \\
 \\
    volatile long __res; \\
    _asm  \\
        _asm mov eax,__NR_##name \\
        _asm int 80h \\
        _asm mov __res,eax \\
     \\
    if (__res >= 0) \\
        return (type) __res; \\
    errno = -__res; \\
    return -1; \\

所以,把宏定义都展开,其实就相当于定义了一个函数

int fork(void) 
     volatile long __res;
    _asm 
        _asm mov eax,__NR_fork
        _asm int 80h
        _asm mov __res,eax
    
    if (__res >= 0)
        return (void) __res;
    errno = -__res;
    return -1;

仅此而已。

具体看一下 fork 函数里面的代码,又是讨厌的内联汇编,不过上面我已经变成好看一点的样子了,而且不用你看懂,听我说就行。

关键指令就是一个 0x80 号软件中断的触发,int 80h

其中还有一个 eax 寄存器里的参数是 __NR_fork,这也是个宏定义,值是 2

OK,还记得 0x80 号中断的处理函数么?这个是我们在 第18回 | 大名鼎鼎的进程调度就是从这里开始的 sched_init 里面设置的。

set_system_gate(0x80, &system_call);

看这个 system_call 的汇编代码,我们发现这么一行。

_system_call:
    ...
    call [_sys_call_table + eax*4]
    ...

刚刚那个值就用上了,eax 寄存器里的值是 2,所以这个就是在这个 sys_call_table 表里找下标 2 位置处的函数,然后跳转过去。

那我们接着看 sys_call_table 是个啥。

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
;

看到没,就是各种函数指针组成的一个数组,说白了就是个系统调用函数表。

那下标 2 位置处是啥?从第零项开始数,第二项就是 sys_fork 函数!

至此,我们终于找到了 fork 函数,通过系统调用这个中断,最终走到内核层面的函数是什么,就是 sys_fork。

_sys_fork:
    call _find_empty_process
    testl %eax,%eax
    js 1f
    push %gs
    pushl %esi
    pushl %edi
    pushl %ebp
    pushl %eax
    call _copy_process
    addl $20,%esp
1:  ret

至于这个函数是什么,我们下一讲再说。

从这讲的探索我们也可以看出,操作系统通过系统调用,提供给用户态可用的功能,都暴露在 sys_call_table 里了。

系统调用统一通过 int 0x80 中断来进入,具体调用这个表里的哪个功能函数,就由 eax 寄存器传过来,这里的值是个数组索引的下标,通过这个下标就可以找到在 sys_call_table 这个数组里的具体函数。

同时也可以看出,用户进程调用内核的功能,可以直接通过写一句 int 0x80 汇编指令,并且给 eax 赋值,当然这样就比较麻烦。

所以也可以直接调用 fork 这样的包装好的方法,而这个方法里本质也是 int 0x80 以及 eax 赋值而已。

本讲就借着这个机会,讲讲系统调用的玩法,你学会了么?

------

那我们再多说两句,刚刚定义 fork 的系统调用模板函数时,用的是 syscall0,其实这个表示参数个数为 0,也就是 sys_fork 函数并不需要任何参数。

所以其实,在 unistd.h 头文件里,还定义了 syscall0 ~ syscall3 一共四个宏。

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

看都能看出来,其实 syscall1 就表示有一个参数syscall2 就表示有两个参数

哎,就这么简单。

那这些参数放在哪里了呢?总得有个约定的地方吧?

我们看一个今后要讲的重点函数,execve,是一个通常和 fork 在一起配合的变身函数,在之后的进程 1 创建进程 2 的过程中,就是这样玩的。

void init(void) 
    ...
    if (!(pid=fork())) 
        ...
        execve("/bin/sh",argv_rc,envp_rc);
        ...
    

fork和exec函数解析

当然我们的重点不是研究这个函数的作用,仅仅把它当做研究 syscall3 的一个例子,因为它的宏定义就是 syscall3

execve("/bin/sh",argv_rc,envp_rc);

_syscall3(int,execve,const char *,file,char **,argv,char **,envp)

#define _syscall3(type,name,atype,a,btype,b,ctype,c) \\
type name(atype a,btype b,ctype c)  \\
    volatile long __res; \\
    _asm  \\
        _asm mov eax,__NR_##name \\
        _asm mov ebx,a \\
        _asm mov ecx,b \\
        _asm mov edx,c \\
        _asm int 80h \\
        _asm mov __res,eax\\
     \\
    if (__res >= 0) \\
        return (type) __res; \\
    errno = -__res; \\
    return -1; \\

可以看出,参数 a 被放在了 ebx 寄存器,参数 b 被放在了 ecx 寄存器,参数 c 被放在了 edx 寄存器

我们再打开 system_call 的代码,刚刚我们只看了它的关键一行,就是去系统调用表里找函数。

_system_call:
    ...
    call [_sys_call_table + eax*4]
    ...

我们再看看全貌。

_system_call:
    cmpl $nr_system_calls-1,%eax
    ja bad_sys_call
    push %ds
    push %es
    push %fs
    pushl %edx
    pushl %ecx      # push %ebx,%ecx,%edx as parameters
    pushl %ebx      # to the system call
    movl $0x10,%edx     # set up ds,es to kernel space
    mov %dx,%ds
    mov %dx,%es
    movl $0x17,%edx     # fs points to local data space
    mov %dx,%fs
    call _sys_call_table(,%eax,4)
    pushl %eax
    movl _current,%eax
    cmpl $0,state(%eax)     # state
    jne reschedule
    cmpl $0,counter(%eax)       # counter
    je reschedule
ret_from_sys_call:
    movl _current,%eax      # task[0] cannot have signals
    cmpl _task,%eax
    je 3f
    cmpw $0x0f,CS(%esp)     # was old code segment supervisor ?
    jne 3f
    cmpw $0x17,OLDSS(%esp)      # was stack segment = 0x17 ?
    jne 3f
    movl signal(%eax),%ebx
    movl blocked(%eax),%ecx
    notl %ecx
    andl %ebx,%ecx
    bsfl %ecx,%ecx
    je 3f
    btrl %ecx,%ebx
    movl %ebx,signal(%eax)
    incl %ecx
    pushl %ecx
    call _do_signal
    popl %eax
3:  popl %eax
    popl %ebx
    popl %ecx
    popl %edx
    pop %fs
    pop %es
    pop %ds
    iret

又被吓到了是不是?

别怕,我们只关注压栈的情况,还记不记得在 一个新进程的诞生(二)从内核态到用户态 讲中,我们聊到触发了中断后,CPU 会自动帮我们做如下压栈操作。

因为 system_call 是通过 int 80h 这个软中断进来的,所以也属于中断的一种,具体说是属于特权级发生变化的,且没有错误码情况的中断,所以在这之前栈已经被压了 SS、ESP、EFLAGS、CS、EIP 这些值。

接下来 system_call 又压入了一些值,具体说来有 ds、es、fs、edx、ecx、ebx、eax

如果你看源码费劲,得不出我上述结论,那你可以看 system_call.s 上面的注释,Linus 作者已经很贴心地给你写出了此时的堆栈状态。

/*
 * Stack layout in 'ret_from_system_call':
 *
 *   0(%esp) - %eax
 *   4(%esp) - %ebx
 *   8(%esp) - %ecx
 *   C(%esp) - %edx
 *  10(%esp) - %fs
 *  14(%esp) - %es
 *  18(%esp) - %ds
 *  1C(%esp) - %eip
 *  20(%esp) - %cs
 *  24(%esp) - %eflags
 *  28(%esp) - %oldesp
 *  2C(%esp) - %oldss
 */

看,就是 CPU 中断压入的 5 个值,加上 system_call 手动压入的 7 个值。

所以之后,中断处理程序如果有需要的话,就可以从这里取出它想要的值,包括 CPU 压入的那五个值,或者 system_call 手动压入的 7 个值。

比如 sys_execve 这个中断处理函数,一开始就取走了位于栈顶 0x1C 位置处的 EIP 的值。

EIP = 0x1C
_sys_execve:
    lea EIP(%esp),%eax
    pushl %eax
    call _do_execve
    addl $4,%esp
    ret

随后在 do_execve 函数中,又通过 C 语言函数调用的约定,取走了 filename,argv,envp 等参数。

int do_execve(
        unsigned long * eip,
        long tmp,
        char * filename,
        char ** argv,
        char ** envp) 
    ...

具体这个函数的详细流程和作用,将会在第四部分的 shell 程序装载章节讲到。

今天你只需要记住一次系统调用的流程和原理,就可以了,把下图印在脑子里。

之后很多函数都会像今天的 fork 一样,走一遍系统调用的流程,到时候我就不再展开了。

所以前面的底子打得越好,后面你将会学得越爽。

欲知后事如何,且听下回分解。


转载

本文转载至闪客图解操作系统系列文章

以上是关于Linux 0.11-通过 fork 看一次系统调用-26的主要内容,如果未能解决你的问题,请参考以下文章

Linux 0.11-fork 中进程基本信息的复制-27

Linux 0.11-fork 中进程基本信息的复制-27

Linux 0.11-一个新进程的诞生-22

Linux 0.11-一个新进程的诞生-22

Linux 0.11-从一次定时器滴答来看进程调度-25

Linux 0.11-从一次定时器滴答来看进程调度-25