系统调用与设备驱动：从用户态到内核态的跨越机制

一、系统调用的工程意义：用户态与内核态的边界

操作系统通过系统调用（syscall）在用户态和内核态之间建立安全边界。用户程序不能直接操作硬件，必须通过 syscall 请求内核代为执行。这个边界不是技术限制，而是安全设计：如果用户程序能直接写磁盘，一个 Bug 就能破坏整个文件系统。

系统调用的性能开销是跨越边界的代价：从用户态切换到内核态需要保存/恢复寄存器、切换栈、刷新 TLB，单次开销约 100-200ns。高频系统调用（如网络 I/O）的累积开销不可忽视，这是 epoll/io_uring 等优化方案的驱动力。

二、系统调用的执行链路

sequenceDiagram
    participant U as 用户态
    participant K as 内核态

    U->>U: 调用库函数 write()
    U->>U: 将参数放入寄存器
    U->>K: syscall 指令（触发软中断）
    K->>K: 保存用户态寄存器
    K->>K: 切换到内核栈
    K->>K: 查找 syscall 表
    K->>K: 执行 sys_write()
    K->>K: 恢复用户态寄存器
    K->>U: 返回用户态
    U->>U: 检查返回值

三、系统调用与字符设备驱动的实现

/* ========== 系统调用注册 ========== */

/* Linux 5.x 的 syscall 表定义（arch/x86/entry/syscalls/syscall_64.tbl） */
/* 每个系统调用有唯一编号和对应的内核函数 */

/* 自定义系统调用示例 */
SYSCALL_DEFINE2(my_ioctl, unsigned int, fd, unsigned long, cmd)
{
    /* 参数校验：防止用户态传入非法值 */
    if (fd >= NR_OPEN)
        return -EBADF;

    struct file *filp = fget(fd);
    if (!filp)
        return -EBADF;

    /* 调用文件操作的 ioctl 方法 */
    if (filp->f_op->unlocked_ioctl) {
        long ret = filp->f_op->unlocked_ioctl(filp, cmd, 0);
        fput(filp);
        return ret;
    }

    fput(filp);
    return -ENOTTY;
}


/* ========== 字符设备驱动 ========== */

#define DEVICE_NAME "mydev"
#define BUF_SIZE 4096

struct mydev_data {
    char buffer[BUF_SIZE];
    int buffer_len;
    struct mutex lock;       /* 互斥锁保护并发访问 */
    wait_queue_head_t read_queue;  /* 读等待队列 */
};

static struct mydev_data *mydev;

/* 打开设备 */
static int mydev_open(struct inode *inode, struct file *filp)
{
    /* 将设备数据指针存入 filp->private_data，后续操作可直接获取 */
    filp->private_data = mydev;
    return 0;
}

/* 读设备：用户态调用 read() 时触发 */
static ssize_t mydev_read(
    struct file *filp, char __user *buf,
    size_t count, loff_t *ppos)
{
    struct mydev_data *data = filp->private_data;
    ssize_t ret;

    /* 获取互斥锁 */
    if (mutex_lock_interruptible(&data->lock))
        return -ERESTARTSYS;

    /* 如果缓冲区为空，阻塞等待（可被信号中断） */
    while (data->buffer_len == 0) {
        mutex_unlock(&data->lock);
        if (wait_event_interruptible(data->read_queue, data->buffer_len > 0))
            return -ERESTARTSYS;
        if (mutex_lock_interruptible(&data->lock))
            return -ERESTARTSYS;
    }

    /* 读取数据，不超过缓冲区剩余量 */
    size_t to_copy = min(count, (size_t)data->buffer_len);

    /* copy_to_user：将内核数据安全地复制到用户空间 */
    if (copy_to_user(buf, data->buffer, to_copy)) {
        ret = -EFAULT;
        goto out;
    }

    data->buffer_len -= to_copy;
    ret = to_copy;

out:
    mutex_unlock(&data->lock);
    return ret;
}

/* 写设备：用户态调用 write() 时触发 */
static ssize_t mydev_write(
    struct file *filp, const char __user *buf,
    size_t count, loff_t *ppos)
{
    struct mydev_data *data = filp->private_data;
    ssize_t ret;

    if (mutex_lock_interruptible(&data->lock))
        return -ERESTARTSYS;

    size_t to_copy = min(count, (size_t)(BUF_SIZE - data->buffer_len));
    if (to_copy == 0) {
        ret = -ENOSPC;  /* 缓冲区已满 */
        goto out;
    }

    /* copy_from_user：安全地从用户空间复制数据到内核 */
    if (copy_from_user(data->buffer + data->buffer_len, buf, to_copy)) {
        ret = -EFAULT;
        goto out;
    }

    data->buffer_len += to_copy;
    ret = to_copy;

    /* 唤醒阻塞在读等待队列上的进程 */
    wake_up_interruptible(&data->read_queue);

out:
    mutex_unlock(&data->lock);
    return ret;
}

/* 文件操作集合：将系统调用映射到驱动函数 */
static const struct file_operations mydev_fops = {
    .owner   = THIS_MODULE,
    .open    = mydev_open,
    .read    = mydev_read,
    .write   = mydev_write,
    /* .ioctl, .mmap 等按需实现 */
};

/* 模块初始化 */
static int __init mydev_init(void)
{
    mydev = kzalloc(sizeof(*mydev), GFP_KERNEL);
    if (!mydev)
        return -ENOMEM;

    mutex_init(&mydev->lock);
    init_waitqueue_head(&mydev->read_queue);

    /* 注册字符设备 */
    int major = register_chrdev(0, DEVICE_NAME, &mydev_fops);
    if (major < 0) {
        kfree(mydev);
        return major;
    }

    pr_info("mydev: registered with major %d\n", major);
    return 0;
}

四、系统调用与驱动的 Trade-offs 分析

系统调用的开销：每次 syscall 约 100-200ns，高频调用（如逐字节 read）会显著影响性能。建议使用缓冲区批量读取，或使用 mmap 绕过 syscall 直接访问设备内存。

copy_to_user/copy_from_user 的安全性：这两个函数会检查用户空间指针的合法性，防止内核访问非法地址。但检查本身有开销。对于高性能场景，可以使用 get_user_pages 直接映射用户页到内核。

驱动的并发安全：多个进程可能同时打开设备文件，读写操作必须用锁保护。mutex_lock_interruptible 允许被信号中断，避免不可杀死的 D 状态进程。但中断后需要正确恢复状态（ERESTARTSYS）。

设备节点的权限控制：/dev/mydev 的权限决定了哪些用户可以访问设备。默认只有 root 可访问，需要 udev 规则调整权限。权限过宽有安全风险，过窄限制可用性。

五、总结

系统调用是用户态与内核态的安全边界，每次跨越有 100-200ns 的开销。字符设备驱动通过 file_operations 将系统调用映射到具体的硬件操作。关键实现要点：copy_to_user/copy_from_user 保证用户空间访问安全，mutex 保护并发访问，wait_queue 实现阻塞 I/O。落地时需要关注 syscall 开销优化、并发安全和设备权限控制。