Linux之系统调用

文章目录

glibc对系统调用的封装

Linux提供了glibc这个中介,它更熟悉系统调用的细节,并且可以封装成更加友好的接口。

通过最常用的系统调用open为例,看看系统调用是如何实现的。

用户态进程里调用open函数如下:

大部分用户会选择glibc里面的open函数,定义如下

int open(const char *pathname, int flags, mode_t mode)

glibc源代码中,有个文件syscalls.list,里面列着所有glibc的函数对应的系统调用,就像下面这样

# File name Caller  Syscall name    Args    Strong name Weak names
open		-	open		Ci:siv	 __libc_open __open    open

glibc源代码中,还有一个脚本make-syscall.sh,可以根据syscalls.list配置文件,对于每个封装好的系统调用,生成一个文件,文件里面定义了一些宏,例如

#define SYSCALL_NAME open

glibc还有一个文件syscall-template.S,使用上面这个宏,定义了这个系统调用的调用方式

T_PSEUDO (SYSCALL_SYMBOL, SYSCALL_NAME, SYSCALL_NARGS)
    ret
T_PSEUDO_END (SYSCALL_SYMBOL)
 
#define T_PSEUDO(SYMBOL, NAME, N)		PSEUDO (SYMBOL, NAME, N)

PSEUDO 也是一个宏,定义如下:

#define PSEUDO(name, syscall_name, args)                 
  .text;                                      
  ENTRY (name)                                    
    DO_CALL (syscall_name, args);                         
    cmpl $-4095, %eax;                              
    jae SYSCALL_ERROR_LABEL

里面对于任何一个系统调用,会调用DO_CALL,这也是一个宏,宏32位和64位的定义不一样。

32位系统调用过程

在 Linux的源代码注释里,可以看到寄存器是如何传递系统调用号和参数的。

/* Linux takes system call arguments in registers:
	syscall number	%eax	     call-clobbered
	arg 1		%ebx	     call-saved
	arg 2		%ecx	     call-clobbered
	arg 3		%edx	     call-clobbered
	arg 4		%esi	     call-saved
	arg 5		%edi	     call-saved
	arg 6		%ebp	     call-saved
......
*/
#define DO_CALL(syscall_name, args)                           \
    PUSHARGS_##args                               \
    DOARGS_##args                                 \
    movl $SYS_ify (syscall_name), %eax;                          \
    ENTER_KERNEL                                  \
    POPARGS_##args
  • 请求参数放在寄存器里面
  • 根据系统调用的名称,得到系统调用号,放在寄存器eax里面
  • 执行ENTER_KERNEL

ENTER_KERNEL 如下

# define ENTER_KERNEL int $0x80

int就是interrupt,中断的意思,int $0x80就是触发一个软中断,通过它就可以陷入内核。

内核启动的时候,有一个trap_init(),其中有这样的代码

set_system_intr_gate(IA32_SYSCALL_VECTOR, entry_INT80_32);

这是一个软中断的陷入门,收到一个系统调用的时候,entry_INT80_32就被调用了

ENTRY(entry_INT80_32)
        ASM_CLAC
        pushl   %eax                    /* pt_regs->orig_ax */
        SAVE_ALL pt_regs_ax=$-ENOSYS    /* save rest */
        movl    %esp, %eax
        call    do_syscall_32_irqs_on
.Lsyscall_32_done:
......
.Lirq_return:
	INTERRUPT_RETURN
  • PUSH和SAVE_ALL将当前用户态的寄存器,保存在pt_regs结构里面
  • 进入内核之前,保存所有的寄存器,然后调用do_syscall_32_irqs_on,实现如下
static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs)
{
	struct thread_info *ti = current_thread_info();
	unsigned int nr = (unsigned int)regs->orig_ax;
......
	if (likely(nr < IA32_NR_syscalls)) {
		regs->ax = ia32_sys_call_table[nr](
			(unsigned int)regs->bx, (unsigned int)regs->cx,
			(unsigned int)regs->dx, (unsigned int)regs->si,
			(unsigned int)regs->di, (unsigned int)regs->bp);
	}
	syscall_return_slowpath(regs);
}
  • 将系统调用号从eax里面取出来,然后根据系统调用号,在系统调用表中找到相应的函数进行调用
  • 将寄存器中保存的参数取出来,作为函数参数。

根据宏定义 #define ia32_sys_call_table sys_call_table,系统调用就放在这个表里面。

