用户态与内核态通信：AF_NETLINK+AF_UNIX及IPC共享缓冲区实现咨询

嘿，作为IPC领域的新手，你的这个混合AF_UNIX+AF_NETLINK的共享缓冲区方案想法挺棒的——既保留了用户态套接字的易用性，又实现了跨内核/用户态的通信能力。我来给你拆解下具体的实现步骤和关键要点，帮你把这个方案落地：

先把核心架构理清楚，确保各组件职责明确：

• 用户态侧：
  • 守护进程：负责管理共享缓冲区的生命周期、同步逻辑（互斥/信号量），同时作为AF_NETLINK的用户态端点，和内核模块双向通信。
  • 客户端进程：链接你的自定义库，通过AF_UNIX套接字向守护进程发起缓冲区读写请求。
• 内核态侧：
  • 内核模块：作为AF_NETLINK的内核端点，发起对共享缓冲区的读写操作，或接收守护进程的缓冲区更新通知。
• 共享缓冲区：有两种可行方案：
  • 内核态分配内存，用户态通过mmap映射到自身地址空间（安全性更高，内核可控访问权限）。
  • 用户态用shm_open+mmap创建共享内存，内核态通过copy_from_user/copy_to_user安全访问。

2.1 内核态AF_NETLINK模块实现 #

内核侧需要创建NETLINK套接字并处理用户态消息，以下是极简示例代码：

#include <linux/netlink.h>
#include <linux/module.h>

// 自定义NETLINK协议号（选未被占用的，比如31）
#define NETLINK_MYIPC 31
// 共享缓冲区大小
#define BUF_SIZE 4096
// 内核态共享缓冲区
static char kernel_shared_buf[BUF_SIZE];

static struct sock *nl_sk = NULL;

// 处理用户态发来的NETLINK消息
static void nl_recv_msg(struct sk_buff *skb) {
    struct nlmsghdr *nlh = nlmsg_hdr(skb);
    int user_pid = nlh->nlmsg_pid; // 发送消息的用户态进程PID（这里是守护进程）
    char *user_data = nlmsg_data(nlh);

    switch(nlh->nlmsg_type) {
        case 1: // 读缓冲区请求
            // 构造响应消息返回给用户态
            struct sk_buff *skb_out = nlmsg_new(BUF_SIZE, GFP_KERNEL);
            struct nlmsghdr *nlh_out = nlmsg_put(skb_out, 0, 0, NLMSG_DONE, BUF_SIZE, 0);
            strncpy(nlmsg_data(nlh_out), kernel_shared_buf, BUF_SIZE);
            netlink_unicast(nl_sk, skb_out, user_pid, MSG_DONTWAIT);
            break;
        case 2: // 写缓冲区请求
            // 把用户态数据拷贝到内核缓冲区
            strncpy(kernel_shared_buf, user_data, BUF_SIZE-1);
            kernel_shared_buf[BUF_SIZE-1] = '\0';
            printk(KERN_INFO "内核缓冲区已更新：%s\n", kernel_shared_buf);
            break;
        default:
            printk(KERN_WARNING "收到未知NETLINK消息类型\n");
            break;
    }
}

static int __init nl_module_init(void) {
    struct netlink_kernel_cfg cfg = {
        .input = nl_recv_msg,
    };

    nl_sk = netlink_kernel_create(&init_net, NETLINK_MYIPC, &cfg);
    if (!nl_sk) {
        printk(KERN_ALERT "NETLINK套接字创建失败\n");
        return -ENOMEM;
    }
    printk(KERN_INFO "NETLINK IPC模块加载成功\n");
    return 0;
}

static void __exit nl_module_exit(void) {
    netlink_kernel_release(nl_sk);
    printk(KERN_INFO "NETLINK IPC模块卸载成功\n");
}

module_init(nl_module_init);
module_exit(nl_module_exit);
MODULE_LICENSE("GPL");

2.2 用户态守护进程实现 #

守护进程需要同时处理AF_UNIX和AF_NETLINK套接字，用select实现多路复用：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/select.h>
#include <linux/netlink.h>

