这篇文章介绍 linux 操作系统中的系统调用。有一个新增系统调用的实验，实验下来还是非常有趣的。

系统调用是操作系统为应用程序提供的一种接口，使得应用程序可以利用这个接口请求操作系统为其提供服务。在现代操作系统中，内核空间和用户空间是分开的。内核空间可以访问硬件资源和所有内存，而用户空间的权限则较低，不能直接访问硬件资源和内核内存。这种设计可以保护硬件资源和内核内存不被恶意或者错误的用户程序破坏。

系统调用步骤

在 ARM 上，执行系统调用会大体经历以下步骤：

1. 调用系统调用指令。ARM 上是 SVC #0 指令。该指令会触发一个同步异常。

2. 触发异常处理。触发同步异常后，会根据异常向量表调用对应的异常处理函数。

3. 分派系统调用。同步异常处理函数中会根据发生的异常类型分派具体的处理函数，此处为 SVC 异常。

4. 执行系统调用。系统调用处理函数中会通过寄存器中的值获取系统调用号，然后通过查找系统调用表来找到对应的系统调用函数，并执行。

5. 返回用户空间：系统调用执行完毕后，恢复上下文环境并返回到用户空间，系统调用结束。

下面我们在 ARM Linux 源码中，找寻一下以上步骤的关键点信息。

异常向量表

异常向量表在 arch/arm64/kernel/entry.S 中定义。SVC 指令对应的异常处理函数为 el0_sync。

• ENTRY(vectors)
•     kernel_ventry 1, sync_invalid          // Synchronous EL1t
•     kernel_ventry 1, irq_invalid           // IRQ EL1t
•     kernel_ventry 1, fiq_invalid           // FIQ EL1t
•     kernel_ventry 1, error_invalid     // Error EL1t
•  
•     kernel_ventry 1, sync             // Synchronous EL1h
•     kernel_ventry 1, irq              // IRQ EL1h
•     kernel_ventry 1, fiq_invalid           // FIQ EL1h
•     kernel_ventry 1, error        // Error EL1h
•  
•     kernel_ventry 0, sync             // Synchronous 64-bit EL0
•     kernel_ventry 0, irq              // IRQ 64-bit EL0
•     kernel_ventry 0, fiq_invalid           // FIQ 64-bit EL0
•     kernel_ventry 0, error        // Error 64-bit EL0
•  
• #ifdef CONFIG_COMPAT
•     kernel_ventry 0, sync_compat, 32       // Synchronous 32-bit EL0
•     kernel_ventry 0, irq_compat, 32    // IRQ 32-bit EL0
•     kernel_ventry 0, fiq_invalid_compat, 32 // FIQ 32-bit EL0
•     kernel_ventry 0, error_compat, 32       // Error 32-bit EL0
• #else
•     kernel_ventry 0, sync_invalid, 32       // Synchronous 32-bit EL0
•     kernel_ventry 0, irq_invalid, 32       // IRQ 32-bit EL0
•     kernel_ventry 0, fiq_invalid, 32       // FIQ 32-bit EL0
•     kernel_ventry 0, error_invalid, 32      // Error 32-bit EL0
• #endif
• END(vectors)

el0_sync 也同样定义在 arch/arm64/kernel/entry.S 中。

异常发生后，异常的具体信息会被存放在一个叫做 ESR_ELx 的寄存器中。

在 ESR_ELx 寄存器的值中，有一部分位被用来表示异常的类别，即“异常类”。这部分位在 ESR_ELx 寄存器中的偏移，即是源码中指定的 #ESR_ELx_EC_SHIFT。

我们比较“异常类”的值，如果为 #ESR_ELx_EC_SVC64，即为 ARM64 中的 SVC 异常。会跳转到 el0_svc 处理程序。

• el0_sync:
•     kernel_entry 0
•     mrs x25, esr_el1         // read the syndrome register
•     lsr x24, x25, #ESR_ELx_EC_SHIFT   // exception class
•     cmp x24, #ESR_ELx_EC_SVC64    // SVC in 64-bit state
•     b.eq el0_svc

系统调用表

el0_svc 会调用 el0_svc_handler，el0_svc_handler 在 arch/arm64/kernel/syscall.c 中定义。

从源码中我们可以看到，SVC 处理函数会从 regs->regs[8] 中获取系统调用号，并根据 sys_call_table 系统调用表查找系统调用并执行。

• asmlinkage void el0_svc_handler(struct pt_regs* regs)
• {
•     sve_user_discard();
•     el0_svc_common(regs, regs->regs[8], __NR_syscalls, sys_call_table);
• }

系统调用表 sys_call_table 定义在 arch/arm64/kernel/sys.c 中。如源码所示，第一次包含 asm/unistd.h，会声明系统函数；第二次包含会声明系统调用表 sys_call_table 中的各个表项。