当系统调用结束之后,在entry_INT80_32之后,紧接着调用的是INTERRUPT_RETURN,定义如下

#define INTERRUPT_RETURN                iret

iret指令将原来用户态保存的现场恢复回来,包含代码段、指令指针寄存器等,这个时候用户态恢复执行。
Linux之系统调用

64位调用过程

/* The Linux/x86-64 kernel expects the system call parameters in
   registers according to the following table:
    syscall number	rax
    arg 1		rdi
    arg 2		rsi
    arg 3		rdx
    arg 4		r10
    arg 5		r8
    arg 6		r9
......
*/
#define DO_CALL(syscall_name, args)					      \
  lea SYS_ify (syscall_name), %rax;					      \
  syscall
  • 将系统调用名称换成系统调用号,放到寄存器rax
  • 这里是真正进行调用,不用中断了,改用syscall指令。
  • 传递参数的寄存器也变了

syscall指令还使用了一种特殊的寄存器,特殊模块寄存器(MSR),这种寄存器是CPU为了完成某些特殊控制功能为目的的寄存器,其中就有系统调用。

系统初始化的时候,trap_init 初始化了上面的中断模式,还会调用cpu_init->syscall_init,里面有这样的代码

wrmsrl(MSR_LSTAR, (unsigned long)entry_SYSCALL_64);

rdmsr和wrmsrl是用来读写特殊模块寄存器的,MSR_LSTAR是一个特殊的寄存器,当syscalll指令调用的时候,会从这个寄存器里面拿出函数地址来调用,也就是调用entry_SYSCALL_64。

在arch/x86/entry/entry_64.S 中定义了 entry_SYSCALL_64。

ENTRY(entry_SYSCALL_64)
        /* Construct struct pt_regs on stack */
        pushq   $__USER_DS                      /* pt_regs->ss */
        pushq   PER_CPU_VAR(rsp_scratch)        /* pt_regs->sp */
        pushq   %r11                            /* pt_regs->flags */
        pushq   $__USER_CS                      /* pt_regs->cs */
        pushq   %rcx                            /* pt_regs->ip */
        pushq   %rax                            /* pt_regs->orig_ax */
        pushq   %rdi                            /* pt_regs->di */
        pushq   %rsi                            /* pt_regs->si */
        pushq   %rdx                            /* pt_regs->dx */
        pushq   %rcx                            /* pt_regs->cx */
        pushq   $-ENOSYS                        /* pt_regs->ax */
        pushq   %r8                             /* pt_regs->r8 */
        pushq   %r9                             /* pt_regs->r9 */
        pushq   %r10                            /* pt_regs->r10 */
        pushq   %r11                            /* pt_regs->r11 */
        sub     $(6*8), %rsp                    /* pt_regs->bp, bx, r12-15 not saved */
        movq    PER_CPU_VAR(current_task), %r11
        testl   $_TIF_WORK_SYSCALL_ENTRY|_TIF_ALLWORK_MASK, TASK_TI_flags(%r11)
        jnz     entry_SYSCALL64_slow_path
......
entry_SYSCALL64_slow_path:
        /* IRQs are off. */
        SAVE_EXTRA_REGS
        movq    %rsp, %rdi
        call    do_syscall_64           /* returns with IRQs disabled */
return_from_SYSCALL_64:
	RESTORE_EXTRA_REGS
	TRACE_IRQS_IRETQ
	movq	RCX(%rsp), %rcx
	movq	RIP(%rsp), %r11
    movq	R11(%rsp), %r11
......
syscall_return_via_sysret:
	/* rcx and r11 are already restored (see code above) */
	RESTORE_C_REGS_EXCEPT_RCX_R11
	movq	RSP(%rsp), %rsp
	USERGS_SYSRET64

这里先保存了很多寄存器到pt_regs结构里面,例如用户态的代码段、数据段、保存参数的寄存器,然后调用entry_SYSCALL64_slow_pat->do_syscall_64

__visible void do_syscall_64(struct pt_regs *regs)
{
        struct thread_info *ti = current_thread_info();
        unsigned long nr = regs->orig_ax;
......
        if (likely((nr & __SYSCALL_MASK) < NR_syscalls)) {
                regs->ax = sys_call_table[nr & __SYSCALL_MASK](
                        regs->di, regs->si, regs->dx,
                        regs->r10, regs->r8, regs->r9);
        }
        syscall_return_slowpath(regs);
}

