SO2 课程 02——系统调用

System Calls

Linux 系统调用实现
VDSO and 虚拟系统调用
通过系统调用访问用户空间

System Calls as Kernel services

+-------------+           +-------------+
|   应用程序   |           |   应用程序   |
+-------------+           +-------------+
  |                           |
  |read(fd, buff, len)        |fork()
  |                           |
  v                           v
+---------------------------------------+
|                 内核                  |
+---------------------------------------+

System Call Setup

用于识别系统调用及其参数的设置信息
触发内核模式切换
获取系统调用的结果

Linux system call setup

系统调用通过数字进行标识
系统调用的参数为机器字大小（32 位或 64 位）并且最多可以有6个系统调用参数。
使用寄存器同时存储它们（例如，对于 32 位 x86 架构：系统调用标识符使用 EAX 寄存器，参数使用 EBX、ECX、EDX、ESI、EDI 和 EBP 寄存器）。

Example of Linux system call setup and handling

     +-------------+   dup2    +-----------------------------+
     |   应用程序   |-----+     |  libc                       |
     +-------------+     |     |                             |
                         +---->| C7590 dup2:                 |
                               | ...                         |
                               | C7592 movl 0x8(%esp),%ecx   |
                               | C7596 movl 0x4(%esp),%ebx   |
                               | C759a movl $0x3f,%eax       |
+------------------------------+ C759f int $0x80             |
|                              | ...                         +<-----+
|                              +-----------------------------+      |
|                                                                   |
|                                                                   |
|                                                                   |
|                                                                   |
|    +------------------------------------------------------------+ |
|    |                         内核                               | |
|    |                                                            | |
+--->|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_int80_syscall_32                                 | |
     | ....                                                       | |
     | RESTORE_REGS 4                  # skip orig_eax/error_code | |
     | ...                                                        | |
     | INTERRUPT_RETURN                                           +-+
     +------------------------------------------------------------+

Linux System Call Dispatcher

/* 处理（handle）int $0x80 */
__visible void do_int80_syscall_32(struct pt_regs *regs)
{
    enter_from_user_mode();
    local_irq_enable();
    do_syscall_32_irqs_on(regs);
}

/* Linux x86 32 位系统调用分发器的简化版本 */
static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs)
{
    unsigned int nr = regs->orig_ax;

    if (nr < IA32_NR_syscalls)
        regs->ax = ia32_sys_call_table[nr](regs->bx, regs->cx,
                                           regs->dx, regs->si,
                                           regs->di, regs->bp);
    syscall_return_slowpath(regs);
}

Inspecting dup2 system call

System Call Flow Summary

应用程序设置系统调用编号和参数，并触发陷阱（trap）指令
执行模式从用户模式切换到内核模式；CPU 切换到内核堆栈；用户堆栈和返回地址保存在内核堆栈中
内核入口点将寄存器保存在内核堆栈中
系统调用分发器识别系统调用函数并运行它
恢复用户空间寄存器并切换回用户空间（例如，调用 IRET 指令）
用户空间应用程序恢复执行

System Call Table

#define __SYSCALL_I386(nr, sym, qual) [nr] = sym,

const sys_call_ptr_t ia32_sys_call_table[] = {
  [0 ... __NR_syscall_compat_max] = &sys_ni_syscall,
  #include <asm/syscalls_32.h>
};

__SYSCALL_I386(0, sys_restart_syscall)
__SYSCALL_I386(1, sys_exit)
__SYSCALL_I386(2, sys_fork)
__SYSCALL_I386(3, sys_read)
__SYSCALL_I386(4, sys_write)
#ifdef CONFIG_X86_32
__SYSCALL_I386(5, sys_open)
#else
__SYSCALL_I386(5, compat_sys_open)
#endif
__SYSCALL_I386(6, sys_close)

系统调用指针参数

绝不允许指向内核空间的指针
检查无效指针

指向内核空间的指针

如果允许指向内核空间的指针存在，那么用户会通过写入系统调用访问内核数据
如果允许指向内核空间的指针存在，那么用户会通过读取系统调用破坏内核数据

处理无效指针的方法

在使用指针之前对照用户地址空间检查指针，或者
避免检查指针，并依赖于内存管理单元（MMU）来检测指针是否无效，并使用页面故障处理程序确定指针是否无效

页面故障处理