1. #undef __SYSCALL
2. #define __SYSCALL(nr, sym) asmlinkage long __arm64_##sym(const struct pt_regs *);
3. #include <asm/unistd.h>
4.  
5. #undef __SYSCALL
6. #define __SYSCALL(nr, sym) [nr] = (syscall_fn_t)__arm64_##sym,
7.  
8. const syscall_fn_t sys_call_table[__NR_syscalls] = {
9.     [0 ... __NR_syscalls - 1] = (syscall_fn_t)sys_ni_syscall,
10. #include <asm/unistd.h>

头文件 arch/arm64/include/asm/unistd.h 会引用到 arch/arm64/include/uapi/asm/unistd.h，最终引用到 include/uapi/asm-generic/unistd.h。

我们看其中对 __SYSCALL 宏的使用。以 read 系统调用为例，__NR_read 63 是它的系统调用号，结合 sys_read 用于 __SYSCALL 宏的展开。

1. /* fs/readdir.c */
2. #define __NR_getdents64 61
3. __SYSCALL(__NR_getdents64, sys_getdents64)
4.  
5. /* fs/read_write.c */
6. #define __NR3264_lseek 62
7. __SC_3264(__NR3264_lseek, sys_llseek, sys_lseek)
8. #define __NR_read 63
9. __SYSCALL(__NR_read, sys_read)
10. #define __NR_write 64
11. __SYSCALL(__NR_write, sys_write)

调用函数

还是以 read 系统调用为例，从前面的内容我们知道，最终 read 系统调用对应的处理函数为 __arm64_sys_read。__arm64_sys_read 通过 SYSCALL_DEFINE3 宏定义在 fs/read_write.c 中。

• SYSCALL_DEFINE3(read, unsigned int, fd, char __user*, buf, size_t, count)
• {
•     return ksys_read(fd, buf, count);
• }

SYSCALL_DEFINE3 宏定义在 include/linux/syscalls.h 中。它会创建关于系统调用的元数据，然后创建实际的系统调用函数。

1. #define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
2. #define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
3. #define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
4. #define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
5. #define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
6. #define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)
7.  
8. #define SYSCALL_DEFINE_MAXARGS 6
9.  
10. #define SYSCALL_DEFINEx(x, sname, ...)             \
11.     SYSCALL_METADATA(sname, x, __VA_ARGS__)        \
12.     __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)

SYSCALL_DEFINE3 宏展开的实际内容非常繁琐，我们直接查看编译器最终展开的内容。以下内容我对展开内容做了格式规范化，便于查看。可以看到上部分是各种元数据的定义，下半部分是系统调用函数函数。此处的 __arm64_sys_read 会调用 __se_sys_read，然后调用 __do_sys_read，最终调用到 ksys_read。