#define NETLINK_MYIPC 31
#define UNIX_SOCK_PATH "/tmp/my_ipc_sock"
#define BUF_SIZE 4096

// 处理AF_UNIX客户端请求
void handle_unix_client(int client_fd) {
    char req_buf[BUF_SIZE];
    int n = read(client_fd, req_buf, BUF_SIZE);
    if (n <= 0) {
        close(client_fd);
        return;
    }
    req_buf[n] = '\0';

    // 解析客户端请求：READ/WRITE
    if (strncmp(req_buf, "READ", 4) == 0) {
        // 向内核发送读请求，获取数据后返回给客户端
        int nl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_MYIPC);
        struct sockaddr_nl nl_addr = {0};
        nl_addr.nl_family = AF_NETLINK;
        nl_addr.nl_pid = getpid();

        struct nlmsghdr *nlh = malloc(NLMSG_SPACE(BUF_SIZE));
        memset(nlh, 0, NLMSG_SPACE(BUF_SIZE));
        nlh->nlmsg_len = NLMSG_SPACE(BUF_SIZE);
        nlh->nlmsg_pid = getpid();
        nlh->nlmsg_type = 1; // 读请求

        struct iovec iov = {.iov_base = nlh, .iov_len = nlh->nlmsg_len};
        struct msghdr msg = {.msg_name = &nl_addr, .msg_namelen = sizeof(nl_addr), .msg_iov = &iov, .msg_iovlen = 1};

        sendmsg(nl_fd, &msg, 0);
        // 接收内核响应
        char resp_buf[BUF_SIZE];
        recvmsg(nl_fd, &msg, 0);
        strncpy(req_buf, NLMSG_DATA(nlh), BUF_SIZE);
        write(client_fd, req_buf, strlen(req_buf));

        free(nlh);
        close(nl_fd);
    } else if (strncmp(req_buf, "WRITE", 5) == 0) {
        // 向内核发送写请求
        int nl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_MYIPC);
        struct sockaddr_nl nl_addr = {0};
        nl_addr.nl_family = AF_NETLINK;
        nl_addr.nl_pid = getpid();

        struct nlmsghdr *nlh = malloc(NLMSG_SPACE(BUF_SIZE));
        memset(nlh, 0, NLMSG_SPACE(BUF_SIZE));
        nlh->nlmsg_len = NLMSG_SPACE(BUF_SIZE);
        nlh->nlmsg_pid = getpid();
        nlh->nlmsg_type = 2; // 写请求
        strncpy(NLMSG_DATA(nlh), req_buf+6, BUF_SIZE-1);

        struct iovec iov = {.iov_base = nlh, .iov_len = nlh->nlmsg_len};
        struct msghdr msg = {.msg_name = &nl_addr, .msg_namelen = sizeof(nl_addr), .msg_iov = &iov, .msg_iovlen = 1};

        sendmsg(nl_fd, &msg, 0);
        free(nlh);
        close(nl_fd);
        write(client_fd, "OK", 2);
    }
    close(client_fd);
}

// 处理内核发来的NETLINK消息（比如主动通知缓冲区更新）
void handle_netlink_msg(int nl_fd) {
    char buf[BUF_SIZE];
    struct sockaddr_nl nl_addr = {0};
    struct iovec iov = {.iov_base = buf, .iov_len = BUF_SIZE};
    struct msghdr msg = {.msg_name = &nl_addr, .msg_namelen = sizeof(nl_addr), .msg_iov = &iov, .msg_iovlen = 1};

    int n = recvmsg(nl_fd, &msg, 0);
    if (n <= 0) return;

    struct nlmsghdr *nlh = (struct nlmsghdr*)buf;
    printk("收到内核通知：%s\n", NLMSG_DATA(nlh));
}

