Linux用户态/内核态通信方式汇总

最新推荐文章于 2025-04-10 11:12:52 发布

Adam付时凡

最新推荐文章于 2025-04-10 11:12:52 发布

阅读量2.1k

点赞数 32

文章标签： linux microsoft 服务器

本文链接：https://blog.csdn.net/zhengyuchao_/article/details/137949317

版权

Linux用户态/内核态通信方式汇总

文章目录

Linux用户态/内核态通信方式汇总

用户态和内核态之间的通信方式主要有以下几种：

系统调用（System Call）：这是最常见的方式，用户态程序通过系统调用接口（如open、read、write、fork等）请求内核执行特定的动作。系统调用是用户态和内核态之间进行交互的桥梁，它允许用户态程序请求内核提供服务。
中断（Interrupts）：中断包括软中断和硬中断。当中断到来时，CPU会暂停当前执行的用户态代码，切换到内核态来处理中断。中断机制允许内核在适当的时候介入用户态程序的执行，处理一些紧急或特殊的情况。
信号（Signal）：内核通过信号通知用户态进程发生了某些事件，用户态程序可以注册信号处理函数来响应特定的信号事件。例如，SIGTERM和SIGINT等信号就是用于通知进程终止或中断的信号。
共享内存（Share Memory）：允许多个进程在它们的地址空间中共享一块内存区域，从而实现用户态和内核态之间的高效通信。这种方式避免了频繁的用户态和内核态切换，但也需要处理数据同步和一致性的问题。
IOCTL：这是内核较早的一种用户态和内核态的交互方式。用户态程序通过命令的方式调用ioctl函数，然后内核态分发到对应驱动处理，最后将处理结果返回到用户态。
Netlink：本质上是一种特殊的socket，用于内核与多种用户进程之间的消息传递系统。netlink支持内核与用户态之间的双向通信，是一种全双工通信方式。
procfs/sysfs：在Linux中，procfs和sysfs是特殊的文件系统，用于内核与用户空间之间的信息交互。procfs提供了内核和进程的各种信息，而sysfs则提供了设备和驱动的信息。用户态程序可以通过读取这些文件系统中的文件来获取内核信息，也可以通过写入特定的文件来配置内核或驱动。
每种通信方式都有其特定的应用场景和优缺点，开发者需要根据具体需求选择适合的通信方式。

实现用户态和内核态之间的通信通常涉及编写内核模块（在内核态运行）以及用户空间程序（在用户态运行）。我将提供一个简单的例子，展示如何编写一个内核模块，它提供一个系统调用接口，以及一个用户空间程序来调用这个系统调用。

系统调用（System Call）

首先，我们需要编写一个内核模块，它注册一个新的系统调用。这个系统调用将简单地返回传递给它的参数值。

// syscall_example.c - 内核模块源代码  
#include <linux/kernel.h>  
#include <linux/syscalls.h>  
#include <linux/unistd.h>  
  
// 定义新的系统调用号（这通常是自动分配的，但在这个例子中为了简单起见我们手动定义）  
#define __NR_my_syscall 333  
  
// 定义系统调用的原型  
SYSCALL_DEFINE1(my_syscall, int, arg)  
{
     
    printk(KERN_INFO "my_syscall called with arg %d\n", arg);  
    return arg;  
}  
  
// 初始化模块  
static int __init syscall_example_init(void)  
{
     
    // 注册系统调用  
    if (syscall_register(__NR_my_syscall, (sys_call_ptr_t)my_syscall) < 0) {
     
        printk(KERN_ALERT "Failed to register syscall!\n");  
        return -1;  
    }  
    printk(KERN_INFO "syscall_example module loaded\n");  
    return 0;  
}  
  
// 清理模块  
static void __exit syscall_example_exit(void)  
{
     
    // 注销系统调用（这通常不是必需的，因为模块卸载时系统会自动清理）  
    syscall_unregister( );  
    printk(KERN_INFO "syscall_example module unloaded\n");  
}  
  
module_init(syscall_example_init);  
module_exit(syscall_example_exit);  
  
MODULE_LICENSE("GPL");

编译这个内核模块需要Makefile文件：

# Makefile - 用于编译内核模块的Makefile  
obj-m += syscall_example.o  
  
all:  
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules  
  
clean:  
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

在编译并加载这个模块后，新的系统调用就可以通过__NR_my_syscall号来调用了。

接下来，我们编写一个用户空间程序来调用这个新的系统调用。

