精华内容
下载资源
问答
  • linux内核协议栈分析

    2018-05-07 17:50:54
    详细描述了linux内核协议栈的实现原理及相关数据结构,为linux内核协议栈分析人员提供了重要参考。
  • 文章目录目录前文列表用户态网络协议栈简述内核协议栈存在的问题总结参考文档 前文列表 《Linux 内核网络协议栈》 《DPDK 网络加速在 NFV 中的应用》 用户态网络协议栈简述 用户态网络协议栈的底层支撑技术称为「...

    目录

    内核协议栈存在的意义

    关于内核协议栈的功能与原理我们在《Linux 内核网络协议栈》一文中已有讨论,这里我们主要思考内核协议栈存在的意义。要回答这个问题,我希望从操作系统聊起。

    一个正在运行的程序会做一件非常简单的事情:执行指令。CPU 从内存中获取一条指令,对其进行解码、然后执行它应该做的事情,例如:相加算数、访问内存、检查条件、跳转到函数等等。

    实际上,有一类软件负责让这些程序的运行变得简单,运行程序间共享内存,让程序能够与设备交互,这类软件就是操作系统。现在被我们称之为 “操作系统” 的软件其实最早的称谓是 Supervisor,往后还被叫过一段时间的 Master Control Program(主控程序),但最终 Operating System 胜出了。它们负责确保系统即易于使用又能正确高效的运行,为此,操作系统实现了以下两点需求:

    1. 操作系统带来了硬件的独立性和容易使用的 API(系统调用),让上层应用程序的运行更加简单。
    2. 操作系统应用(CPU、内存)虚拟化技术添加了一个时间分享的层,让多个上层应用程序的运行更加简单。

    写到这里不仅感叹 Unix 操作系统与 C 语言的出现,以及贝尔实验室排除万难使用 C 语言重写了 Unix 的壮举。从此,上层应用程序与计算机硬件的世界被解耦,黑客文化与思潮得以诞生,正是这群软件世界的叛逆者捍卫了代码的自由,开源运动才得以启动。

    回到主题,从操作系统的启发,我们大概能够理解内核协议栈的意义,它是为了让种类多如繁星的网络协议能够在计算机上运行得更加简单。但世上本不存在所谓的 “万金油”,计算机的世界从来都是时间与空间的博弈。看似万能的内核协议栈,其实充满妥协 —— Linux 内核协议栈存在严重的 Scalable(可伸展性)问题。

    在这里插入图片描述

    NOTE

    • BPS(Bit Per Second):比特每秒,表示每秒钟传输多少位信息,即带宽。例如:常说的 1M 带宽的意思是 1Mbps(兆比特每秒)。
    • CPS(Connect Per Second):TCP 每秒新建连接数。
    • PPS(Packet Per Second):包转发率,即能够同时转发的数据包的数量,表示转发数据包能力的大小。

    从上图可以看见,内核协议栈的 CPS、PPS 以及 CPU 数量的关系远没有达到线性提升,甚至远没有用户态协议栈来的优秀。据经验,在C1(8 Core)上运行应用程序每 1W 包处理需要消耗 1% 软中断 CPU,这意味着单机的上限是 100W PPS。假设,要跑满 10GE 网卡,每个包 64 字节,就需要 2000W PPS(注:实际上以太网万兆网卡速度上限是 1488W PPS,因为最小数据帧的大小为 84B),100G 就是 2亿 PPS,即每个包的处理耗时不能超过 50 纳秒。而一次 Cache Miss,不管 Miss 的是 TLB、数据 Cache 还是指令 Cache,回内存读取都需要大约为 65 纳秒,而且在 NUMA 架构体系下的跨 Node 通讯大约还需要额外多加 40 纳秒。

    所以,内核协议栈一秒钟能处理的数据包是有限的。当达到上限的时候,所有的 CPU 都开始忙于接收数据包。在这种情形下,数据包要么被丢弃,要么会导致应用 CPU 匮乏( starve of CPU)。诚然,这并非内核协议栈所愿,但现实如此,受限于操作系统和硬件设备的实现细节,内核协议栈选择了向空间(满足大部分常规使用场景)“妥协”。

    对此,笔者曾在《DPDK 网络加速在 NFV 中的应用》一文中详细谈到 Linux 内核协议栈存在的问题,这里不再赘述,简单总结为几点:

    • 上下文切换开销大
    • 内存拷贝昂贵
    • Cache Miss 高
    • 中断处理频繁
    • 系统调用开销

    再回过头来看,我们可以明显的感受到网速一直在提升,网络技术的发展从 1GE/10GE/25GE/40GE/100GE 演变,这也为计算机网络 I/O 能力提出了挑战。如何跟上网速的发展?这是一个宽泛的命题,我们只看其中的一个方法 —— 用户态网络协议栈。

    用户态网络协议栈简述

    用户态网络协议栈,即在 Linux 用户态上实现的网络协议栈处理程序,底层支撑技术被称为内核旁路技术,又可细分为完全内核旁路及部分内核旁路。其思路大抵是绕过内核,直接将网络硬件设备交给运行在用户态的应用程序使用,常见的内核旁路技术实现有 PF_RING、Snabbswitch、Netmap 以及 DPDK。

    有了内核旁路技术,开发者得以编写自己的网络协议栈,让协议栈功能变得更加灵活,专注于某些高级特性,并且针对性能进行优化。可见,用户态网络协议栈最大的特点就是 “自定义”,针对特定的业务需求来实现数据流量转发控制以及性能提升。当然了,这也需要付出代价 —— 每一张网卡只能用于一个进程,此时的网卡不再具备 “常规意义上” 的网卡功能。例如:Linux 的 netstat、tcpdump 等工具可能会停止工作。

    对于部分内核旁路技术,内核仍然保留对网卡的拥有权,并且能让用户态应用程序只在一个单独的接收队列(Rx Queue)上执行旁路,典型的部分内核旁路技术实现有 Linux 社区开源的 Netmap,官方数据是 10G 网卡 1400W PPS,已经比较接近 1488W 的极限了,但是 Netmap 没又得到广泛使用。其原因有几个:

    • Netmap 需要网卡驱动的支持,即受制于网卡厂商。
    • Netmap 仍然依赖中断通知机制,没完全解决瓶颈。
    • Netmap 更像是几个系统调用,实现用户态直接收发包,功能太过原始,没形成依赖的网络开发框架,社区不完善。

    但鉴于目前还没有稳定的开源部分内核旁路技术方案,我们希望 Netmap 能抢占这个商机。毕竟现在常见的 DPDK 与 Intel 的关系实在过于紧密。

    用户态网络协议栈的应用场景

    • 软件定义的交换机或者路由器,例如 OvS、vRouter。该场景中希望将网卡交由应用程序来管理,以及处理原始的数据包并且完全绕开内核。
    • 专用的负载均衡器。类似的,如果该机器只用来做数据包的随机处理(Packet Shuffling),那绕过内核就是合理的。
    • 对于选定的高吞吐/低延迟的应用进行部分旁路。例如:DDoS 缓解系统中。
    • 在高频交易(High Frequency Trading)场景中使用,因为用户态协议可以很好的降低延迟。

    用户态网络协议栈面临的挑战

    • Linux 内核协议栈有很多重要的特性和优秀的调试能力。需要花费长期的时间才可能挑战这个丰富的生态系统。

    用户态协议栈如何解决这个问题?

    解决问题,首先要提出问题。这里的问题是:如何提高收包吞吐?

    以 DPDK 为例,笔者《DPDK 网络加速在 NFV 中的应用》一文中也有过阐述,这里不再赘述。

    netmap 高性能网络 I/O 框架

    Netmap 基于共享内存的思想,是一个高性能收发原始数据包的框架,由 Luigi Rizzo 等人开发完成,其包含了内核模块以及用户态库函数。其目标是,不修改现有操作系统软件以及不需要特殊硬件支持,实现用户态和网卡之间数据包的高性能传递。

    在这里插入图片描述

    在 Netmap 框架下,内核拥有数据包池,发送环\接收环上的数据包不需要动态申请,有数据到达网卡时,当有数据到达后,直接从数据包池中取出一个数据包,然后将数据放入此数据包中,再将数据包的描述符放入接收环中。内核中的数据包池,通过 mmap 技术映射到用户空间。用户态程序最终通过 netmap_if 获取接收发送环 netmap_ring,进行数据包的获取发送。

    参考文档

    https://www.cnblogs.com/huangfuyuan/p/9238437.html
    https://cloud.tencent.com/developer/article/1198333
    https://blog.csdn.net/dog250/article/details/80532754

    展开全文
  • linux内核协议栈剖析

    2018-06-02 09:34:28
    linux内核协议栈调用解析,数据包走向流程。 网络数据包走向
  • Linux内核协议栈源码分析.pdfLinux2.6 协议栈源代码分析基于Linux 2.6.18 内核源码V0.1luoyu第 i 页Linux2.6 协议栈源代码分析目 录目 录 ii图目录 iv表目录 viii前 言 xiii感 谢 xiv第1章 协议栈概述 11.1 操作系统...

    Linux内核协议栈源码分析.pdf

    Linux2.6 协议栈源代码分析

    基于Linux 2.6.18 内核源码

    V0.1

    luoyu

    第 i 页

    Linux2.6 协议栈源代码分析

    目 录

    目 录 ii

    图目录 iv

    表目录 viii

    前 言 xiii

    感 谢 xiv

    第1章 协议栈概述 1

    1.1 操作系统及网络协议介绍 1

    1.1.1 Linux操作系统架构简介 1

    1.1.2 网络协议发展介绍 2

    1.2 本书的组织和安排 4

    1.2.1 基本的数据结构和计算机术语 5

    1.2.2 图片风格演示 6

    1.2.3 本书的组织 7

    第2章 系统初始化 9

    2.1 系统初始化流程简介 9

    2.2 内核文件解读 13

    2.2.1 ELF文件格式 13

    2.2.2 Link Scripts知识 15

    2.2.3 Linux 内核镜像研究 16

    2.3 中断及任务调度管理 23

    2.3.1 中断及软中断模型 23

    2.3.2 各种语境下的切换 32

    2.3.3 内核下的同步与互斥 33

    2.3.4 各种异步手段 35

    2.4 虚拟文件系统 37

    2.5 网络协议栈各部分初始化 39

    2.5.1 网络基础系统初始化 40

    2.5.2 网络内存管理 40

    2.5.3 网络文件系统初始化 48

    2.5.4 网络协议初始化 50

    2.5.5 初步了解路由系统 58

    2.6 Linux设备管理 58

    2.6.1 底层PCI模块的初始化 60

    2.6.2 网络设备接口初始化例程 63

    第3章 配置系统 73

    第 ii 页

    Linux2.6 协议栈源代码分析

    3.1 配置过程分析 73

    3.1.1 配置是如何下达到内核的? 73

    3.1.2 socket系统调用 74

    3.1.3 ioctl代码的实现 81

    3.1.4 Loopback接口的配置过程 90

    3.1.5 IP别名的实现 92

    3.2 回顾FIB系统初始化 96

    3.3 深入FIB系统 99

    3.4 FIB系统发生了什么样的变化 108

    3.5 直接访问路由表 122

    3.6 接口状态变化的处理过程 124

    第4章 网络层实现的初步研究 127

    4.1 从Ping 开始旅程 127

    4.2 再次相遇Socket系统调用 129

    4.3 IP数据报文格式 129

    4.4 send系统调用 130

    4.5 在路由系统中游历 135

    4.5.1 查找出口 135

    展开全文
  • linux内核协议栈源码分析
  • 内核协议栈数据包转发完全解析
  • Linux TCP 内核协议栈是一个非常复杂的实现, 不但沉淀了过去20多年的设计与实现,同时还在不停的更新。相关的RFC与优化工作一直还在进行中。如何研究和学习Linux TCP内核协议栈这样一块硬骨头就成了一大难题。当然...

    5caa1ed5aaa385f965a69603e86f63d1.png

    Linux TCP 内核协议栈是一个非常复杂的实现, 不但沉淀了过去20多年的设计与实现,同时还在不停的更新。相关的RFC与优化工作一直还在进行中。如何研究和学习Linux TCP内核协议栈这样一块硬骨头就成了一大难题。

    当然最重要也是最基本的还是要阅读相关的RFC和内核中的代码实现。这个是最最基本的要求。想要驯服TCP 内核协议栈这样的monster 仅仅浏览和静态分析代码是完全不够的。因为整个实现中充斥着各种边界条件和异常的处理(这里有部分原因是因为TCP协议本身设计造成的),尤其是TCP是有状态的协议, 很多边界条件的触发需要一系列的报文来构成,同时还需要满足时延等其它条件。

    幸运的是Google在2013年替大家解决了这个难题。Google 在2013 年发布了TCP 内核协议栈 测试工具 Packet Drill。这个工具是名副其实,大大的简化了学习和测试TCP 内核协议栈的难度。基本可以随心所欲的触摸TCP 内核协议栈的每个细节。Google的这件工具真是造福了人类。PacketDrill GitHub link:

    使用Packet Drill, 用户可以随心所欲的构造报文序列,可以指定所有的报文格式(类似tcpdump语法)然后通过TUN接口和目标系统的TCP 内核协议栈来通信, 并对接收到的来自目标系统TCP 内核协议栈 的报文进行校验,来确定是否通过测试。再进一步结合wireshark+Packet Drill 用户可以获得最直观而且具体的体验。每个报文的每个细节都在掌控之中,溜得飞起,人生瞬间到达了巅峰。

    Packet Drill 基本原理

    TUN 网络设备

    TUN 是Linux 下的虚拟网络设备, 可以直通到网络层。使得应用程序可以直接收发IP报文。

    2d7d53be9d344a2114692d662811f076.png

    Packet Drill 脚本解析/执行引擎

    • 首先 Packet Drill 脚本必须要被解析和分解为 通过传统socket 接口收发报文的部分和通过TUN接口收发报文的部分
    • 在传统socket 接口执行对应的动作。
    • 在TUN接口执行对应的动作,并对收到的数据进行比对。
    • 在本文中 socket 接口主要扮演的是 server side的角色。TUN接口扮演的是client的角色。因而我们可以通过TUN接口完全掌控我们将要发送出去的IP报文,并受到TCP协议栈的反馈。并和预设数据进行比对。

    Packet Drill 语法简介

    相对时间顺序

    Packet Drill 每一个事件(发送/接收/发起系统调用)都有相对前后事件的时间便宜。一般使用+number 来表达。例如+0 就是在之前的事件结束之后立即发起。+.1 表示为在之前时间结束秒之后发起。以此类推

    系统调用

    Packet Drill 中集成了系统调用, 可以通过脚本来完成例如 socket,bind, read,write,getsocketoption 等等系统调用。熟悉socket 编程的同学很容易理解并使用。

    报文的发送与接受

    • 通过内核栈侧。可以通过调用系统调用 read/write 来完成报文的发送与接受。但是因为tcp是有状态的协议栈,所以内核栈本身也会根据协议栈所处状态发送报文(例如ACK/SACK).
    • TUN 设备侧. Packet Drill 使用 < 表示发送报文, 使用 > 表示接收报文。

    报文的格式描述

    报文格式的表达比较类似tcpdump。例如 S 0:0(0) win 1000表示syn包 win大小为1000, 同时tcp的选项 mss (max segment size)为1000. 如果不熟悉报文格式, 可以先复习一下《TCP/IP协议详解》 卷1.

    进一步的信息请参考 Drilling Network Stacks with packetdrill:

    实战示例

    下面我们通过2个例子来进一步学习

    Handshake and Teardown

    我们通过packet drill的脚本 复习一下这个经典的流程。

    首选来回顾一下 TCP协议标准的 handshake 和 treardown 流程

    8950a1f63478fe7c0f2bbe8f7b4d02c9.png

    接下来我们结合packet drill 的脚本来重现 整个过程

    //创建server侧socket, server侧socket 将通过内核协议栈来通信  // 注意这里使用的是传统的系统调用  0 socket(..., SOCK_STREAM, IPPROTO_TCP) = 3     //设置对应的socket options  // 注意这里使用的是传统的系统调用  +0 setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0     //bind socket  // 注意这里使用的是传统的系统调用  +0 bind(3, ..., ...) = 0     //listen on the socket  // 注意这里使用的是传统的系统调用  +0 listen(3, 1) = 0     // client侧(TUN)发送 syn 握手的第一个报文  // 注意这里的语法 syn seq都是相对的,从0开始。  +0 < S 0:0(0) win 1000 <mss 1000>     // client侧(TUN)期望收到的报文格式 syn+ack 且 ack.no=ISN(c)+1  // 参考标准流程图 最后的<...> 表示任何tcp option都可以  // 这里是握手的第二步  +0 > S. 0:0(0) ack 1 <...>     // client侧(TUN)发送 ack 报文 seq = ISN(c)+1, ack = ISN(c) +1  // 这里是握手的第三步  +.1 < . 1:1(0) ack 1 win 1000     //握手成功,server侧 socket 返回 established socket  //这时通过accept 系统调用拿到这个stream 的socket  +0 accept(3, ..., ...) = 4     //server侧向stream 写入 10 bytes  //通过系统调用来完成写操作  +0 write(4, ..., 10)=10     //client侧期望收到receive 10 bytes  +0 > P. 1:11(10) ack 1     //client侧应答 ack 表示接收到 10 bytes  +.0 < . 1:1(0) ack 11 win 1000     // client 关闭连接 发送fin包  +0 < F. 1:1(0) ack 11 win 4000     // client侧期望接收到server端的对于fin的ack报文  // 这里由内核协议栈发回。ack = server seq +1, seq = server ack  // 参考标准流程图  +.005 > . 11:11(0) ack 2     // server 关闭连接 通过系统调用完成  +0 close(4) = 0     // client期望接收到的fin包格式  +0 > F. 11:11(0) ack 2     // client 发送server端fin包的应答ack包  +0 < . 2:2(0) ack 12 win 4000 

    至此, 我们纯手动的完成了全部的发起和关闭连接的过程。然后我们用wireshark 来验证一下

    e7a01c802c4e25193a9d6bdabcfcc2ed.png

    通过结合packetdrill与wireshark 使得每一步都在我们的掌控之中,

    SACK

    我们将使用packet drill 来探索一些更为复杂的案例。例如内核协议栈对于 SACK中各种排列组合的响应。

    SACK 是TCP协议中优化重传机制的一个重要选项(该选项一般都在报头的options部分)。

    最原始的情况下如果发送方对于 每一个报文接受到ACK之后再发送下一个报文, 效率将是极为低下的。引入滑动窗口之后允许发送方一次发送多个报文 但是如果中间某个报文丢失(没有收到其对应的ACK)那么从那个报文开始,其后所有发送过的报文都要被重新发送一次。造成了极大的浪费。

    SACK 是一种优化措施, 用来避免不必要的重发, 告知发送方那些报文已经收到,不用再重发。tcp 的选项中允许带有最多3个SACK的options。也就是三个已经收到了得报文区间信息。说了这么多, 还是有一些抽象, 我们来看一个具体的示例。

    示例说明

    在下面的这个例子中, 我们需要发送报文的顺序是 1,3,5,6,8,4,7,2 也就是测试一下内核tcp协议栈的SACK逻辑是否如同RFC中所描述的一样。

    // 初始化部分建立服务器端socket, 不再赘述  +0 socket(..., SOCK_STREAM, IPPROTO_TCP) = 3  +0 setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0  +0 bind(3, ..., ...) = 0  +0 listen(3, 1) = 0     // Client 端发送 握手报文以及接受服务器响应,不再赘述。这里注意激活了SACK  +.1 < S 0:0(0) win 50000 <mss 1000, sackOK,nop,nop,nop,wscale 7>  +0 > S. 0:0(0) ack 1 win 32000 <mss 1000,nop,nop,sackOK>  +0 < . 1:1(0) ack 1 win 50000     // Server 端就绪  +.1 accept(3, ..., ...) = 4     //发送报文1  +0 < . 1:1001(1000) ack 1 win 50000  //发送报文3, 报文2 被调整到最后发送  +0 < . 2001:3001(1000) ack 1 win 50000  //发送报文5 报文4 被调整乱序  +0 < . 4001:5001(1000) ack 1 win 50000  //发送报文6  +0 < . 5001:6001(1000) ack 1 win 50000   //发送报文8 报文7 被调整乱序  +0 < P. 7001:8001(1000) ack 1 win 50000  //发送报文4  +0 < . 3001:4001(1000) ack 1 win 50000  //发送报文7  +0 < . 6001:7001(1000) ack 1 win 50000  // 接收到第一个报文的ACK  +0 > . 1:1(0) ack 1001     // 接收到SACK, 报告收到了乱序的报文3,但是没报文2。  +0 > . 1:1(0) ack 1001 win 31000 <nop,nop,sack 2001:3001>  // 接收到SACK, 报告收到了乱序的报文3,报文5,但是没报文2。没报文4  +0 > . 1:1(0) ack 1001 win 31000 <nop,nop,sack 4001:5001 2001:3001>  // 接收到SACK, 报告收到了乱序的报文3,报文5,但是没报文2。没报文4  +0 > . 1:1(0) ack 1001 win 31000 <nop,nop,sack 4001:6001 2001:3001>  // 接收到SACK, 报告收到了乱序的报文3,报文5,6, 报文8,但是没报文2。没报文4,没报文7  +0 > . 1:1(0) ack 1001 win 31000 <nop,nop,sack 7001:8001 4001:6001 2001:3001>  // 接收到SACK, 报告收到了乱序的报文3,4,5,6, 报文8,但是没报文2。没报文7  +0 > . 1:1(0) ack 1001 win 31000 <nop,nop,sack 2001:6001 7001:8001>  // 接收到SACK, 报告收到了乱序的报文3,4,5,6,7,8,但是没报文2  +0 > . 1:1(0) ack 1001 win 31000 <nop,nop,sack 2001:8001>     //发送报文2 至此所有报文完结  +0 < . 1001:2001(1000) ack 1 win 50000     +0 > . 1:1(0) ack 8001` 

    随后我们再来用wireshark 验证一下。

    2712402abb8dc446655f38e6fc88c0d6.png

    果然完全匹配。

    Packet Drill 其实还有非常复杂而且更精巧的玩法, 可以充分测试各种边界条件。以后有机会再和大家进一步分享

    参考信息

    例子脚本的链接:

    本文转载自微信公众号「Linux阅码场」,可以通过以下二维码关注。转载本文请联系Linux阅码场公众号。 

    8939030fbe91521532ee75f683ea9a16.png

    【编辑推荐】

    【责任编辑:

    武晓燕

    TEL:(010)68476606】


    点赞 0
    展开全文
  • linux内核协议栈与DPDK

    2018-04-15 20:44:00
    linux内核网络协议栈的性能本身就不好,一些内核协议栈的实现瓶颈被发现,因此即使10GE的网卡大量投入使用也没有带来预期的性能提升。 因此一些跳过内核来处理网络包的技术手段应允而生,主要目的是为了实现低延迟...

    linux内核网络协议栈越来越多的被关注,因为网络流量发生的巨大的变化,每小时的流量相当于过去几天的流量。

    linux内核网络协议栈的性能本身就不好,一些内核协议栈的实现瓶颈被发现,因此即使10GE的网卡大量投入使用也没有带来预期的性能提升。

    因此一些跳过内核来处理网络包的技术手段应允而生,主要目的是为了实现低延迟,低消耗,高吞吐的网络,典型代表是DPDK。

     

    那么DPDK是如何处理报文的呢?在说明这个问题之前,我们先描述下linux内核的协议栈实现。

     

    Linux内核收包处理流程:

    1,当网卡收到报文后,通过DMA机制将报文放到内存

    2,网卡触发中断通知系统有报文到达(一个报文,一个中断),系统分配sk_buff,将报文copy到这块sk_buff中,然后交由协议栈处理

    3,经过协议栈处理,将报文上送用户态应用程序处理

    从上面的简单描述可以看出,处理越多报文就消耗越多资源(中断,内存等):

    a.一个报文一个中断,中断将打断CPU并且涉及上下文切换,将消耗系统资源

    b.每个报文都要分配sk_buff,申请分配将消耗很多资源,同时linux为了兼容很多协议将sk_buff设计的过于复杂和庞大,导致处理变得缓慢。

    c.其次,当用户态程序需要收发包时涉及多次系统调用和上下文切换,这些切换将消耗大量的系统资源。

    为了解决a/b问题,Linux在2.6版本开始支持NAPI,大体原理如下:

    网卡首先工作在中断模式,首包到达后中断处理程序处理报文,然后关闭网卡中断然后进入轮询模式,轮询检查网卡收包队列然后收包。

    其中轮询模式处理函数由网卡驱动实现,初始化过程中挂接即可。

     

    DPDK如何解决这些问题:

    上图左侧表示内核处理报文流程,右侧表示DPDK处理报文流程。DPDK模式网卡完全由DPDK库接管。

    DPDK通过将kernel bypass规避了内核处理报文的瓶颈,并且通过轮询模式,hugepage,线程的CPU亲和性,代码实现关注cache利用率,代码设计尽量减少互斥操作,代码设计尽量减少上下文切换等技术要点实现了高吞吐量,低延迟。

     

    转载于:https://www.cnblogs.com/llc-blog/p/8849376.html

    展开全文
  • 深入,对于想深入了解linux内核协议栈的有帮助
  • 上一篇博文中我们从宏观上分析了Linux内核中网络的初始化过程,这里我们再从宏观上分析一下一个数据包在各网络层的传递的过程。我们知道网络的OSI模型和TCP/IP模型层次结构如下:上文中我们看到了网络...
  • linux内核网络协议栈的性能本身就不好,一些内核协议栈的实现瓶颈被发现,因此即使10GE的网卡大量投入使用也没有带来预期的性能提升。因此一些跳过内核来处理网络包的技术手段应允而生,主要目的是为了实现低延迟,...
  • 学习Linux-4.12内核网路协议栈(2.1)——接口层加快传输速率的特性 学习Linux-4.12内核网路协议栈(2.2)——接口层数据包的接收(上半部) 学习Linux-4.12内核网路协议栈(2.3)——接口层数据包的接收(下半部...
  • 本文主要针对Linux-3.19.3版本的内核简单分析内核协议栈初始化涉及到的主要步骤和关键函数,不针对协议的解析以及数据包的处理流程做具体分析,后续有机会再详细分析 1.准备 Linux内核协议栈本身构建在虚拟文件...
  • 1 协议栈入口__netif_receive_skb_core() 2 vlan 操作 2.1 vlan报文信息struct vlan_hdr 2.2 vlan 剥离 vlan_untag() 2.3 vlan 添加eth_type_trans() 3 三层协议处理钩子注册 3.1 各种三层协议处理函数注册...
  • VPP和Linux内核协议栈通信的方法

    千次阅读 2019-05-18 15:13:15
    背景介绍 基于VPP开发一款网络设备,除使用VPP框架实现端口数据报文转发外,还需要对设备...相关的用户态程序是基于Linux内核的socket来收发包的,因此,需要实现VPP和Linux内核协议栈通信的方法,可以将访问控制面...
  • 作者简介 作者Liam,海外老码农,对应用密码学、CPU微架构、高速网络通信等领域都有所涉猎。Linux阅码场原创文章Linux TCP 内核协议栈是一个非常复杂的实现, 不但沉淀了过去...
  • Linux内核协议栈源代码解析是国人写的一本较为系统的书籍,这儿经过加书签,去掉限制,提供给大家下载
  • 目录 1 TCP保活机制 2 具体报文形式 2.1 零窗口通知包: win = 0 2.2 keepalive 包:seq = ack- 1,...在linux 内核协议栈中,当TCP的接收窗口为0时,发送端开始发送 keepalive 包,直到接收端窗口不为0时继续发...
  • 很早之前想深入的研究内核协议栈的源码,但是由于各种原因,一直都没有进行。各种原因有时间原因,毅力原因,也许更重要的是知识储备和方法论的问题——所谓的内功吧,毕竟对于菜鸟,能读懂协议栈源码真是件不容易的...
  • Linux内核协议栈之socket接口的内核实现(v2.6.18)
  • Table of Contents ...在《linux内核协议栈 TCP选项之SACK选项的接收Ⅰ》中有看到,对于每个SACK信息块,在和cache信息比较后,都会有两个核心操作来更新记分牌: tcp_sacktag_skip() tcp_sacktag_walk() .
  • raw_socket 接收到的SYN包,linux 协议栈同样会接收到,然而内核协议栈 会立刻回复RST,因为内核协议栈,检测到SYN目的端口无人监听。 ##问1: 是否有方法让内核不处理,或接收不到此SYN? ##问2: 链路层raw...
  • 题记:本系列文章的目的是抛开书本从Linux内核源代码... linux内核协议栈中对于socket相关API的实现 首先对于内核中断向量表不是很熟悉的请先参考一下博文:《TCP/IP协议栈源码图解分析系列6:linux 系统调用中...
  • 详解Linux协议栈的数据流向,SOCKET的操作流程,unicast multicast等等的区别。
  • 现在看一本linux内核协议栈源码解析一书,将自己学习的经历以及 理解记录下来,以备将来回头查漏补缺,同时校正自己的理解错误,自勉 转载于:https://www.cnblogs.com/ding-linux-coder/p/4401450.html...
  • 是查路由表快呢?还是查socket哈希表快?这不是问题的根本。问题的根本是怎么有效利用这两者,让两者成为合作者而不是竞争者。这是怎么回事? 我们知道,如果一个数据包要... Linux内核协议栈采用了一种办法:在s...
  • 自2012年开始我就一直在关注Linux网络协议栈转发平面的性能优化,到2015年已经有很多想法落地,但都是基于Linux内核协议栈的优化,那个时候还没有智能网卡,DPDK也不火爆,能做的只是优化协议栈,当时除了华为等...
  • 1 什么是邻居协议? NDP(Neighbor Discovery Protocol,邻居发现协议)是IPv6的一个关键协议,它组合了IPv4中的ARP、ICMP路由器发现和ICMP重定向等协议,并对它们作了改进。作为IPv6的基础性协议,NDP还提供了前缀...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,093
精华内容 1,637
关键字:

内核协议栈