1. static const char* types__read[] = { "unsigned int", "char *", "size_t" };
2. static const char* args__read[] = { "fd", "buf", "count" };
3.  
4. static struct syscall_metadata __syscall_meta__read;
5.  
6. static struct trace_event_call __attribute__((__used__)) event_enter__read = {
7.     .class = &event_class_syscall_enter,
8.     {.name = "sys_enter""_read", },
9.     .event.funcs = &enter_syscall_print_funcs,
10.     .data = (void*)&__syscall_meta__read,
11.     .flags = TRACE_EVENT_FL_CAP_ANY,
12. };
13.  
14. static struct trace_event_call __attribute__((__used__)) __attribute__((section("_ftrace_events")))* __event_enter__read = &event_enter__read;;
15.  
16. static struct syscall_metadata __syscall_meta__read;
17.  
18. static struct trace_event_call __attribute__((__used__)) event_exit__read = {
19.     .class = &event_class_syscall_exit,
20.     {.name = "sys_exit""_read", },
21.     .event.funcs = &exit_syscall_print_funcs,
22.     .data = (void*)&__syscall_meta__read,
23.     .flags = TRACE_EVENT_FL_CAP_ANY,
24. };
25.  
26. static struct trace_event_call __attribute__((__used__)) __attribute__((section("_ftrace_events")))* __event_exit__read = &event_exit__read;;
27.  
28. static struct syscall_metadata __attribute__((__used__)) __syscall_meta__read = {
29.     .name = "sys""_read",
30.     .syscall_nr = -1,
31.     .nb_args = 3,
32.     .types = 3 ? types__read : ((void*)0),
33.     .args = 3 ? args__read : ((void*)0),
34.     .enter_event = &event_enter__read,
35.     .exit_event = &event_exit__read,
36.     .enter_fields = { &(__syscall_meta__read.enter_fields), &(__syscall_meta__read.enter_fields) },
37. };
38.  
39. static struct syscall_metadata __attribute__((__used__)) __attribute__((section("__syscalls_metadata")))* __p_syscall_meta__read = &__syscall_meta__read;
40.  
41. long __arm64_sys_read(const struct pt_regs* regs);
42.  
43. static long __se_sys_read(
44.     __typeof(
45.         __builtin_choose_expr(
46.             (__builtin_types_compatible_p(typeof((unsigned int)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((unsigned int)0), typeof(0ULL))),
47.             0LL, 0L
48.         )
49.     ) fd,
50.     __typeof(
51.         __builtin_choose_expr(
52.             (__builtin_types_compatible_p(typeof((char*)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((char*)0), typeof(0ULL))),
53.             0LL, 0L
54.         )
55.     ) buf,
56.     __typeof(
57.         __builtin_choose_expr(
58.             (__builtin_types_compatible_p(typeof((size_t)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((size_t)0), typeof(0ULL))),
59.             0LL, 0L
60.         )
61.     ) count
62. );
63.  
64. static inline __attribute__((__always_inline__)) __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0))) long __do_sys_read(unsigned int fd, char* buf, size_t count);
65.  
66. long __arm64_sys_read(const struct pt_regs* regs) {
67.     return __se_sys_read(regs->regs[0], regs->regs[1], regs->regs[2]);
68. }
69.  
70. static long __se_sys_read(
71.     __typeof(
72.         __builtin_choose_expr(
73.             (__builtin_types_compatible_p(typeof((unsigned int)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((unsigned int)0), typeof(0ULL))),
74.             0LL, 0L
75.         )
76.     ) fd,
77.     __typeof(
78.         __builtin_choose_expr(
79.             (__builtin_types_compatible_p(typeof((char*)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((char*)0), typeof(0ULL))),
80.             0LL, 0L
81.         )
82.     ) buf,
83.     __typeof(
84.         __builtin_choose_expr(
85.             (__builtin_types_compatible_p(typeof((size_t)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((size_t)0), typeof(0ULL))),
86.             0LL, 0L
87.         )
88.     ) count
89. ) {
90.     long ret = __do_sys_read((unsigned int)fd, (char*)buf, (size_t)count);
91.     (void)(
92.         sizeof(struct {
93.         int:(-!!(!(__builtin_types_compatible_p(typeof((unsigned int)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((unsigned int)0), typeof(0ULL))) && sizeof(unsigned int) > sizeof(long)));
94.     }),
95.         sizeof(struct {
96.         int:(-!!(!(__builtin_types_compatible_p(typeof((char*)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((char*)0), typeof(0ULL))) && sizeof(char*) > sizeof(long)));
97.     }),
98.         sizeof(struct {
99.         int:(-!!(!(__builtin_types_compatible_p(typeof((size_t)0), typeof(0LL)) || __builtin_types_compatible_p(typeof((size_t)0), typeof(0ULL))) && sizeof(size_t) > sizeof(long)));
100.     })
101.         );
102.     do {} while (0);
103.     return ret;
104. }
105.  
106. static inline __attribute__((__always_inline__)) __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0))) long __do_sys_read(unsigned int fd, char* buf, size_t count)
107. {
108.     return ksys_read(fd, buf, count);
109. }

实验

通过上节内容，我们已经对 linux 系统调用的流程有了基本的认识。现在我们在系统中添加一个系统调用，以获取当前进程的 PID 和 UID。

首先我们在 include/uapi/asm-generic/unistd.h 中，在系统编号的最后，添加我们的系统调用。如代码清单 1 所示，这边将新的系统调用命名为 getpuid。添加之后，这个调用声明就添加到系统调用表中了。

1. #define __NR_getpuid 295
2. __SYSCALL(__NR_getpuid, sys_getpuid)
3.  
4. #undef __NR_syscalls
5. #define __NR_syscalls 296

有了系统调用的声明，我们将系统调用的实现放在 arch/arm64/kernel/sys.c 中。如代码清单 2 所示，因为需要两个参数，所以使用 SYSCALL_DEFINE2 宏来定义实现。

1. SYSCALL_DEFINE2(getpuid, pid_t* __user, pid, uid_t* __user, uid)
2. {
3.     pid_t tmp_pid;
4.     uid_t tmp_uid;
5.  
6.     if (pid == NULL && uid == NULL)
7.         return -EINVAL;
8.  
9.     printk("%s: pid=%p, uid=%p\n", __func__, pid, uid);
10.  
11.     if (pid != NULL)
12.     {
13.         tmp_pid = task_tgid_vnr(current);
14.         if (put_user(tmp_pid, pid))
15.             return -EFAULT;
16.         printk("%s: pid=%d\n", __func__, tmp_pid);
17.     }
18.  
19.     if (uid != NULL)
20.     {
21.         tmp_uid = from_kuid_munged(current_user_ns(), current_uid());
22.         if (put_user(tmp_uid, uid))
23.             return -EFAULT;
24.         printk("%s: uid=%d\n", __func__, tmp_uid);
25.     }
26.  
27.     return 0;
28. }

以上就完成了系统调用的添加。我们需要重新编译 linux 源码。

编译并运行新系统之后，我们编写测试程序。如代码清单 3 所示，核心是使用 syscall 标准库函数。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <errno.h>
5.  
6. int main()
7. {
8.     long pid, uid;
9.     int ret;
10.  
11.     ret = (int)syscall(295, &pid, &uid);
12.     if (ret != 0)
13.     {
14.         printf("call getpuid failed\n");
15.         return 1;
16.     }
17.  
18.     printf("call getpuid success, return pid = %d, uid = %d\n", pid, uid);
19.  
20.     while (1)
21.         sleep(1);
22.     return 0;
23. }

小插曲

书上在内核中的操作是直接解引用赋值传入的用户态变量地址。不知道为什么书作者运行无误，自己实验下来遇到以下内核奔溃。

更改使用 put_user 函数后，运行无误。