// user_program.c - 用户空间程序源代码  
#include <unistd.h>  
#include <stdio.h>  
#include <sys/syscall.h>  
  
// 定义新的系统调用号，这个值必须与内核模块中定义的值相匹配  
#define __NR_my_syscall 333  
  
int main() {
     
    int arg = 42; // 要传递给系统调用的参数  
    long result;  
  
    // 使用syscall函数来调用系统调用  
    result = syscall(__NR_my_syscall, arg);  
    if (result >= 0) {
     
        printf("my_syscall returned: %ld\n", result);  
    } else {
     
        perror("my_syscall failed");  
    }  
  
    return 0;  
}

编译并运行用户空间程序：

gcc -o user_program user_program.c  
sudo insmod syscall_example.ko  # 加载内核模块  
./user_program                  # 运行用户空间程序  
sudo rmmod syscall_example     # 卸载内核模块（当不再需要时）

请注意，加载和卸载内核模块通常需要root权限。此外，由于内核模块和系统调用的开发涉及到对内核的深入理解和潜在的风险，因此在实际应用中应该非常小心，并确保遵循正确的开发和测试流程。此外，系统调用号的分配通常由内核管理，因此在真实环境中，你不会手动分配系统调用号，而是使用内核提供的机制来注册你的系统调用。

中断（Interrupts）

这个示例，提供一个简单的C语言实现，用于在用户态和内核态之间通信，并使用中断来实现。这个示例将使用字符设备驱动程序和ioctl系统调用。请注意，这个示例仅用于演示目的，实际应用可能需要更多的错误处理和功能。

内核态（字符设备驱动程序）

首先，我们需要创建一个简单的字符设备驱动程序。这个驱动程序将实现ioctl系统调用，以便用户态程序可以与内核态通信。

#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/cdev.h>
#include<linux/ioctl.h>
#include<linux/uaccess.h>

#define DEVICE_NAME "my_device"
#define DEVICE_MAJOR 240
#define DEVICE_MINOR 0

static int my_device_open(struct inode *inode, struct file *file) {
   
    return 0;
}

static int my_device_release(struct inode *inode, struct file *file) {
   
    return 0;
}

static long my_device_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
   
    int data;

    switch (cmd) {
   
        case 1: // 读取数据
            data = 42; // 示例数据
            if (copy_to_user((void *)arg, &data, sizeof(int))) {
   
                return -EFAULT;
            }
            break;
        default:
            return -ENOTTY;
    }

    return 0;
}

static struct file_operations my_device_fops = {
   
    .owner = THIS_MODULE,
    .open = my_device_open,
    .release = my_device_release,
    .unlocked_ioctl = my_device_ioctl,
};

static struct cdev my_device_cdev;

static int __init my_device_init(void) {
   
    int ret;
    dev_t devno = MKDEV(DEVICE_MAJOR, DEVICE_MINOR);

    ret = register_chrdev_region(devno, 1, DEVICE_NAME);
    if (ret < 0) {
   
        printk(KERN_ERR "Failed to register device region\n");
        return ret;
    }

    cdev_init(&my_device_cdev, &my_device_fops);
    my_device_cdev.owner = THIS_MODULE;

    ret = cdev_add(&my_device_cdev, devno, 1);
    if (ret < 0) {
   
        printk(KERN_ERR "Failed to add device\n");
        unregister_chrdev_region(devno, 1);
        return ret;
    }

    printk(KERN_INFO "My device initialized\n");
    return 0;
}

static void __exit my_device_exit(void) {
   
    dev_t devno = MKDEV(DEVICE_MAJOR, DEVICE_MINOR);

    cdev_del(&my_device_cdev);
    unregister_chrdev_region(devno, 1);

    printk(KERN_INFO "My device exited\n");
}

module_init(my_device_init);
module_exit(my_device_exit);
MODULE_LICENSE("GPL");

用户态（应用程序）

接下来，我们需要创建一个简单的用户态应用程序，用于与内核态通信。这个应用程序将使用ioctl系统调用来读取数据。

#include<stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>

#define DEVICE_NAME "/dev/my_device"

int main() {
   
    int fd, data;

    fd = open(DEVICE_NAME, O_RDWR);
    if (fd < 0) {
   
        perror("open");
        exit(EXIT_FAILURE);
    }

    if (ioctl(fd, 1, (unsigned long)&data) < 0) {

最低0.47元/天解锁文章