int main() {
    // 创建AF_UNIX监听套接字
    int unix_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    struct sockaddr_un unix_addr = {0};
    unix_addr.sun_family = AF_UNIX;
    strncpy(unix_addr.sun_path, UNIX_SOCK_PATH, sizeof(unix_addr.sun_path)-1);
    unlink(UNIX_SOCK_PATH);
    bind(unix_fd, (struct sockaddr*)&unix_addr, sizeof(unix_addr));
    listen(unix_fd, 5);

    // 创建AF_NETLINK套接字
    int nl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_MYIPC);
    struct sockaddr_nl nl_addr = {0};
    nl_addr.nl_family = AF_NETLINK;
    nl_addr.nl_pid = getpid();
    bind(nl_fd, (struct sockaddr*)&nl_addr, sizeof(nl_addr));

    // 多路复用处理两个套接字
    fd_set read_fds;
    int max_fd = (unix_fd > nl_fd) ? unix_fd : nl_fd;

    while(1) {
        FD_ZERO(&read_fds);
        FD_SET(unix_fd, &read_fds);
        FD_SET(nl_fd, &read_fds);

        select(max_fd+1, &read_fds, NULL, NULL, NULL);

        if (FD_ISSET(unix_fd, &read_fds)) {
            int client_fd = accept(unix_fd, NULL, NULL);
            handle_unix_client(client_fd);
        }
        if (FD_ISSET(nl_fd, &read_fds)) {
            handle_netlink_msg(nl_fd);
        }
    }

    // 清理资源（实际需要处理信号触发退出）
    close(unix_fd);
    close(nl_fd);
    unlink(UNIX_SOCK_PATH);
    return 0;
}

2.3 用户态客户端库实现 #

封装AF_UNIX通信逻辑，让客户端可以便捷调用：

// my_ipc_lib.h
#ifndef MY_IPC_LIB_H
#define MY_IPC_LIB_H

int buf_init(void);
int buf_read(char *out_buf, int max_len);
int buf_write(const char *in_buf);
void buf_cleanup(void);

#endif

// my_ipc_lib.c
#include "my_ipc_lib.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define UNIX_SOCK_PATH "/tmp/my_ipc_sock"
#define BUF_SIZE 4096

static int client_sock = -1;

int buf_init(void) {
    client_sock = socket(AF_UNIX, SOCK_STREAM, 0);
    if (client_sock < 0) return -1;

    struct sockaddr_un addr = {0};
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, UNIX_SOCK_PATH, sizeof(addr.sun_path)-1);

    if (connect(client_sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        close(client_sock);
        client_sock = -1;
        return -1;
    }
    return 0;
}

int buf_read(char *out_buf, int max_len) {
    if (client_sock < 0) return -1;
    write(client_sock, "READ", 4);
    return read(client_sock, out_buf, max_len);
}

int buf_write(const char *in_buf) {
    if (client_sock < 0) return -1;
    char req_buf[BUF_SIZE];
    snprintf(req_buf, BUF_SIZE, "WRITE %s", in_buf);
    return write(client_sock, req_buf, strlen(req_buf));
}

void buf_cleanup(void) {
    if (client_sock >= 0) {
        close(client_sock);
        client_sock = -1;
    }
}

• 内存访问安全：内核态绝对不能直接访问用户态地址，必须用copy_from_user/copy_to_user做数据拷贝；如果是内核态共享内存，用户态通过mmap映射后也要注意权限控制。
• 同步机制：多实体（客户端、守护进程、内核）访问缓冲区时必须加锁，用户态用进程共享属性的pthread_mutex，内核态用mutex_lock/mutex_unlock。
• 协议号选择：不要使用系统已占用的NETLINK协议号，可查看/usr/include/linux/netlink.h确认，推荐用NETLINK_GENERIC或自定义大于30的编号。
• 资源清理：守护进程退出时要删除UNIX套接字文件；内核模块卸载时要释放NETLINK套接字和内核内存。

1. 编译内核模块：编写Makefile编译成.ko，用insmod加载。
2. 编译守护进程：gcc daemon.c -o daemon，后台运行。
3. 编译客户端库：gcc -c my_ipc_lib.c -o my_ipc_lib.o && ar rcs libmyipc.a my_ipc_lib.o。
4. 编写测试客户端：链接静态库，调用buf_init()、buf_write()、buf_read()验证功能。

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