1
# 查看你的系统是否支持 syscall 指令
2
grep -o 'syscall' /proc/cpuinfo | head -1 && echo "支持 syscall"

1
// glibc: sysdeps/unix/sysv/linux/x86_64/syscall.S（简化版）
2
ssize_t write(int fd, const void *buf, size_t count)
3
{
4
    // 将系统调用号存入 rax
5
    // 将参数按约定存入寄存器
6
    // 执行 syscall 指令
7
    // 检查返回值，设置 errno
8

9
    register long rax __asm__("rax") = __NR_write;  // 系统调用号 1
10
    register long rdi __asm__("rdi") = fd;
11
    register long rsi __asm__("rsi") = (long)buf;
12
    register long rdx __asm__("rdx") = count;
13

14
    __asm__ volatile ("syscall"
15
        : "+r" (rax)
16
        : "r" (rdi), "r" (rsi), "r" (rdx)
17
        : "memory", "rcx", "r11");
18

19
    // 返回值处理：负值表示错误
20
    if (rax < 0) {
21
        errno = -rax;
22
        return -1;
23
    }
24
    return rax;
25
}

1
# 查看你的系统上 syscall 入口地址
2
sudo rdmsr -d 0xC0000082    # 读取 IA32_LSTAR MSR

1
// arch/x86/entry/entry_64.S（简化版）
2
SYM_CODE_START(entry_SYSCALL_64)
3
    swapgs                          // 切换 GS 基址到内核 GS
4
    movq    %rsp, %gs:cpu_current_top_of_stack  // 保存用户态栈指针
5
    movq    %gs:cpu_current_top_of_stack, %rsp  // 切换到内核栈
6

7
    // 保存用户态寄存器到内核栈上的 pt_regs 结构
8
    pushq   $__USER_DS             // pt_regs->ss
9
    pushq   PER_CPU_VAR(cpu_current_top_of_stack)  // pt_regs->sp
10
    pushq   %r11                   // pt_regs->flags (从 syscall 保存的 R11)
11
    pushq   $__USER_CS             // pt_regs->cs
12
    pushq   %rcx                   // pt_regs->ip (从 syscall 保存的 RCX)
13
    pushq   $-1                    // pt_regs->orig_ax (占位，标记系统调用)
14
    pushq   %rdi                   // 保存参数寄存器
15
    pushq   %rsi
16
    pushq   %rdx
17
    pushq   %r10                   // 注意：r10 而非 rcx（rcx 已被 syscall 使用）
18
    pushq   %r8
19
    pushq   %r9
20

21
    // 切换到内核栈后，调用 C 函数
22
    movq    %rsp, %rdi             // 第一个参数: pt_regs 指针
23
    call    do_syscall_64           // 进入 C 代码
24
SYM_CODE_END(entry_SYSCALL_64)

1
// arch/x86/entry/common.c（简化版）
2
__visible noinstr void do_syscall_64(struct pt_regs *regs, int nr)
3
{
4
    // 安全检查：系统调用号是否合法
5
    if (likely(nr < NR_syscalls)) {
6
        nr = array_index_nospec(nr, NR_syscalls);
7
        // 从分派表中查找并调用对应的内核函数
8
        regs->ax = sys_call_table[nr](regs);
9
    } else {
10
        regs->ax = __x64_sys_ni_syscall(regs);  // 返回 -ENOSYS
11
    }
12
}

1
// fs/read_write.c（简化版）
2
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf, size_t, count)
3
{
4
    struct fd f = fdget_pos(fd);
5
    ssize_t ret = -EBADF;
6

7
    if (f.file) {
8
        loff_t pos = file_pos_read(f.file);
9
        ret = vfs_write(f.file, buf, count, &pos);
10
        file_pos_write(f.file, pos);
11
        fdput_pos(f);
12
    }
13
    return ret;
14
}

1
// include/uapi/asm-generic/unistd.h（部分示例）
2
#define __NR_io_setup       0
3
#define __NR_io_destroy     1
4
#define __NR_io_submit      2
5
#define __NR_io_cancel      3
6
#define __NR_io_getevents   4
7
#define __NR_setxattr       5
8
#define __NR_lsetxattr      6
9
#define __NR_fsetxattr      7
10
#define __NR_getxattr       8
11
// ...
12
#define __NR_write          1
13
#define __NR_read           0
14
#define __NR_open           2
15
#define __NR_close          3

1
#include <sys/syscall.h>
2
#include <stdio.h>
3

