文章：用户空间与内核通信（一）介绍了系统调用（System Call），内核模块参数和sysfs，sysctl函数方式进行用户空间和内核空间的访问。本章节我将介绍使用netlink套接字和proc文件系统实现用户空间对内核空间的访问。
netlink套接字
netlink是一种基于socket的通信机制，用于在用户空间与内核空间之间进行小量数据的及时交互。netlink套接字允许用户空间程序与内核空间程序建立连接，并通过发送和接收消息来进行通信。
内核模块：
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netlink.h>
#include <net/netlink.h>
#define NETLINK_USER 31
#define MSG_LEN 1024
struct sock *nl_sock = NULL;
// 接收用户空间消息的回调函数
static void nl_recv_msg(struct sk_buff *skb) {
struct nlmsghdr *nlh;
char msg[MSG_LEN];
// 从skb中获取消息头
nlh = nlmsg_hdr(skb);
if (nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
netlink_skb_valid(skb, nlh->nlmsg_len)) {
// 拷贝消息数据到msg缓冲区
strncpy(msg, NLMSG_DATA(nlh), MSG_LEN);
// 打印接收到的消息
printk(KERN_INFO "Received message from user space: %s\n", msg);
}
}
// 模块初始化函数
static int __init init_netlink(void) {
// 创建Netlink套接字
nl_sock = netlink_kernel_create(&init_net, NETLINK_USER, 0, nl_recv_msg, NULL, THIS_MODULE);
if (!nl_sock) {
printk(KERN_ERR "Failed to create netlink socket\n");
return -1;
}
printk(KERN_INFO "Netlink socket created\n");
return 0;
}
// 模块退出函数
static void __exit exit_netlink(void) {
if (nl_sock)
netlink_kernel_release(nl_sock);
printk(KERN_INFO "Netlink socket released\n");
}
module_init(init_netlink);
module_exit(exit_netlink);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
用户空间应用程序：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#define NETLINK_USER 31
#define MSG_LEN 1024
int main() {
int sockfd;
struct sockaddr_nl src_addr, dest_addr;
struct nlmsghdr *nlh = NULL;
struct iovec iov;
struct msghdr msg;
sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_USER);
if (sockfd < 0) {
perror("socket");
return -1;
}
memset(&src_addr, 0, sizeof(src_addr));
src_addr.nl_family = AF_NETLINK;
src_addr.nl_pid = getpid(); // This is the source's port number
bind(sockfd, (struct sockaddr*)&src_addr, sizeof(src_addr));
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.nl_family = AF_NETLINK;
dest_addr.nl_pid = 0; // To kernel
dest_addr.nl_groups = 0;
nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MSG_LEN));
memset(nlh, 0, NLMSG_SPACE(MSG_LEN));
nlh->nlmsg_len = NLMSG_SPACE(MSG_LEN);
nlh->nlmsg_pid = getpid();
nlh->nlmsg_flags = 0;
strcpy(NLMSG_DATA(nlh), "Hello from user space");
iov.iov_base = (void *)nlh;
iov.iov_len = nlh->nlmsg_len;
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)&dest_addr;
msg.msg_namelen = sizeof(dest_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
sendmsg(sockfd, &msg, 0);
close(sockfd);
free(nlh);
return 0;
}
编译内核模块：
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
加载内核模块：
sudo insmod your_module.ko
编译用户空间程序：
gcc user_program.c -o user_program
运行用户空间程序：
sudo ./user_program
proc文件系统
proc是一个虚拟文件系统，用于导出内核和进程的状态信息。用户空间程序可以通过读取proc文件系统中的文件来获取内核和进程的信息，也可以通过写入proc文件来向内核发送指令或修改配置。
这些机制为用户空间与内核空间之间的通信提供了灵活和多样化的方式，使得用户程序能够与操作系统内核进行交互，获取系统服务并完成各种任务。
下面的示例，演示了如何使用proc文件系统在用户空间和内核空间之间进行通信。在此示例中，我们将创建一个proc文件，并使用它来向内核发送和接收数据。
首先，让我们创建一个名为"proc_example"的内核模块，该模块将在/proc目录下创建一个名为"proc_example"的文件。用户可以通过读取和写入此文件来与内核通信。文章来源：https://www.toymoban.com/news/detail-831082.html
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/uaccess.h>
#define PROC_ENTRY_NAME "proc_example"
#define BUFFER_SIZE 1024
static struct proc_dir_entry *proc_entry;
static char proc_buffer[BUFFER_SIZE];
// 读取proc文件的回调函数
static ssize_t proc_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) {
ssize_t len = strlen(proc_buffer);
if (*offset >= len) {
return 0; // 已经读取完毕
}
if (count > len - *offset) {
count = len - *offset; // 如果请求的数据超过了剩余的数据量，则只读取剩余的数据量
}
if (copy_to_user(buffer, proc_buffer + *offset, count) != 0) {
return -EFAULT; // 复制数据失败
}
*offset += count; // 更新偏移量
return count;
}
// 写入proc文件的回调函数
static ssize_t proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *offset) {
if (count >= BUFFER_SIZE) {
return -EINVAL; // 写入的数据过大
}
if (copy_from_user(proc_buffer, buffer, count) != 0) {
return -EFAULT; // 复制数据失败
}
proc_buffer[count] = '\0'; // 添加字符串结束符
return count;
}
// 模块初始化函数
static int __init init_proc_example(void) {
proc_entry = proc_create(PROC_ENTRY_NAME, 0666, NULL, &proc_fops);
if (!proc_entry) {
printk(KERN_ERR "Failed to create /proc/%s\n", PROC_ENTRY_NAME);
return -ENOMEM;
}
printk(KERN_INFO "/proc/%s created\n", PROC_ENTRY_NAME);
return 0;
}
// 模块退出函数
static void __exit exit_proc_example(void) {
if (proc_entry) {
remove_proc_entry(PROC_ENTRY_NAME, NULL);
printk(KERN_INFO "/proc/%s removed\n", PROC_ENTRY_NAME);
}
}
// 定义proc文件操作结构体
static const struct file_operations proc_fops = {
.read = proc_read,
.write = proc_write,
};
module_init(init_proc_example);
module_exit(exit_proc_example);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
编译和加载模块后，你可以在/sys/kernel/debug/proc_example中读取和写入数据。例如，你可以使用cat和echo命令：文章来源地址https://www.toymoban.com/news/detail-831082.html
$ echo "Hello from user space" > /proc/proc_example
$ cat /proc/proc_example
Hello from user space
到了这里，关于用户空间与内核通信（二）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
