内核态和用户态通信(二)--实现

最新推荐文章于 2024-09-13 22:03:06 发布
最新推荐文章于 2024-09-13 22:03:06 发布
阅读量1k 收藏 2
点赞数
分类专栏： 网络编程 linux 文章标签： netlink

本文主要使用netlink套接字实现中断环境与用户态进程通信。
系统环境：基于linux 2.6.32.27 和 linux 3.16.36

Linux内核态和用户态进程通信方法的提出和实现

用户上下文环境

运行在用户上下文环境中的代码是可以阻塞的，这样，便可以使用消息队列和Unix域套接字来实现内核态和用户态的通信。但这些的数据传输效率较低，linux内核提供copy_from_user() 和 copy_to_user() 函数来实现内核态与用户态数据的拷贝，但这两个函数会引发阻塞，所以不能用在硬、软中断中。一般将这两个特殊拷贝函数用在类似系统调用一类的函数中，如图，
这里写图片描述
其中相关的系统调用是需要用户自行编写并载入内核。

硬、软中断环境

  1. 硬中断和软中断环境与用户态进程无丝毫关系，而且运行过程不能阻塞。
    软中断、硬中断有一套同步机制 — 自旋锁(spinlock)，可以通过自旋锁来实现中断环境和中断环境，中断环境与内核线程的同步，而内核线程是运行在有进程上下文环境中的，这样便可以在内核线程中使用套接字或消息队列来取得用户空间的数据，然后再将数据通过临界区传递给中断过程，如图
    这里写图片描述
    因为中断过程不可能无休止地等待用户态进程发送数据，所以要通过一个内核线程来接收用户空间的数据，再通过临界区传给中断过程。中断过程向用户空间的数据发送必须是无阻塞的。这样的通信模型并不令人满意，因为内核线程是和其他用户态进程竞争cpu接收数据的，效率很低，这样中断过程便不能实时地接收来自用户空间的数据。

  2. netlink套接字的通信依据是一个对应于进程的标识，一般定义为该进程的ID。当通信的一端处于中断过程时，该标识为0。当使用 netlink 套接字进行通信，通信的双方都是用户态进程，则使用方法类似于消息队列。但通信双方有一端是中断过程，使用方法则不同。netlink 套接字的最大特点是对中断过程的支持，它在内核空间接收用户空间数据时不再需要用户自行启动一个内核线程，而是通过另一个软中断调用用户事先指定的接收函数。工作原理如图
    这里写图片描述
    很明显，这里使用了软中断而不是内核线程来接收数据，这样就可以保证数据接收的实时性。
    当 netlink 套接字用于内核空间与用户空间的通信时，在用户空间的创建方法和一般套接字使用类似，但内核空间的创建方法则不同。如图
    这里写图片描述

/**
 *imp2.h
 */
#ifndef __IMP2_H__
#define __IMP2_H__

#define IMP2_OPS_BASIC 128
#define IMP2_SET    IMP2_OPS_BASIC
#define IMP2_GET    IMP2_OPS_BASIC
#define IMP2_MAX    (IMP2_OPS_BASIC + 1)

#define IMP2_U_PID 0
#define IMP2_K_MSG 1
#define IMP2_CLOSE 2

#define NL_IMP2    31

