手动阀

在Linux系统中，系统调用是用户空间程序与内核进行交互的主要方式，以下是三种常见的方法来实现系统调用：

使用标准库函数

许多C标准库函数实际上是对系统调用的封装。open(),read(),write(),close()等函数都是通过系统调用实现的，这些函数提供了更高层次的接口，使得编程更加方便和安全。

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
int main() {
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }
    char buffer[1024];
    ssize_t bytesRead = read(fd, buffer, sizeof(buffer));
    if (bytesRead == -1) {
        perror("read");
        close(fd);
        return 1;
    }
    write(STDOUT_FILENO, buffer, bytesRead);
    close(fd);
    return 0;
}

2. 直接使用系统调用号（syscall）

在Linux中，每个系统调用都有一个唯一的系统调用号，可以使用syscall()函数来直接调用这些系统调用，这种方法需要包含头文件<sys/syscall.h>和<unistd.h>。

#define _GNU_SOURCE
#include <sys/syscall.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
int main() {
    int fd = syscall(SYS_open, "example.txt", O_RDONLY);
    if (fd == -1) {
        perror("syscall open");
        return 1;
    }
    char buffer[1024];
    ssize_t bytesRead = syscall(SYS_read, fd, buffer, sizeof(buffer));
    if (bytesRead == -1) {
        perror("syscall read");
        syscall(SYS_close, fd);
        return 1;
    }
    syscall(SYS_write, STDOUT_FILENO, buffer, bytesRead);
    syscall(SYS_close, fd);
    return 0;
}

3. 内联汇编（Inline Assembly）

在某些情况下，你可能需要直接使用内联汇编来进行系统调用，这通常用于非常底层的编程或性能优化，需要注意的是，这种方法依赖于具体的架构和ABI（应用二进制接口），因此代码的可移植性较差。

#include <unistd.h>
#include <stdio.h>
#include <sys/syscall.h>
int main() {
    int fd;
    asm volatile (
        "mov $2, %%rax\n" // SYS_open system call number for x86_64
        "mov $1, %%rdi\n" // file descriptor for standard output
        "mov %1, %%rsi\n" // pointer to the filename string
        "mov $0, %%rdx\n" // flags (O_RDONLY in this case)
        "syscall\n"
        "mov %%rax, %0\n" // store return value in fd
        : "=r" (fd)
        : "r" ("example.txt")
        : "rax", "rdi", "rsi", "rdx"
    );
    if (fd == -1) {
        perror("inline assembly open");
        return 1;
    }
    char buffer[1024];
    ssize_t bytesRead;
    asm volatile (
        "mov $0, %%rax\n" // SYS_read system call number for x86_64
        "mov %1, %%rdi\n" // file descriptor
        "mov %2, %%rsi\n" // buffer to read into
        "mov %3, %%rdx\n" // number of bytes to read
        "syscall\n"
        "mov %%rax, %0\n" // store return value in bytesRead
        : "=r" (bytesRead)
        : "r" (fd), "r" (buffer), "r" (sizeof(buffer))
        : "rax", "rdi", "rsi", "rdx"
    );
    if (bytesRead == -1) {
        perror("inline assembly read");
        asm volatile (
            "mov $3, %%rax\n" // SYS_close system call number for x86_64
            "mov %0, %%rdi\n" // file descriptor to close
            "syscall\n"
            :
            : "r" (fd)
            : "rax", "rdi"
        );
        return 1;
    }
    asm volatile (
        "mov $1, %%rax\n" // SYS_write system call number for x86_64
        "mov $1, %%rdi\n" // file descriptor for standard output
        "mov %1, %%rsi\n" // buffer to write from
        "mov %2, %%rdx\n" // number of bytes to write
        "syscall\n"
        :
        : "r" (buffer), "r" (bytesRead)
        : "rax", "rdi", "rsi", "rdx"
    );
    asm volatile (
        "mov $3, %%rax\n" // SYS_close system call number for x86_64
        "mov %0, %%rdi\n" // file descriptor to close
        "syscall\n"
        :
        : "r" (fd)
        : "rax", "rdi"
    );
    return 0;
}

这三种方法各有优缺点：使用标准库函数是最简单和最安全的，但有时你需要直接使用系统调用号或内联汇编以获得更高的控制或性能。