4
int main() {
5
    printf("NR_read  = %ld\n", __NR_read);    // 0
6
    printf("NR_write = %ld\n", __NR_write);   // 1
7
    printf("NR_open  = %ld\n", __NR_open);    // 2
8
    printf("NR_close = %ld\n", __NR_close);   // 3
9
    printf("NR_fork  = %ld\n", __NR_fork);    // 57
10
    printf("NR_execve= %ld\n", __NR_execve);  // 59
11
    return 0;
12
}

1
// include/generated/asm/syscalls_64.h（自动生成，部分示例）
2
[0] = __x64_sys_read,
3
[1] = __x64_sys_write,
4
[2] = __x64_sys_open,
5
[3] = __x64_sys_close,
6
// ... 约 400+ 个条目

1
# 查看当前内核支持的系统调用数量
2
grep -c __x64_sys_ /boot/System.map-$(uname -r)
3

4
# 查看所有系统调用符号
5
grep __x64_sys_ /proc/kallsyms | head -20

1
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
2
//     rdi        rsi        rdx      r10      r8     r9

1
// 内核中安全访问用户空间内存的方式
2
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf, size_t, count)
3
{
4
    // __user 标注表明这是用户空间指针
5
    // copy_from_user() 会做地址合法性检查
6
    // 如果指针非法，返回非零值（表示未拷贝的字节数）
7
}

1
// 对比：系统调用 vs 函数调用
2
#include <sys/syscall.h>
3
#include <unistd.h>
4
#include <time.h>
5

6
#define ITERATIONS 1000000
7

8
int main() {
9
    struct timespec start, end;
10

11
    // 测试 1: 系统调用 getpid()
12
    clock_gettime(CLOCK_MONOTONIC, &start);
13
    for (int i = 0; i < ITERATIONS; i++) {
14
        syscall(__NR_getpid);
15
    }
16
    clock_gettime(CLOCK_MONOTONIC, &end);
17
    double sys_time = (end.tv_sec - start.tv_sec) * 1e9 +
18
                      (end.tv_nsec - start.tv_nsec);
19

20
    // 测试 2: 普通函数调用
21
    clock_gettime(CLOCK_MONOTONIC, &start);
22
    for (int i = 0; i < ITERATIONS; i++) {
23
        getpid();  // glibc 可能缓存了结果，不会每次都系统调用
24
    }
25
    clock_gettime(CLOCK_MONOTONIC, &end);
26
    double func_time = (end.tv_sec - start.tv_sec) * 1e9 +
27
                       (end.tv_nsec - start.tv_nsec);
28

29
    printf("syscall(__NR_getpid): %.1f ns/call\n", sys_time / ITERATIONS);
30
    printf("getpid() (glibc):     %.1f ns/call\n", func_time / ITERATIONS);
31
    return 0;
32
}

1
用户空间地址布局：
2
0xffffffffff600000 ┌─────────────────────┐
3
                   │  vsyscall 页面       │
4
                   │  - gettimeofday()    │
5
                   │  - time()            │
6
                   │  - getcpu()          │
7
0xffffffffff601000 └─────────────────────┘

1
# 查看 VDSO 在进程地址空间中的映射
2
cat /proc/self/maps | grep vdso
3
# 输出示例：
4
# 7f8e4a7fe000-7f8e4a7ff000 r-xp 00000000 00:00 0    [vdso]
5

6
# 查看 VDSO 导出的符号
7
readelf -s /proc/self/exe 2>/dev/null | grep -i vdso
8
# 或者
9
objdump -T /lib64/ld-linux-x86-64.so.2 | grep vdso

1
# 对比 VDSO 加速前后的 gettimeofday 性能
2
# 测试 1: 通过 VDSO（默认路径）
3
strace -c -e trace=gettimeofday ./test_gettime
4

5
# 测试 2: 绕过 VDSO，强制走系统调用
6
# 设置环境变量禁用 VDSO
7
LD_PRELOAD=/path/to/disable_vdso.so ./test_gettime

1
int ioctl(int fd, unsigned long request, ...);

1
  方向   |  大小   |   类型   |   编号
2
 (2 bit) | (14bit) | (8 bit)  | (8 bit)

1
// 构造 ioctl 请求码的宏
2
#define _IO(type, nr)           // 无数据传输
3
#define _IOR(type, nr, datatype) // 从内核读数据
4
#define _IOW(type, nr, datatype) // 向内核写数据
5
#define _IOWR(type, nr, datatype) // 双向数据传输
6