写时复制（Copy on Write）、需求分页（demand paging）、交换（swapping）：故障地址和引发故障的地址都在用户空间；故障地址有效（在用户地址空间进行检查）。

在系统调用中使用无效指针：引发故障的地址在内核空间；故障地址在用户空间且无效。

内核错误（内核访问无效指针）：与上述情况相同。

标记访问用户空间的内核代码

访问用户空间的确切指令被记录在一个表格中（异常表）
当发生页故障时，会用该表格检查引发故障的地址

指针检查与故障处理的成本分析

成本	指针检查	故障处理
有效地址	地址空间搜索	可忽略的
无效地址	地址空间搜索	异常表搜索

虚拟动态共享对象（VDSO）

内核在一个特殊的内存区域生成一系列用来触发系统调用的指令（格式化为 ELF 共享对象）
该内存区域映射到用户地址空间的末尾
libc 搜索 VDSO，如果存在，则使用它来发出系统调用

检查 VDSO

虚拟系统调用（vsyscalls）

直接从用户空间运行的“系统调用”，属于 VDSO 的一部分
静态数据（例如，getpid（））
内核通过VDSO的读写映射进行动态数据更新（例如，gettimeofday（），time（））

通过系统调用访问用户空间

/* 如果 user_ptr 无效，则返回 -EFAULT */
if (copy_from_user(&kernel_buffer, user_ptr, size))
    return -EFAULT;

/* 只有当 user_ptr 有效时才能工作，否则会导致内核崩溃 */
memcpy(&kernel_buffer, user_ptr, size);

get_user 实现

#define get_user(x, ptr)                                          \
({                                                                \
  int __ret_gu;                                                   \
  register __inttype(*(ptr)) __val_gu asm("%"_ASM_DX);            \
  __chk_user_ptr(ptr);                                            \
  might_fault();                                                  \
  asm volatile("call __get_user_%P4"                              \
               : "=a" (__ret_gu), "=r" (__val_gu),                \
                  ASM_CALL_CONSTRAINT                             \
               : "0" (ptr), "i" (sizeof(*(ptr))));                \
  (x) = (__force __typeof__(*(ptr))) __val_gu;                    \
  __builtin_expect(__ret_gu, 0);                                  \
})

get_user 伪代码

#define get_user(x, ptr)                \
    movl ptr, %eax                      \
    call __get_user_1                   \
    movl %edx, x                        \
    movl %eax, result                   \

get_user_1 实现

.text
ENTRY(__get_user_1)
    mov PER_CPU_VAR(current_task), %_ASM_DX
    cmp TASK_addr_limit(%_ASM_DX),%_ASM_AX
    jae bad_get_user
    ASM_STAC
1:  movzbl (%_ASM_AX),%edx
    xor %eax,%eax
    ASM_CLAC
    ret
ENDPROC(__get_user_1)

bad_get_user:
    xor %edx,%edx
    mov $(-EFAULT),%_ASM_AX
    ASM_CLAC
    ret
END(bad_get_user)

_ASM_EXTABLE(1b,bad_get_user)

异常表条目

/* 异常表条目 */
# define _ASM_EXTABLE_HANDLE(from, to, handler)           \
  .pushsection "__ex_table","a" ;                         \
  .balign 4 ;                                             \
  .long (from) - . ;                                      \
  .long (to) - . ;                                        \
  .long (handler) - . ;                                   \
  .popsection

# define _ASM_EXTABLE(from, to)                           \
  _ASM_EXTABLE_HANDLE(from, to, ex_handler_default)

异常表构建

#define EXCEPTION_TABLE(align)                                    \
  . = ALIGN(align);                                               \
  __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {               \
          VMLINUX_SYMBOL(__start___ex_table) = .;                 \
          KEEP(*(__ex_table))                                     \
          VMLINUX_SYMBOL(__stop___ex_table) = .;                  \
  }

异常表处理

bool ex_handler_default(const struct exception_table_entry *fixup,
                        struct pt_regs *regs, int trapnr)
{
    regs->ip = ex_fixup_addr(fixup);
    return true;
}

int fixup_exception(struct pt_regs *regs, int trapnr)
{
    const struct exception_table_entry *e;
    ex_handler_t handler;

    e = search_exception_tables(regs->ip);
    if (!e)
        return 0;

    handler = ex_fixup_handler(e);
    return handler(e, regs, trapnr);
}