struct packet_info
{
    __u32 src;
    __u32 dest;
};
#endif
/**
 *imp2_u.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <signal.h>
#include <arpa/inet.h>
#include <linux/types.h>
#include <linux/netlink.h>
#include "imp2.h"


struct msg_to_kernel
{
    struct nlmsghdr hdr;
};

struct u_packet_info
{
    struct nlmsghdr hdr;
    struct packet_info icmp_info;
};

static int skfd;

static void sig_int(int signo)
{
    struct sockaddr_nl kpeer;
    struct msg_to_kernel message;

    memset(&kpeer,0,sizeof(kpeer));
    kpeer.nl_family = AF_NETLINK;
    kpeer.nl_pid = 0;
    kpeer.nl_groups = 0;

    memset(&message,0,sizeof(message));
    message.hdr.nlmsg_len = NLMSG_LENGTH(0);
    message.hdr.nlmsg_flags = 0;
    message.hdr.nlmsg_type = IMP2_CLOSE;
    message.hdr.nlmsg_pid = getpid();

    sendto(skfd,&message,message.hdr.nlmsg_len,0,(struct sockaddr *)(&kpeer),sizeof(kpeer));

    close(skfd);
    exit(0);

}

int main(void)
{

    /* 本地的 */
    struct sockaddr_nl local;
    /* 连线kernel的 */
    struct sockaddr_nl kpeer;
    int kpeerlen;
    struct msg_to_kernel message;
    struct u_packet_info info;
    int sendlen = 0;
    int rcvlen = 0;
    struct in_addr addr;

    skfd = socket(AF_NETLINK,SOCK_RAW,NL_IMP2);
    if(skfd < 0) {
        printf("cannot create a netlink socket\n");
        exit(0);
    }

    memset(&local,0,sizeof(local));
    local.nl_family = AF_NETLINK;
    local.nl_pid = getpid();
    local.nl_groups = 0;

    if(bind(skfd,(struct sockaddr *)&local,sizeof(local)) != 0) {
        printf("bind() error\n");
        return -1;
    }

    signal(SIGINT,sig_int);

    memset(&kpeer,0,sizeof(kpeer));
    kpeer.nl_family = AF_NETLINK;
    kpeer.nl_pid = 0;
    kpeer.nl_groups = 0;

    memset(&message,0,sizeof(message));
    message.hdr.nlmsg_len = NLMSG_LENGTH(0);
    message.hdr.nlmsg_flags = 0;
    message.hdr.nlmsg_type = IMP2_U_PID;
    message.hdr.nlmsg_pid = local.nl_pid;

    sendto(skfd,&message,message.hdr.nlmsg_len,0,(struct sockaddr *)&kpeer,sizeof(kpeer));

    while(1) {
        kpeerlen = sizeof(struct sockaddr_nl);
        rcvlen = recvfrom(skfd,&info,sizeof(struct u_packet_info),0,(struct sockaddr *)&kpeer,&kpeerlen);
        addr.s_addr = info.icmp_info.src;
        printf("src:%s,",inet_ntoa(addr));
        addr.s_addr = info.icmp_info.dest;
        printf("dest:%s\n",inet_ntoa(addr));
    }

    return 0;
}
/**
 * imp2_k.c //兼容linux 2.6.32 和 linux 3.16.36
 */
#ifndef __KERNEL__
#define __KERNEL__
#endif

#ifndef MODULE
#define MODULE
#endif

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/version.h>
#include <linux/netfilter_ipv4.h>
#include <linux/inet.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/netlink.h>
#include <linux/spinlock.h>
#include <linux/semaphore.h>
#include <linux/semaphore.h>
#include <net/sock.h>
#include "imp2.h"

#define NF_IP_PRE_ROUTING 0


/* 实现从netfilter的NF_IP_PRE_ROUTING点截获的ICMP数据包，
   再将数据包的相关信息传递到一个用户态进程 */

static struct sock *nlfd;

//是竞争的资源
struct {
    __u32 pid;
    rwlock_t lock;
}user_proc;