在do_syscall_64里面,从rax里面拿出系统调用号,然后根据系统调用号,在系统调用表sys_call_table中找到相应的函数进行调用,并将寄存器中保存的参数取出来,作为函数参数

系统调用返回的时候,执行的是USERGS_SYSRET64,定义如下

#define USERGS_SYSRET64				\
	swapgs;					\
	sysretq;

返回用户态的指令变成了sysretq。å

无论是32位,还是64位,都会到系统调用表sys_call_table这里来。
Linux之系统调用

系统调用表

32位的系统调用表定义在arch/x86/entry/syscalls/syscall_32.tbl 文件里,例如 open定义如下:

5	i386	open			sys_open  compat_sys_open

64 位的系统调用定义在另一个文件 arch/x86/entry/syscalls/syscall_64.tbl 里。例如 open 定义如下:

2	common	open			sys_open
  • 第一列的数字是系统调用号,32和64位系统调用号是不一样的
  • 第三列是系统调用的名字
  • 第四列是系统调用再内核的实现函数

系统调用在内核中的实现要有一个声明,声明往往在include/linux/syscalls.h 文件中,sys_open的声明如下:

asmlinkage long sys_open(const char __user *filename,
                                int flags, umode_t mode);

实现这个系统调用的再.c文件中,例如sys_open的实现在fs/open.c里面

SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;
        return do_sys_open(AT_FDCWD, filename, flags, mode);
}

SYSCALL_DEFINE3是一个宏系统调用,最多6个参数,根据参数的数目选择宏,

#define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)
 
 
#define SYSCALL_DEFINEx(x, sname, ...)                          \
        SYSCALL_METADATA(sname, x, __VA_ARGS__)                 \
        __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
 
 
#define __PROTECT(...) asmlinkage_protect(__VA_ARGS__)
#define __SYSCALL_DEFINEx(x, name, ...)                                 \
        asmlinkage long sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))       \
                __attribute__((alias(__stringify(SyS##name))));         \
        static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__));  \
        asmlinkage long SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__));      \
        asmlinkage long SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__))       \
        {                                                               \
                long ret = SYSC##name(__MAP(x,__SC_CAST,__VA_ARGS__));  \
                __MAP(x,__SC_TEST,__VA_ARGS__);                         \
                __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__));       \
                return ret;                                             \
        }                                                               \
        static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__)

如果我们把宏展开之后,实现如下,和声明的是一样的。

asmlinkage long sys_open(const char __user * filename, int flags, int mode)
{
 long ret;
 
 
 if (force_o_largefile())
  flags |= O_LARGEFILE;
 
 
 ret = do_sys_open(AT_FDCWD, filename, flags, mode);
 asmlinkage_protect(3, ret, filename, flags, mode);
 return ret;

声明和实现都好了。

  • 在编译的过程中,需要根据 syscall_32.tbl 和 syscall_64.tbl 生成自己的 unistd_32.h 和 unistd_64.h。生成方式在 arch/x86/entry/syscalls/Makefile 中。
  • 这里面会使用两个脚本,其中第一个脚本 arch/x86/entry/syscalls/syscallhdr.sh,会在文件中生成 #define __NR_open
  • 第二个脚本 arch/x86/entry/syscalls/syscalltbl.sh,会在文件中生成 __SYSCALL(__NR_open, sys_open)。
  • unistd_32.h 和 unistd_64.h 是对应的系统调用号和系统调用实现函数之间的对应关系。

在文件 arch/x86/entry/syscall_32.c,定义了这样一个表,里面 include 了这个头文件,从而所有的 sys_ 系统调用都在这个表里面了。

__visible const sys_call_ptr_t ia32_sys_call_table[__NR_syscall_compat_max+1] = {
        /*
         * Smells like a compiler bug -- it doesn't work
         * when the & below is removed.
         */
        [0 ... __NR_syscall_compat_max] = &sys_ni_syscall,
#include <asm/syscalls_32.h>
};

同理,在文件 arch/x86/entry/syscall_64.c,定义了这样一个表,里面 include 了这个头文件,这样所有的 sys_ 系统调用就都在这个表里面了。

/* System call table for x86-64. */
asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = {
	/*
	 * Smells like a compiler bug -- it doesn't work
	 * when the & below is removed.
	 */
	[0 ... __NR_syscall_max] = &sys_ni_syscall,
#include <asm/syscalls_64.h>
};

总结

Linux之系统调用

上一篇:xenomai内核解析之双核系统调用(一)


下一篇:/etc/hosts文件设置不对导致Jboss启动失败