7
// 示例：终端相关的 ioctl
8
#define TCGETS  _IOR('T', 0x01, struct termios)  // 获取终端属性
9
#define TCSETS  _IOW('T', 0x02, struct termios)  // 设置终端属性

1
# 编译内核
2
make -j$(nproc)
3

4
# 在 QEMU 中启动新内核
5
qemu-system-x86_64 -kernel arch/x86/boot/bzImage -m 512M
6

7
# 编写测试程序
8
cat > test_hello.c << 'EOF'
9
#include <sys/syscall.h>
10
#include <stdio.h>
11
#include <unistd.h>
12

13
int main() {
14
    long ret = syscall(451, "Hello from userspace!");
15
    if (ret < 0) {
16
        perror("syscall failed");
17
        return 1;
18
    }
19
    printf("syscall returned %ld\n", ret);
20
    return 0;
21
}
22
EOF
23

24
gcc -o test_hello test_hello.c
25
./test_hello
26

27
# 查看内核日志
28
dmesg | grep sys_hello

1
$ strace -c ls /tmp
2
% time     seconds  usecs/call     calls    errors syscall
3
------ ----------- ----------- --------- --------- ----------------
4
 28.45    0.000324           3       102           mmap
5
 18.72    0.000213           3        72           mprotect
6
 12.34    0.000140           4        32           openat
7
  9.87    0.000112           3        34           read
8
  8.64    0.000098           3        32           close
9
  7.21    0.000082           3        28           fstat
10
  5.43    0.000062           2        30           brk
11
  ...
12
------ ----------- ----------- --------- --------- ----------------
13
100.00    0.001139                   456        12 total

1
$ strace -e trace=openat cat /etc/hosts
2
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
4
openat(AT_FDCWD, "/etc/hosts", O_RDONLY) = 3
5
+++ exited with 0 +++

1
# 先找到目标进程 PID
2
pgrep -f nginx
3

4
# 追踪该进程（需要 root 权限）
5
sudo strace -p $(pgrep -f nginx | head -1) -e trace=accept,read,write

1
# 1. 统计 ls 命令的系统调用
2
strace -c ls /
3

4
# 2. 只追踪文件打开操作
5
strace -e trace=openat cat /etc/hostname
6

7
# 3. 追踪带耗时信息的系统调用
8
strace -T echo "hello"

1
# 1. 查看内核符号表中的系统调用
2
sudo cat /proc/kallsyms | grep __x64_sys_ | head -30
3

4
# 2. 统计系统调用总数
5
sudo cat /proc/kallsyms | grep -c __x64_sys_
6

7
# 3. 查看系统调用号定义
8
grep __NR_ /usr/include/asm/unistd_64.h | head -20

1
# 1. 查看 VDSO 在进程地址空间中的映射
2
cat /proc/self/maps | grep vdso
3

4
# 2. 阅读 VDSO 手册
5
man 7 vdso
6

7
# 3. 查看 VDSO 导出的函数
8
# 方法一：通过 /proc/self/maps 找到 VDSO 地址，然后 readelf
9
VDSO_ADDR=$(cat /proc/self/maps | grep vdso | head -1 | cut -d'-' -f1)
10
# 方法二：使用 ldd
11
ldd /bin/ls | grep vdso

1
#define _GNU_SOURCE
2
#include <unistd.h>
3
#include <sys/syscall.h>
4
#include <stdio.h>
5

6
int main() {
7
    char buf[256];
8
    long fd, n;
9

10
    // openat(AT_FDCWD, "/etc/hostname", O_RDONLY)
11
    fd = syscall(__NR_openat, -100, "/etc/hostname", 0);
12
    if (fd < 0) {
13
        printf("openat failed\n");
14
        return 1;
15
    }
16

17
    // read(fd, buf, sizeof(buf))
18
    n = syscall(__NR_read, fd, buf, sizeof(buf) - 1);
19
    if (n > 0) {
20
        buf[n] = '\0';
21
        // write(STDOUT_FILENO, buf, n)
22
        syscall(__NR_write, 1, buf, n);
23
    }
24

25
    // close(fd)
26
    syscall(__NR_close, fd);
27
    return 0;
28
}

1
# 1. 追踪一个网络程序的 connect 调用
2
strace -e trace=connect curl -s https://example.com > /dev/null
3

4
# 2. 追踪进程创建
5
strace -e trace=clone3,execve bash -c 'ls'
6

7
# 3. 追踪内存映射
8
strace -e trace=mmap,munmap,brk ls
9

10
# 4. 附加到运行中的进程（需要 root）
11
sudo strace -p 1 -e trace=epoll_wait -c