//相当于np_log
static int send_to_user(struct packet_info *info)
{
    int ret = 0;
    int size = 0;
    unsigned char *old_tail = NULL;

    struct sk_buff *skb = NULL;
    struct nlmsghdr *nlh = NULL;
    struct packet_info *packet = NULL;

    printk("%s,begin ....\n",__FUNCTION__);

    size = NLMSG_SPACE(sizeof(*info));
    //分配一块skb(数据缓存区和skb描述符),大小,GFP自动分配
    skb = alloc_skb(size,GFP_ATOMIC);
    old_tail = skb->tail;

    nlh = nlmsg_put(skb,0,0,IMP2_K_MSG,(size-sizeof(*nlh)),0);
    packet = NLMSG_DATA(nlh);
    memset(packet , 0 ,sizeof(struct packet_info));

    packet->src = info->src;
    packet->dest = info->dest;

    nlh->nlmsg_len = skb->tail - old_tail;
    NETLINK_CB(skb).dst_group = 0;

    read_lock_bh(&user_proc.lock);
    ret = netlink_unicast(nlfd,skb,user_proc.pid,MSG_DONTWAIT);
    read_unlock_bh(&user_proc.lock);

    printk("%s,end....\n",__FUNCTION__);

    return ret;

nlmsg_failure:

    if(skb) {
        kfree_skb(skb);
    }
    return -1;
}


static unsigned int get_icmp(unsigned int hooknum,struct sk_buff *skb,
        const struct net_device *in,const struct net_device *out,
        int(*okfn)(struct sk_buff *))
{
    //struct iphdr *iph = (*pskb)->nh.iph;
    struct iphdr *iph = ip_hdr(skb);    //2.6.24开始使用，因为struct sk_buff
    struct packet_info info;


    if(iph->protocol == IPPROTO_ICMP) {
        read_lock_bh(&user_proc.lock);

        if(user_proc.pid != 0) {
            info.src = iph->saddr;
            info.dest= iph->daddr;

            //printk("%s,src = %u.%u,%u.%u,dst = %u,%u,%u,%u\n",__FUNCTION__,NIPQUAD(info.src), NIPQUAD(info.dest));

            read_unlock_bh(&user_proc.lock);

            send_to_user(&info);

        } else {
            //printk("%s, no user process runing....\n",__FUNCTION__);
            read_unlock_bh(&user_proc.lock);

        }
    }

    return NF_ACCEPT;
}


static struct nf_hook_ops imp2_ops = 
{
    .hook = get_icmp,
    .pf = PF_INET,
    .hooknum = NF_IP_PRE_ROUTING,
    .priority = NF_IP_PRI_FILTER - 1,
    .owner = THIS_MODULE,
};

static void kernel_receive(struct sk_buff *skb)
{
    struct nlmsghdr *nlh = NULL;
    int len = 0;

    nlh = nlmsg_hdr(skb);
    len = skb->len;

    while(NLMSG_OK(nlh,len)) {

        write_lock_bh(&user_proc.lock);

        if(nlh->nlmsg_type == IMP2_U_PID) {
            user_proc.pid = nlh->nlmsg_pid;
        }
        else if(nlh->nlmsg_type == IMP2_CLOSE && nlh->nlmsg_pid == user_proc.pid) {
            user_proc.pid = 0;
        }

        write_unlock_bh(&user_proc.lock);

        netlink_ack(skb,nlh,0);
        nlh = NLMSG_NEXT(nlh,len);
    }
}

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)

struct netlink_kernel_cfg cfg = 
{
    .input = kernel_receive,
};

#endif

static int __init init(void)
{
    rwlock_init(&user_proc.lock);

    //这里的版本问题需要解决
    /*在内核创建一个netlink socket ,
      协议 NL_IMP2是自定义的,并指示由 kernel_receive接收数据*/

    {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
        nlfd = netlink_kernel_create(&init_net,NL_IMP2,&cfg);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) 
        nlfd = netlink_kernel_create(&init_net ,NL_IMP2 , 0, kernel_receive, NULL, THIS_MODULE);

#else 
        nlfd = NULL;

#endif
    }


    if(!nlfd) {
        printk("cannot create a netlink socket\n");
        return -1;
    }

    return nf_register_hook(&imp2_ops);
}


static void __exit fini(void)
{
    if(nlfd) {
        netlink_kernel_release(nlfd);
    }

    nf_unregister_hook(&imp2_ops);
}



module_init(init);
module_exit(fini);
MODULE_LICENSE("GPL");

#Makefile
MODULE_NAME := imp2_k
obj-m := $(MODULE_NAME).o

KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

all: 
    $(MAKE) -C $(KERNELDIR) M=$(PWD)

clean:
    rm -fr *.ko
    rm -fr *.o 
    rm -fr *.cmd sender $(MODULE_NAME).mod.c


.PHONY:clean aLL

netlink具体结构分析，可参考其他博文
http://blog.csdn.net/luckyapple1028/article/details/50839395
http://blog.csdn.net/luckyapple1028/article/details/50936563

my_zou
关注
专栏目录
RK3399平台开发系列讲解（网络篇）7.25、Socket接口的分层
内核笔记
02-02 2995
在Linux内核中，Socket的实现分为三层，第一层是 GLIBC接口层，第二层是 BSD接口层，第三层是 具体的协议层（如Unix sokcet或者INET socket）。
详解Linux用户态与内核态通信的几种方式
09-14
主要介绍了详解Linux用户态与内核态通信的几种方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
linux内核空间与用户空间信息交互方法
07-14 1416
本文作者：康华：计算机硕士，主要从事Linux操作系统内核、Linux技术标准、计算机安全、软件测试等领域的研究与开发工作，现就职于信息产业部软件与集成电路促进中心所属的MII-HP Linux软件实验室。如果需要可以联系通过kanghua151@msn.com联系他。 摘要：在进行设备驱动程序，内核功能模块等系统级开发时，通常需要在内核和用户程序之间交换信息。Linux提供了多种方法可以用来完成
NetLink 通信机制
最新发布
CHENDONGHAO1105的博客
09-13 585
Netlink是linux提供的用于内核和用户态进程之间的通信方式。但是注意虽然Netlink主要用于用户空间和内核空间的通信，但是也能用于用户空间的两个进程通信。只是进程间通信有其他很多方式，一般不用Netlink。除非需要用到Netlink的广播特性时。一般来说用户空间和内核空间的通信方式有三种：/proc、ioctl、Netlink。而前两种都是单向的，但是Netlink可以实现双工通信。
Linux -- 用户态和内核态通讯方式
迟来大师的博客
12-21 202
用户态和内核态通讯方式 内核启动参数、模块参数与 sysfs、sysctl、系统调用、netlink、procfs、seq_file、debugfs 和 relayfs。
内核态与用户态通信方式——Netlink
abcxy2161的博客
04-22 3169
内核态与用户态通信方式Linux下内核空间与用户空间进行通信的方式主要有system call、sysctl、procfs、模块参数、debugfs、relayfs、sysfs和netlink等。Why NetlinK full-duplex 模块参数、sysfs、procfs、debugfs和relayfs都是基于文件系统，用于内核向用户发送消息；sysctl和system call是用户向内核发
linux用户态与内核态通讯及如何编写内核模块
weixin_38679007的博客
06-08 1298
通讯方式：procfs/socket/syscall/IOCTL常用的是socket/syscall/ioctl.ioctl机制，ioctl机制可以在驱动中扩展特定的ioctl消息，用于将一些状态从内核反应到用户态。Ioctl有很好的数据同步保护机制，不要担心内核和用户层的数据访问冲突，但是ioctl不适合传输大量的数据，通过和内存映射结合可以很好的完成大量数据交换过程。但是，ioctl的发起方一...
电信设备-内核态与用户态的通信结构及通信方法.zip
09-18
在计算机操作系统中，内核态和用户态是两种不同的运行级别，它们之间的通信是系统设计中的关键部分。本文将深入探讨这两种状态的定义、特点以及它们如何在电信设备中进行通信，以帮助理解《电信设备-内核态与用户态...
linux内核态与用户态通信-netlink实例解析
07-24
二、内核态与用户态通信的必要性 由于用户态无法直接访问硬件，需要内核态协助，因此两者之间需要通信。常见的通信方式包括系统调用、信号量、共享内存、管道、消息队列、套接字等。Netlink是其中一种特殊的基于套...
linux使用eventfd进行用户态与内核态通信
12-17
在提供的压缩包文件`interrupt_test`中，很可能包含了这样一个示例，演示了如何在用户态和内核态之间利用`eventfd`进行通信，并结合线程亲核技术来优化性能。代码可能包括了创建`eventfd`、设置线程亲核性、在内核...
使用netlink完成用户态跟用户态的通信以及用户态跟内核态的通信
煮酒论英雄
10-15 1113
使用netlink机制跟指定进程通信netlink通信编码目标编码实现1、内核态代码2、使用netlink进行通信示例 netlink通信 我们知道，使用netlink可以完成用户跟内核态双向通信，实际使用时，我们需要对netlink进行封装统一的接口，在和指定进程进行通信时，只需要调用指定接口就可以轻松完成用户态到内核态的netlink通信编码。此外，我们上层用户态进程除了需要和内核进行通信外，还需要和其他用户态进程进行通信，因此需要封装统一的接口同时支持netlink用户态到用户态的通信以及用户态到内核
用户态与内核态通信netlink-example.zip
10-16
内核态与用户态通信---netlink通信的一些实例！！！
linux内核中的软中断的实现
jack li的博客
06-04 1045
最近在阅读linux内核源码，把自己的一些理解发上来，一方面看到的朋友可以帮我指正我理解偏差的地方，别一方面也算是做一个简单的总结。 首先调用open_softirq()函数来初始化软件中断处理函数，将软件中断处理函数根据软中断的下标号插入到softirq_vec数组中，实现过程很简单如下： 1 2 3 4 void open_softirq(int nr,
进程的软中断通信_Linux 中断
weixin_39776817的博客
11-22 892
中断大家应该很清楚，系统在执行时可以处于两种可能的状态：核心态和用户态。之前我们讨论过的系统调用，就能使进程从用户态切换到核心态去执行某些任务，当执行成功后再回到用户进程中。大家可能还记得这是通过软中断来实现的，那么中断到底是什么呢？ 接下来我将介绍与中断相关的一些知识。中断通常中断可以分为如下两个类别： - 同步中断和异常。这些由 CPU 自发地针对当前执行的程序产生的。异常可能因种种原因触发:...
Linux内核态和用户态的socket编程
成长笔记
05-11 3461
Linux socket编程（内核态）
Linux系统编程之套接字Socket
m0_67168421的博客
09-25 261
套接字（Socket）是一种用于在计算机网络中进行通信的编程接口或端点。它允许不同计算机上的进程通过网络进行数据传输和通信。套接字是网络通信的基础构建块，使程序能够在不同主机之间发送和接收数据。套接字提供了一种标准化的方法来创建、连接、发送和接收数据，无论是在本地计算机上的不同进程之间还是在远程计算机之间。套接字通常用于支持各种网络协议，如TCP（传输控制协议）、UDP（用户数据报协议）、IP（互联网协议）等，以实现不同类型的网络通信。
OSOSOS
weixin_44716359的博客
01-05 917
无
内核空间与用户空间的通信方式
feelinghappy的专栏
08-18 1451
下面总结了7种方式，主要对以前不是很熟悉的方式做了编程实现，以便加深印象。 1.使用API：这是最常使用的一种方式了 A.get_user(x，ptr)：在内核中被调用，获取用户空间指定地址的数值并保存到内核变量x中。 B.put_user(x，ptr)：在内核中被调用，将内核空间的变量x的数值保存到到用户空间指定地址处。 C.Copy_from_user()/copy_to_user()：主要应用于设备驱动读写函数中，通过系统调用触发。 2.使用proc文件系统：和sysfs文件系统..
Linux内核态与用户态内存共享示例：通过proc文件传递地址
总结来说，这个示例展示了Linux内核如何利用`proc`文件系统和内存映射功能，实现内核态和用户态之间的内存共享。这种机制有助于简化系统编程中的数据交换，并提供了一种安全的途径，使用户空间能间接访问内核的资源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值