Linux下能否通过排队syscalls减少调用开销？求C代码示例

你这个思路抓得很准——系统调用的开销主要来自用户态/内核态的上下文切换，每次切换都要保存/恢复寄存器、刷新TLB等操作，累积起来开销不小。把多个操作打包成一次系统调用，确实能大幅减少切换带来的额外消耗。

不过得明确一点：这种批量操作需要内核层面的支持——用户态程序没法自己“排队”多个系统调用再一次性触发，因为单个系统调用的触发本身就需要进入内核。下面给两种可行的实现方案：

方案1：利用内核原生批量接口（最实用） #

Linux等主流系统已经提供了不少批量操作的系统调用，比如readv/writev（批量读写）、preadv/pwritev（带偏移的批量读写），这些接口本质就是把多个IO请求打包，通过一次系统调用完成，避免多次切换。

代码示例：用writev批量写入多个缓冲区 #

下面的代码对比了普通多次write和writev的执行方式，后者只需要一次系统调用，耗时差异会很明显：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/uio.h>
#include <time.h>
#include <string.h>

#define NUM_BUFFERS 1000
#define BUF_SIZE 100

int main() {
    // 创建测试文件
    int fd = open("test_batch_write.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open failed");
        exit(EXIT_FAILURE);
    }

    // 准备多个缓冲区
    char* buffers[NUM_BUFFERS];
    struct iovec iov[NUM_BUFFERS];
    for (int i = 0; i < NUM_BUFFERS; i++) {
        buffers[i] = malloc(BUF_SIZE);
        snprintf(buffers[i], BUF_SIZE, "Buffer %d: This is a test line.\n", i);
        iov[i].iov_base = buffers[i];
        iov[i].iov_len = strlen(buffers[i]);
    }

    // 测试1：多次调用write
    clock_t start = clock();
    for (int i = 0; i < NUM_BUFFERS; i++) {
        if (write(fd, buffers[i], iov[i].iov_len) == -1) {
            perror("write failed");
            exit(EXIT_FAILURE);
        }
    }
    clock_t end = clock();
    printf("Multiple write calls took: %lf ms\n", (double)(end - start) * 1000 / CLOCKS_PER_SEC);

    // 重置文件指针到开头
    if (lseek(fd, 0, SEEK_SET) == -1) {
        perror("lseek failed");
        exit(EXIT_FAILURE);
    }

    // 测试2：单次writev调用
    start = clock();
    ssize_t total_written = writev(fd, iov, NUM_BUFFERS);
    if (total_written == -1) {
        perror("writev failed");
        exit(EXIT_FAILURE);
    }
    end = clock();
    printf("Single writev call took: %lf ms\n", (double)(end - start) * 1000 / CLOCKS_PER_SEC);
    printf("Total bytes written: %zd\n", total_written);

    // 清理资源
    for (int i = 0; i < NUM_BUFFERS; i++) {
        free(buffers[i]);
    }
    close(fd);

    return EXIT_SUCCESS;
}

编译运行后你会发现，writev的耗时远低于多次write，核心原因就是它只做了一次用户态/内核态切换。

方案2：自定义批量系统调用（需要内核开发） #

如果你的需求不是IO操作，而是自定义的系统调用（比如批量读取进程信息、批量修改文件权限），可以通过编写内核模块实现一个自定义的批量系统调用，把多个请求打包后一次性提交给内核处理。

简化代码示例： #

内核模块（batch_syscall.c）

#include <linux/kernel.h>
#include <linux/syscalls.h>
#include <linux/errno.h>
#include <linux/sched.h>

// 定义请求和结果结构体，用户态和内核态要一致
struct batch_request {
    int op; // 操作类型：0=获取当前进程UID，1=获取当前进程PID
    int pid; // 预留参数，比如指定目标进程PID
};

struct batch_result {
    int op;
    long result;
    int err; // 错误码，0表示成功
};

// 自定义批量系统调用处理函数
SYSCALL_DEFINE3(batch_syscall, struct batch_request __user*, reqs, int, num_reqs, struct batch_result __user*, resps) {
    struct batch_request kernel_req;
    struct batch_result kernel_resp;
    int i;

    for (i = 0; i < num_reqs; i++) {
        // 从用户态拷贝请求数据到内核态
        if (copy_from_user(&kernel_req, &reqs[i], sizeof(struct batch_request))) {
            return -EFAULT;
        }

        // 处理每个请求
        kernel_resp.op = kernel_req.op;
        kernel_resp.err = 0;
        switch (kernel_req.op) {
            case 0:
                // 获取当前进程的UID
                kernel_resp.result = (long)task_uid(current)->val;
                break;
            case 1:
                // 获取当前进程的PID
                kernel_resp.result = (long)current->pid;
                break;
            default:
                kernel_resp.err = -EINVAL;
                kernel_resp.result = 0;
        }

        // 把处理结果拷贝回用户态
        if (copy_to_user(&resps[i], &kernel_resp, sizeof(struct batch_result))) {
            return -EFAULT;
        }
    }

    return num_reqs; // 返回处理的请求数量
}

static int __init batch_syscall_init(void) {
    printk(KERN_INFO "Batch syscall module loaded\n");
    return 0;
}

static void __exit batch_syscall_exit(void) {
    printk(KERN_INFO "Batch syscall module unloaded\n");
}

module_init(batch_syscall_init);
module_exit(batch_syscall_exit);
MODULE_LICENSE("GPL");

用户态测试程序（test_batch_syscall.c）

#include <stdio.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <unistd.h>

// 和内核模块定义一致的结构体
struct batch_request {
    int op;
    int pid;
};

struct batch_result {
    int op;
    long result;
    int err;
};

// 自定义系统调用号（需要选一个未被系统占用的号，比如333，不同内核版本可能有差异）
#define __NR_batch_syscall 333

int main() {
    const int num_reqs = 5;
    struct batch_request reqs[num_reqs];
    struct batch_result resps[num_reqs];

    // 准备批量请求：交替获取UID和PID
    for (int i = 0; i < num_reqs; i++) {
        reqs[i].op = i % 2;
        reqs[i].pid = getpid();
    }

    // 调用自定义批量系统调用
    long ret = syscall(__NR_batch_syscall, reqs, num_reqs, resps);
    if (ret == -1) {
        perror("batch syscall failed");
        exit(EXIT_FAILURE);
    }

    // 打印结果
    printf("Processed %ld requests:\n", ret);
    for (int i = 0; i < num_reqs; i++) {
        if (resps[i].err != 0) {
            printf("Request %d (op=%d): Error %d\n", i, resps[i].op, resps[i].err);
        } else {
            const char* op_desc = (resps[i].op == 0) ? "UID" : "PID";
            printf("Request %d (op=%d, %s): %ld\n", i, resps[i].op, op_desc, resps[i].result);
        }
    }

    return EXIT_SUCCESS;
}

注意事项： #

• 自定义系统调用需要内核开发环境，且不同内核版本的系统调用注册方式可能有差异（比如有些版本需要修改syscall_64.tbl文件）
• 加载内核模块需要root权限，且必须确保模块编译时使用的内核头文件和当前运行的内核版本一致

内容的提问来源于stack exchange，提问作者doliphin