1.浅析Linux标准的内核文件系统(Ext2/Ext3/Ext4)
2.我想学习编程，但是源码源码不知道该怎么开始。
3.深入理解Linux的分析epoll机制
4.Golang GMP 原理
5.linux运行arm程序armlinux程序
6.技术干货！DPDK新手入门到网络功能深入理解

浅析Linux标准的内核文件系统(Ext2/Ext3/Ext4)

       全称Linux extended file system, extfs，即Linux扩展文件系统，源码源码Ext2就代表第二代文件扩展系统，分析masm源码Ext3/Ext4以此类推，内核它们都是源码源码Ext2的升级版。Ext2被称为索引式文件系统，分析而Ext3/Ext4被称为日志式文件系统。内核Linux支持多种文件系统，源码源码包括网络文件系统(NFS)、分析Windows的内核Fat文件系统等。

       查看Linux支持的源码源码文件系统：执行命令`ls -l /lib/modules/$(uname -r)/kernel/fs`或`cat /proc/filesystems`。

       内核资料和学习资源：提供Linux内核技术交流群链接，分析整理了一些个人觉得较好的学习书籍、视频资料。进群私聊管理领取内核资料包（含视频教程、电子书、实战项目及代码）。还提供了免费加入学习的通道，包括Linux/c/c++/内核源码/音视频/DPDK/Golang云原生/QT。

       核心设计数据存放区：这些元素相对稳定，磁盘格式化后，就固定下来了。inode的大小和数量都已固定，大小均为Bytes(新的Ext4和xfs为Bytes)。读取文件时，先读取inode里面记录的文件属性和权限，匹配正确后，才会读取文件内容(block)。在Linux系统中，实际使用inode来识别文件，而不是文件名。

       查看文件或者文件系统的状态：查看系统各个文件系统的inode使用情况。

       中介数据(metadata)：这些元素是为了维持文件系统状态而设计出来的，当新增、编辑、删除文档时，都需要变更这些状态信息。整个文件系统的基本信息全部记录在superblock，它的大小一般为Bytes，如果它死掉，将会花费大量的时间去补救哦！！！除了第一个block group含有superblock外，后续block group都可能会含有备份的superblock，目的就是为了避免superblock单点无法救援的问题。

       inode的作用：当用户搜索或者访问一个文件时，UNIX 系统通过 inode 表查找正确的 inode 编号。在找到 inode 编号之后，相关的命令才可以访问该 inode，并对其进行适当的更改。例如使用vi来编辑一个文件，通过 inode 表找到 inode 编号之后，才允许打开该 inode。在 vi 的编辑会话期间，更改了该 inode 中的某些属性，当您完成操作并键入 :wq 时，将关闭并释放该 inode 。通过这种方式，如果两个用户试图对同一个文件进行编辑，inode 已经在第一个编辑会话期间分配给了另一个用户 ID (UID)，因此第二个编辑任务就必须等待，直到该 inode 释放为止。

       block的重要性：block是文件数据存储的原子单位，且每一个 block 只能存储一个文件的数据。当格式化一个文件系统时，如果选择不当，就会造成大量的磁盘空间浪费。例如，如果文件系统选择的 block 为4k，存储个小文件，每个bytes，请问此时浪费了多少磁盘空间容量？答案是，每个文件浪费的磁盘容量 = - = bytes，个文件浪费的磁盘容量 = * ~=M，实际文件容量 = * ~=4.7M，浪费率高达%。

       inode和block与文件大小的关系：数据实际存储在 block，为了能够快速地读取文件，每个文件都对应一个 inode 索引文件，记录所有的 block 编号。inode的大小只有bytes或bytes (ext4)，如果一个文件太大，block 数量很有可能会超过 inode 可记录的数量。inode 记录 block 号码的区域被设计为 个直接、一个间接、谷歌源码大全查询一个双间接、一个三间接记录区。

       计算单文件最大容量：每个 block 号码为数字，需要占据 4bytes。

       查看磁盘和文档的容量：1. 查看文件系统的整体磁盘容量。2. 查看目录和文件容量。查看目录 geekbuying 下所有目录的容量。统计当前目录容量。

       总结：Ext 家族是 Linux 支持度最广、最完整的文件系统，当我们格式化磁盘后，就已经为我们规划好了所有的 inode/block/metadate 等数据，这样系统可以直接使用，不需要再进行动态的配置。不过这也是它最显著的缺点，磁盘容量越大，格式化越慢。CentOS7.x 已经选用 xfs 作为默认文件系统，xfs 是一种适合大容量磁盘和处理巨型文件的文件系统。

我想学习编程，但是不知道该怎么开始。

       我建议最好是从基础入手，而不是一开始就进行可视化编程。虽然如今国内绝大多数pc都是使用的windows，但是毕竟这知识这个世界的冰山一角。扎实的基础自然会更有用处。编程其实重要的是程序思维，然后是算法和数据结构。这些都是超出语言的，就是说不管是学c学java学delphi还是别的什么，这一部分都是一致的。因此培养这部分的知识可以说是一本万利的事情。初学肯定是通过语言熟悉思想熟悉算法和数据结构，到一定的时候就是纯粹的思想和算法数据结构的学习，便已经脱离程序语言了。经历过这些阶段，换一种语言不过是重新了解一下描述的方式，就像你了解了中文思维，山东话和四川话的差别就不会太大；了解了拉丁语的思维，整个语系的语言都不过是简简单单的记忆工作，应用就好。入门的语言，理论上是怎么方便学哪个，看那个顺眼学哪个。当然这里面还是有不同的推荐的。一般来说我比较推荐pascal、c/c++、java。并不是因为这三个东西很通用很有前途，而是它们实在是严整而有规则（c/c++还显得稍微的宽松了一点），而严谨的语法要求和明确的概念区分是有利于编程思维的形成和算法数据结构的学习的。同样的因为这个理由我不推荐vb，而并不是因为它功能不强大（事实上vb在windows环境中是相当牛的语言）另外一个建议是，如果学c，不要一开始就用vc。ms提供的很多东西很方便，有很多很简单的实现方法，但是它们不标准。vc与ansi

       c标准是有很大的差距的。首先一个不遵循标准的c/c++程序是不通用的，换个编译器说不定就不被承认了。所以我非常推崇gcc，理由之一是它完全符合

       ansi

       c标准，无论它的c还是c++编译器都很严整，功能上一点也不缺乏（有人说gcc不能做图形界面的程序，这一点完全错误，到处都有的qt库和gtk库都能做出很好的界面），另外一个理由便是它免费，毕竟稍微大一点的软件企业就不会屈从与微软的编译器和平台，而一个免费的c编译器无疑可以创造更多的利益；就算要转vc，标准的c程序也是几乎不要作任何改动的。当然，这一切的前提是，你真的很想很好的学编程，做一个这方面的精英。如果只不过是兴趣，或者只是想拿一个ms的工程师认证然后在国内企业找份诸如设计vf、vb程序之类的工作，那完全可以忽略我上面的话，去找个认证培训班，认认真真听听课，好好完成练习，从vb或者vc入手，考好认证是很不会太难的。毕竟现在很多很好的大学里都从来不缺乏计算机的课程，不会缺少算法或者编译原理的课程，不会没有计算机科学的研究院，而那里面出来的威廉指标源码推荐人一般都具备了很好的基础知识，会更加容易成为前面所说的精英。

深入理解Linux的epoll机制

       在Linux系统之中有一个核心武器：epoll池，在高并发的，高吞吐的IO系统中常常见到epoll的身影。

IO多路复用

       在Go里最核心的是Goroutine，也就是所谓的协程，协程最妙的一个实现就是异步的代码长的跟同步代码一样。比如在Go中，网络IO的read，write看似都是同步代码，其实底下都是异步调用，一般流程是：

write(/*IO参数*/)请求入队等待完成后台loop程序发送网络请求唤醒业务方

       Go配合协程在网络IO上实现了异步流程的同步代码化。核心就是用epoll池来管理网络fd。

       实现形式上，后台的程序只需要1个就可以负责管理多个fd句柄，负责应对所有的业务方的IO请求。这种一对多的IO模式我们就叫做IO多路复用。

       多路是指？多个业务方（句柄）并发下来的IO。

       复用是指？复用这一个后台处理程序。

       站在IO系统设计人员的角度，业务方咱们没办法提要求，因为业务是上帝，只有你服从的份，他们要创建多个fd，那么你就需要负责这些fd的处理，并且最好还要并发起来。

       业务方没法提要求，那么只能要求后台loop程序了！

       要求什么呢？快！快！快！这就是最核心的要求，处理一定要快，要给每一个fd通道最快的感受，要让每一个fd觉得，你只在给他一个人跑腿。

       那有人又问了，那我一个IO请求（比如write）对应一个线程来处理，这样所有的IO不都并发了吗？是可以，但是有瓶颈，线程数一旦多了，性能是反倒会差的。

       这里不再对比多线程和IO多路复用实现高并发之间的区别，详细的可以去了解下nginx和redis高并发的秘密。

最朴实的实现方式？

       我不用任何其他系统调用，能否实现IO多路复用？

       可以的。那么写个for循环，每次都尝试IO一下，读/写到了就处理，读/写不到就sleep下。这样我们不就实现了1对多的IO多路复用嘛。

whileTrue:foreach句柄数组{ read/write(fd,/*参数*/)}sleep(1s)

       慢着，有个问题，上面的程序可能会被卡死在第三行，使得整个系统不得运行，为什么？

       默认情况下，我们没有加任何参数create出的句柄是阻塞类型的。我们读数据的时候，如果数据还没准备好，是会需要等待的，当我们写数据的时候，如果还没准备好，默认也会卡住等待。所以，在上面伪代码第三行是可能被直接卡死，而导致整个线程都得到不到运行。

       举个例子，现在有，，这3个句柄，现在读写都没有准备好，只要read/write(,/*参数*/)就会被卡住，但，这两个句柄都准备好了，那遍历句柄数组，，的时候就会卡死在前面，后面，则得不到运行。这不符合我们的预期，因为我们IO多路复用的loop线程是公共服务，不能因为一个fd就直接瘫痪。

       那这个问题怎么解决？

       只需要把fd都设置成非阻塞模式。这样read/write的时候，如果数据没准备好，返回EAGIN的错误即可，不会卡住线程，从而整个系统就运转起来了。java 源码安全吗比如上面句柄还未就绪，那么read/write(,/*参数*/)不会阻塞，只会报个EAGIN的错误，这种错误需要特殊处理，然后loop线程可以继续执行，的读写。

       以上就是最朴实的IO多路复用的实现了。但是好像在生产环境没见过这种IO多路复用的实现？为什么？

       因为还不够高级。for循环每次要定期sleep1s，这个会导致吞吐能力极差，因为很可能在刚好要sleep的时候，所有的fd都准备好IO数据，而这个时候却要硬生生的等待1s，可想而知。。。

       那有同学又要质疑了，那for循环里面就不sleep嘛，这样不就能及时处理了吗？

       及时是及时了，但是CPU估计要跑飞了。不加sleep，那在没有fd需要处理的时候，估计CPU都要跑到%了。这个也是无法接受的。

       纠结了，那sleep吞吐不行，不sleep浪费cpu，怎么办？

       这种情况用户态很难有所作为，只能求助内核来提供机制协助来。因为内核才能及时的管理这些通知和调度。

       我们再梳理下IO多路复用的需求和原理。IO多路复用就是1个线程处理多个fd的模式。我们的要求是：这个“1”就要尽可能的快，避免一切无效工作，要把所有的时间都用在处理句柄的IO上，不能有任何空转，sleep的时间浪费。

       有没有一种工具，我们把一箩筐的fd放到里面，只要有一个fd能够读写数据，后台loop线程就要立马唤醒，全部马力跑起来。其他时间要把cpu让出去。

       能做到吗？能，这种需求只能内核提供机制满足你。

这事Linux内核必须要给个说法？

       是的，想要不用sleep这种辣眼睛的实现，Linux内核必须出手了，毕竟IO的处理都是内核之中，数据好没好内核最清楚。

       内核一口气提供了3种工具select，poll，epoll。

       为什么有3种？

       历史不断改进，矬->较矬->卧槽、高效的演变而已。

       Linux还有其他方式可以实现IO多路复用吗？

       好像没有了！

       这3种到底是做啥的？

       这3种都能够管理fd的可读可写事件，在所有fd不可读不可写无所事事的时候，可以阻塞线程，切走cpu。fd有情况的时候，都要线程能够要能被唤醒。

       而这三种方式以epoll池的效率最高。为什么效率最高？

       其实很简单，这里不详说，其实无非就是epoll做的无用功最少，select和poll或多或少都要多余的拷贝，盲猜（遍历才知道）fd，所以效率自然就低了。

       举个例子，以select和epoll来对比举例，池子里管理了个句柄，loop线程被唤醒的时候，select都是蒙的，都不知道这个fd里谁IO准备好了。这种情况怎么办？只能遍历这个fd，一个个测试。假如只有一个句柄准备好了，那相当于做了1千多倍的无效功。

       epoll则不同，从epoll_wait醒来的时候就能精确的拿到就绪的fd数组，不需要任何测试，拿到的就是要处理的。

epoll池原理

       下面我们看一下epoll池的使用和原理。

epoll涉及的系统调用

       epoll的使用非常简单，只有下面3个系统调用。

epoll_createepollctlepollwait

       就这？是深度学习算法源码的，就这么简单。

       epollcreate负责创建一个池子，一个监控和管理句柄fd的池子；

       epollctl负责管理这个池子里的fd增、删、改；

       epollwait就是负责打盹的，让出CPU调度，但是只要有“事”，立马会从这里唤醒；

epoll高效的原理

       Linux下，epoll一直被吹爆，作为高并发IO实现的秘密武器。其中原理其实非常朴实：epoll的实现几乎没有做任何无效功。我们从使用的角度切入来一步步分析下。

       首先，epoll的第一步是创建一个池子。这个使用epoll_create来做：

       原型：

intepoll_create(intsize);

       示例：

epollfd=epoll_create();if(epollfd==-1){ perror("epoll_create");exit(EXIT_FAILURE);}

       这个池子对我们来说是黑盒，这个黑盒是用来装fd的，我们暂不纠结其中细节。我们拿到了一个epollfd，这个epollfd就能唯一代表这个epoll池。

       然后，我们就要往这个epoll池里放fd了，这就要用到epoll_ctl了

       原型：

intepoll_ctl(intepfd,intop,intfd,structepoll_event*event);

       示例：

if(epoll_ctl(epollfd,EPOLL_CTL_ADD,,&ev)==-1){ perror("epoll_ctl:listen_sock");exit(EXIT_FAILURE);}

       上面，我们就把句柄放到这个池子里了，op（EPOLL_CTL_ADD）表明操作是增加、修改、删除，event结构体可以指定监听事件类型，可读、可写。

       第一个跟高效相关的问题来了，添加fd进池子也就算了，如果是修改、删除呢？怎么做到时间快？

       这里就涉及到你怎么管理fd的数据结构了。

       最常见的思路：用list，可以吗？功能上可以，但是性能上拉垮。list的结构来管理元素，时间复杂度都太高O(n)，每次要一次次遍历链表才能找到位置。池子越大，性能会越慢。

       那有简单高效的数据结构吗？

       有，红黑树。Linux内核对于epoll池的内部实现就是用红黑树的结构体来管理这些注册进程来的句柄fd。红黑树是一种平衡二叉树，时间复杂度为O(logn)，就算这个池子就算不断的增删改，也能保持非常稳定的查找性能。

       现在思考第二个高效的秘密：怎么才能保证数据准备好之后，立马感知呢？

       epoll_ctl这里会涉及到一点。秘密就是：回调的设置。在epoll_ctl的内部实现中，除了把句柄结构用红黑树管理，另一个核心步骤就是设置poll回调。

       思考来了：poll回调是什么？怎么设置？

       先说说file_operations->poll是什么？

       在fd篇说过，Linux设计成一切皆是文件的架构，这个不是说说而已，而是随处可见。实现一个文件系统的时候，就要实现这个文件调用，这个结构体用structfile_operations来表示。这个结构体有非常多的函数，我精简了一些，如下：

structfile_operations{ ssize_t(*read)(structfile*,char__user*,size_t,loff_t*);ssize_t(*write)(structfile*,constchar__user*,size_t,loff_t*);__poll_t(*poll)(structfile*,structpoll_table_struct*);int(*open)(structinode*,structfile*);int(*fsync)(structfile*,loff_t,loff_t,intdatasync);//....};

       你看到了read，write，open，fsync，poll等等，这些都是对文件的定制处理操作，对于文件的操作其实都是在这个框架内实现逻辑而已，比如ext2如果有对read/write做定制化，那么就会是ext2_read，ext2_write，ext4就会是ext4_read，ext4_write。在open具体“文件”的时候会赋值对应文件系统的file_operations给到file结构体。

       那我们很容易知道read是文件系统定制fd读的行为调用，write是文件系统定制fd写的行为调用，file_operations->poll呢？

       这个是定制监听事件的机制实现。通过poll机制让上层能直接告诉底层，我这个fd一旦读写就绪了，请底层硬件（比如网卡）回调的时候自动把这个fd相关的结构体放到指定队列中，并且唤醒操作系统。

       举个例子：网卡收发包其实走的异步流程，操作系统把数据丢到一个指定地点，网卡不断的从这个指定地点掏数据处理。请求响应通过中断回调来处理，中断一般拆分成两部分：硬中断和软中断。poll函数就是把这个软中断回来的路上再加点料，只要读写事件触发的时候，就会立马通知到上层，采用这种事件通知的形式就能把浪费的时间窗就完全消失了。

       划重点：这个poll事件回调机制则是epoll池高效最核心原理。

       划重点：epoll池管理的句柄只能是支持了file_operations->poll的文件fd。换句话说，如果一个“文件”所在的文件系统没有实现poll接口，那么就用不了epoll机制。

       第二个问题：poll怎么设置？

       在epoll_ctl下来的实现中，有一步是调用vfs_poll这个里面就会有个判断，如果fd所在的文件系统的file_operations实现了poll，那么就会直接调用，如果没有，那么就会报告响应的错误码。

staticinline__poll_tvfs_poll(structfile*file,structpoll_table_struct*pt){ if(unlikely(!file->f_op->poll))returnDEFAULT_POLLMASK;returnfile->f_op->poll(file,pt);}

       你肯定好奇poll调用里面究竟是实现了什么？

       总结概括来说：挂了个钩子，设置了唤醒的回调路径。epoll跟底层对接的回调函数是：ep_poll_callback，这个函数其实很简单，做两件事情：

       把事件就绪的fd对应的结构体放到一个特定的队列（就绪队列，readylist）；

       唤醒epoll，活来啦！

       当fd满足可读可写的时候就会经过层层回调，最终调用到这个回调函数，把对应fd的结构体放入就绪队列中，从而把epoll从epoll_wait出唤醒。

       这个对应结构体是什么？

       结构体叫做epitem，每个注册到epoll池的fd都会对应一个。

       就绪队列很高级吗？

       就绪队列就简单了，因为没有查找的需求了呀，只要是在就绪队列中的epitem，都是事件就绪的，必须处理的。所以就绪队列就是一个最简单的双指针链表。

       小结下：epoll之所以做到了高效，最关键的两点：

       内部管理fd使用了高效的红黑树结构管理，做到了增删改之后性能的优化和平衡；

       epoll池添加fd的时候，调用file_operations->poll，把这个fd就绪之后的回调路径安排好。通过事件通知的形式，做到最高效的运行；

       epoll池核心的两个数据结构：红黑树和就绪列表。红黑树是为了应对用户的增删改需求，就绪列表是fd事件就绪之后放置的特殊地点，epoll池只需要遍历这个就绪链表，就能给用户返回所有已经就绪的fd数组；

哪些fd可以用epoll来管理？

       再来思考另外一个问题：由于并不是所有的fd对应的文件系统都实现了poll接口，所以自然并不是所有的fd都可以放进epoll池，那么有哪些文件系统的file_operations实现了poll接口？

       首先说，类似ext2，ext4，xfs这种常规的文件系统是没有实现的，换句话说，这些你最常见的、真的是文件的文件系统反倒是用不了epoll机制的。

       那谁支持呢？

       最常见的就是网络套接字：socket。网络也是epoll池最常见的应用地点。Linux下万物皆文件，socket实现了一套socket_file_operations的逻辑（net/socket.c）：

staticconststructfile_operationssocket_file_ops={ .read_iter=sock_read_iter,.write_iter=sock_write_iter,.poll=sock_poll,//...};

       我们看到socket实现了poll调用，所以socketfd是天然可以放到epoll池管理的。

       还有吗？

       有的，其实Linux下还有两个很典型的fd，常常也会放到epoll池里。

       eventfd：eventfd实现非常简单，故名思义就是专门用来做事件通知用的。使用系统调用eventfd创建，这种文件fd无法传输数据，只用来传输事件，常常用于生产消费者模式的事件实现；

       timerfd：这是一种定时器fd，使用timerfd_create创建，到时间点触发可读事件；

       小结一下：

       ext2，ext4，xfs等这种真正的文件系统的fd，无法使用epoll管理；

       socketfd，eventfd，timerfd这些实现了poll调用的可以放到epoll池进行管理；

       其实，在Linux的模块划分中，eventfd，timerfd，epoll池都是文件系统的一种模块实现。

思考

       前面我们已经思考了很多知识点，有一些简单有趣的知识点，提示给读者朋友，这里只抛砖引玉。

       问题：单核CPU能实现并行吗？

       不行。

       问题：单线程能实现高并发吗？

       可以。

       问题：那并发和并行的区别是？

       一个看的是时间段内的执行情况，一个看的是时间时刻的执行情况。

       问题：单线程如何做到高并发？

       IO多路复用呗，今天讲的epoll池就是了。

       问题：单线程实现并发的有开源的例子吗？

       redis，nginx都是非常好的学习例子。当然还有我们Golang的runtime实现也尽显高并发的设计思想。

总结

       IO多路复用的原始实现很简单，就是一个1对多的服务模式，一个loop对应处理多个fd；

       IO多路复用想要做到真正的高效，必须要内核机制提供。因为IO的处理和完成是在内核，如果内核不帮忙，用户态的程序根本无法精确的抓到处理时机；

       fd记得要设置成非阻塞的哦，切记；

       epoll池通过高效的内部管理结构，并且结合操作系统提供的poll事件注册机制，实现了高效的fd事件管理，为高并发的IO处理提供了前提条件；

       epoll全名eventpoll，在Linux内核下以一个文件系统模块的形式实现，所以有人常说epoll其实本身就是文件系统也是对的；

       socketfd，eventfd，timerfd这三种”文件“fd实现了poll接口，所以网络fd，事件fd，定时器fd都可以使用epoll_ctl注册到池子里。我们最常见的就是网络fd的多路复用；

       ext2，ext4，xfs这种真正意义的文件系统反倒没有提供poll接口实现，所以不能用epoll池来管理其句柄。那文件就无法使用epoll机制了吗？不是的，有一个库叫做libaio，通过这个库我们可以间接的让文件使用epoll通知事件，以后详说，此处不表；

后记

       epoll池使用很简洁，但实现不简单。还是那句话，Linux内核帮你包圆了。

       今天并没有罗列源码实现，以很小的思考点为题展开，简单讲了一些epoll的思考，以后有机会可以分享下异步IO（aio）和epoll能产生什么火花？Golang是怎样使用epoll池的？敬请期待哦。

       原创不易，更多干货，关注：奇伢云存储

Golang GMP 原理

       通常语义中的线程，指的是内核级线程，核心点包括：（1）它是操作系统最小调度单元；（2）创建、销毁、调度交由内核完成，cpu 需完成用户态与内核态间的切换；（3）可充分利用多核，实现并行。

       协程，又称为用户级线程，核心点如下：（1）与线程存在映射关系，为 M：1；（2）创建、销毁、调度在用户态完成，对内核透明，所以更轻；（3）从属同一个内核级线程，无法并行；一个协程阻塞会导致从属同一线程的所有协程无法执行。

       Goroutine，经 Golang 优化后的特殊“协程”，核心点包括：（1）与线程存在映射关系，为 M：N；（2）创建、销毁、调度在用户态完成，对内核透明，足够轻便；（3）可利用多个线程，实现并行；（4）通过调度器的斡旋，实现和线程间的动态绑定和灵活调度；（5）栈空间大小可动态扩缩，因地制宜。

       对比三个模型的各项能力：综上，goroutine 可说是博采众长之物。

       实际上，“灵活调度” 一词概括得实在过于简要，Golang 在调度 goroutine 时，针对“如何减少加锁行为”，“如何避免资源不均”等问题都给出了精彩的解决方案，这一切都得益于经典的 “gmp” 模型。

       GMP = goroutine + machine + processor（+ 一套有机组合的机制），下面先单独拆出每个组件进行介绍，最后再总览全局，对 GMP 进行总述。

       G = goroutine，是 Golang 中对协程的抽象；（2）g 有自己的运行栈、状态、以及执行的任务函数（用户通过 go func 指定）；（3）g 需要绑定到 p 才能执行，在 g 的视角中，p 就是它的 cpu。

       P = processor，是 Golang 中的调度器；（2）p 是 gmp 的中枢，借由 p 承上启下，实现 g 和 m 之间的动态有机结合；（3）对 g 而言，p 是其 cpu，g 只有被 p 调度，才得以执行；（4）对 m 而言，p 是其执行代理，为其提供必要信息的同时（可执行的 g、内存分配情况等），并隐藏了繁杂的调度细节；（5）p 的数量决定了 g 最大并行数量，可由用户通过 GOMAXPROCS 进行设定（超过 CPU 核数时无意义）。

       M = machine，是 Golang 中对线程的抽象；（1）m 不直接执行 g，而是先和 p 绑定，由其实现代理；（3）借由 p 的存在，m 无需和 g 绑死，也无需记录 g 的状态信息，因此 g 在全生命周期中可以实现跨 m 执行。

       全局有多个 M 和多个 P，但同时并行的 G 的最大数量等于 P 的数量。G 的存放队列有三类：P 的本地队列；全局队列；和 wait 队列（图中未展示，为 io 阻塞就绪态 goroutine 队列）。

       M 调度 G 时，优先取 P 本地队列，其次取全局队列，最后取 wait 队列。这样的好处是，取本地队列时，可以接近于无锁化，减少全局锁竞争。为防止不同 P 的闲忙差异过大，设立 work-stealing 机制，本地队列为空的 P 可以尝试从其他 P 本地队列偷取一半的 G 补充到自身队列。

       核心数据结构定义于 runtime/runtime2.go 文件中，各个类的成员属性较多，这里只摘取核心字段进行介绍：g 的生命周期由以下几种状态组成：_Gidle（值为 0，为协程开始创建时的状态，此时尚未初始化完成）；_Grunnable（值为 1，协程在待执行队列中，等待被执行）；_Grunning（值为 2，协程正在执行，同一时刻一个 p 中只有一个 g 处于此状态）；_Gsyscall（值为 3，协程正在执行系统调用）；_Gwaiting（值为 4，协程处于挂起态，需要等待被唤醒. gc、channel 通信或者锁操作时经常会进入这种状态）；_Gdead（值为 6，协程刚初始化完成或者已经被销毁，会处于此状态）；_Gcopystack（值为 8，协程正在栈扩容流程中）；_Greempted（值为 9，协程被抢占后的状态）。

       文字性总结难免有些过于含糊和空洞，对一些细节的描述总是不够精确的。下面照旧开启源码走读流程，从代码中寻求理论证明和细节补充。

       gmp 数据结构定义为 runtime/runtime2.go 文件中，由于各个类的成员属性较多，那么只摘取核心字段进行介绍：（1）m：在 p 的代理，负责执行当前 g 的 m；（2）sched.sp：保存 CPU 的 rsp 寄存器的值，指向函数调用栈栈顶；（3）sched.pc：保存 CPU 的 rip 寄存器的值，指向程序下一条执行指令的地址；（4）sched.ret：保存系统调用的返回值；（5）sched.bp：保存 CPU 的 rbp 寄存器的值，存储函数栈帧的起始位置。其中 g 的生命周期由以下几种状态组成：（1）_Gidle（值为 0，为协程开始创建时的状态，此时尚未初始化完成）；（2）_Grunnable（值为 1，协程在待执行队列中，等待被执行）；（3）_Grunning（值为 2，协程正在执行，同一时刻一个 p 中只有一个 g 处于此状态）；（4）_Gsyscall（值为 3，协程正在执行系统调用）；（5）_Gwaiting（值为 4，协程处于挂起态，需要等待被唤醒. gc、channel 通信或者锁操作时经常会进入这种状态）；（6）_Gdead（值为 6，协程刚初始化完成或者已经被销毁，会处于此状态）；（7）_Gcopystack（值为 8，协程正在栈扩容流程中）；（8）_Greempted（值为 9，协程被抢占后的状态）。

       其中，goroutine 的类型可分为两类：（1）I 负责调度普通 g 的 g0，执行固定的调度流程，与 m 的关系为一对一；（2）II 负责执行用户函数的普通 g。m 通过 p 调度执行的 goroutine 永远在普通 g 和 g0 之间进行切换。

       主动调度是用户主动执行让渡的方式，主要方式是，用户在执行代码中调用了 runtime.Gosched 方法，此时当前 g 会当让出执行权，主动进行队列等待下次被调度执行。被动调度因当前不满足某种执行条件，g 可能会陷入阻塞态无法被调度，直到关注的条件达成后，g 才从阻塞中被唤醒，重新进入可执行队列等待被调度。

       正常调度指的是 g 中的执行任务已完成，g0 会将当前 g 置为死亡状态，发起新一轮调度。抢占调度指的是 g 执行系统调用超过指定的时长，且全局的 p 资源比较紧缺，此时将 p 和 g 解绑，抢占出来用于其他 g 的调度。

       调度流程的主干方法是位于 runtime/proc.go 中的 schedule 函数。在宏观调度流程中，我们可以尝试对 gmp 的宏观调度流程进行整体串联，包括：（1）以 g0 -> g -> g0 的一轮循环为例进行串联；（2）g0 执行 schedule() 函数，寻找到用于执行的 g；（3）g0 执行 execute() 方法，更新当前 g、p 的状态信息，并调用 gogo() 方法，将执行权交给 g；（4）g 因主动让渡（gosche_m()）、被动调度（park_m()）、正常结束（goexit0()）等原因，调用 m_call 函数，执行权重新回到 g0 手中；（5）g0 执行 schedule() 函数，开启新一轮循环。

       在 Golang 中，调度流程的主干方法是位于 runtime/proc.go 中的 schedule 函数，此时的执行权位于 g0 手中。在 findRunnable 方法中，调度流程中，一个非常核心的步骤就是为 m 寻找到下一个执行的 g。在 execute 方法中，当 g0 为 m 寻找到可执行的 g 之后，接下来就开始执行 g。

       在 g 执行主动让渡时，会调用 mcall 方法将执行权归还给 g0，并由 g0 调用 gosched_m 方法。在 g 需要被动调度时，会调用 mcall 方法切换至 g0，并调用 park_m 方法将 g 置为阻塞态。当 g 执行完成时，会先执行 mcall 方法切换至 g0，然后调用 goexit0 方法。与 g 的系统调用有关的，视角切换回发生系统调用前，与 g 绑定的原 m 当中，此时执行权同样位于 m 的 g0 手中。在 m 需要执行系统调用前，会先执行位于 runtime/proc.go 的 reentersyscall 的方法。当 m 完成了内核态的系统调用之后，此时会步入位于 runtime/proc.go 的 exitsyscall 函数中。

       与 g 的系统调用有关的，视角切换回发生系统调用前，与 g 绑定的原 m 当中，在 m 需要执行系统调用前，会先执行位于 runtime/proc.go 的 reentersyscall 的方法。当 m 完成了内核态的系统调用之后，此时会步入位于 runtime/proc.go 的 exitsyscall 函数中。

       当 g 执行完成时，会先执行 mcall 方法切换至 g0，然后调用 goexit0 方法。当 m 完成了内核态的系统调用之后，此时会步入位于 runtime/proc.go 的 exitsyscall 函数中。

       对于抢占调度的执行者，不是 g0，而是一个全局的 monitor g，代码位于 runtime/proc.go 的 retake 方法中。与 g 的系统调用有关的，视角切换回发生系统调用前，与 g 绑定的原 m 当中，在 m 需要执行系统调用前，会先执行位于 runtime/proc.go 的 reentersyscall 的方法。当 m 完成了内核态的系统调用之后，此时会步入位于 runtime/proc.go 的 exitsyscall 函数中。

       在 Golang 中，调度流程的主干方法是位于 runtime/proc.go 中的 schedule 函数，此时的执行权位于 g0 手中。在 findRunnable 方法中，调度流程中，一个非常核心的步骤就是为 m 寻找到下一个执行的 g。在 execute 方法中，当 g0 为 m 寻找到可执行的 g 之后，接下来就开始执行 g。

       在 g 执行主动让渡时，会调用 mcall 方法将执行权归还给 g0，并由 g0 调用 gosched_m 方法。在 g 需要被动调度时，会调用 mcall 方法切换至 g0，并调用 park_m 方法将 g 置为阻塞态。当 g 执行完成时，会先执行 mcall 方法切换至 g0，然后调用 goexit0 方法。当 m 完成了内核态的系统调用之后，此时会步入位于

linux运行arm程序armlinux程序

       å¦‚何编译armlinux的go？

       Golang也就是Go语言，现在已经发行到1.4.1版本了，语言特性优越性和背后Google强大靠山什么的就不多说了。Golang的官方提供了多个平台上的二进制安装包，遗憾的是并非没有发布ARM平台的二进制安装包。ARM平台没办法直接从官网下载二进制安装包来安装，好在Golang是支持多平台并且开源的语言，因此可以通过直接在ARM平台上编译源代码来安装。整个过程主要包括编译工具配置、获取Golang源代码、设置Golang编译环境变量、编译、配置Golang行环境变量等步骤。

       æ³¨ï¼šæœ¬æ–‡é€‰ç”¨æ ‘莓派做测试，因为树莓派是基于ARM平台的。

       1、编译工具配置

       æ®è¯´ä¸‹ä¸ªç‰ˆæœ¬çš„golang编译工具要使用golang自己来写，但目前还是使用C编译工具的。因此，首先要配置好C编译工具：

       1.1在Ubuntu或Debian平台上可以使用sudoapt-getinstallgcclibc6-dev命令安装，树莓派的RaspBian系统是基于Debian修改的，所以可以使用这种方法安装。

       1.2在RedHat或CentOS6平台上可以使用sudoyuminstallgcclibc-devel命令安装。

       å®‰è£…完成后可以输入gcc--version命令验证是否成功安装。

       2、获取golang源代码

       2.1直接从官网下载源代码压缩包。

       golang官网提供golang的源代码压缩包，可以直接下载，最新的1.4.1版本源代码链接：/golang/go1.4.1.src.tar.gz

       2.2使用git工具获取。

       golang使用git版本管理工具，也可以使用git获取golang源代码。推荐使用这个方法，因为以后可以随时获取最新的golang源代码。

       2.2.1首先确认ARM平台上已经安装了git工具，可以使用git--version命令确认。一般linux平台都安装了git，没有的话可以自行安装，不同平台的安装方法可以参考：/download/linux

       2.2.2克隆远程golang的git仓库到本地

       åœ¨ç»ˆç«¯cd到你想要安装golang的目录，确保该目录下没有名为go的目录。然后以下命令获取代码仓库：

       gitclone/go

       å¤§é™†åœ°åŒºå¯èƒ½ä¼šèŽ·å–失败，在不翻墙的情况下我试了几次都没成功，原因大家都懂的。好在google已经将golang也托管到github上面，所以也可以通过下面命令获取：

       gitclone/golang/go.git

       è§†ç½‘络情况，下载可能需要不少时间。我2M的带宽花了将近两个小时才下载完，虽然整个项目不过几十兆==

       ä¸‹è½½å®ŒæˆåŽï¼Œå¯ä»¥çœ‹åˆ°ç›®å½•ä¸‹å¤šäº†ä¸€ä¸ªgo目录，里面即为golang的源代码，在终端上执行cdgo命令进入该目录。

       æ‰§è¡Œä¸‹é¢å‘½ä»¤æ£€å‡ºgo1.4.1版本的源代码，因为现在已经有新的代码提交上去了，最新的代码可能不是最稳定的：

       gitcheckoutgo1.4.1

       è‡³æ­¤ï¼Œæœ€æ–°1.4.1发行版的源代码获取完毕

       3、设置golang的编译环境变量

       ä¸»è¦æœ‰GOROOT、GOOS、GOARCH、GOARM四个环境变量需要设置，先解释四个环境变量的意义。

       3.1GOROOT

       ä¸»è¦ä»£è¡¨golang树结构目录的路径，也就是上面git检出的go目录。一般可以不用设置这个环境变量，因为编译的时候默认会以go目录下src子目录中的all.bash脚本运行时的父目录作为GOROOT的值。为了保险起见，可以直接设置为go目录的路径。

       3.2GOOS和GOARCH

       åˆ†åˆ«ä»£è¡¨ç¼–译的目标系统和平台，可选值如下：

       GOOSGOARCH

       darwin

       darwinamd

       dragonfly

       dragonflyamd

       freebsd

       freebsdamd

       freebsdarm

       linux

       linuxamd

       linuxarm

       netbsd

       netbsdamd

       netbsdarm

       openbsd

       openbsdamd

       plan

       plan9amd

       solarisamd

       windows

       windowsamd

       éœ€è¦æ³¨æ„çš„是这两个值代表的是目标系统和平台，而不是编译源代码的系统和平台。树莓派的RaspBian是linux系统，所以这些GOOS设置为linux，GOARCH设置为arm。

       3.3GOARM

       è¡¨ç¤ºä½¿ç”¨çš„浮点运算协处理器版本号，只对arm平台有用，可选值有5，6，7。如果是在目标平台上编译源代码，这个值可以不设置，它会自动判断需要使用哪一个版本。

       æ€»ç»“下来，在树莓派上设置golang的编译环境变量，可编辑$HOME/.bashrc文件，在末尾添加下面内容：

       exportGOROOT=你的go目录路径

       exportGOOS=linux

       exportGOARCH=arm

       ç¼–辑完后保存，执行source~/.bashrc命令让修改生效。

       4、编译源代码

       çŽ¯å¢ƒå˜é‡é…ç½®å®Œæˆè‡ªåŽå°±å¯ä»¥å¼€å§‹ç¼–译源代码。在go目录下的src子目录中，主要有all.bash和make.bash两个脚本（另外还有两个all.bat和make.bat脚本适用于window平台）。编译实际上就是执行其中一个脚本，两者的区别在于all.bash在编译完成后还会执行一些测试套件。如果希望只编译不测试，可以运行make.bash脚本。使用cd命令进入go下src目录，执行./all.bash或者./make.bash命令即可开始编译。由于硬件情况不同，编译耗费的时间不同。在我的B型树莓派编译过程花费了将近半个小时，编译完成后执行的测试套件又花费了差不多一个小时，总共花费了一个半小时左右。

       5、配置golang运行环境变量

       ç¼–译完成后，go目录下会生成bin目录，里面就是go的运行脚本。为了以后使用方法，可以将这个bin路径添加到PATH环境变量中。同样编辑~/.bashrc文件，因为前面设置过GOROOT环境变量指向go目录了，所以只需要在末尾加上

       exportPATH=$PATH:$GOROOT/bin

       ä¿å­˜åŽåŒæ ·æ‰§è¡Œsource~/.bashrc命令让环境变量生效。

       è‡³æ­¤ï¼Œgolang源代码编译安装成功。执行goversion应该就能看到当前golang的版本信息，表示编译安装成功。

       linux下ARM平台编译编写的完成程序如何在windows环境下运行？

       ç›´æŽ¥åœ¨window下运行不了。只能在window下安装虚拟机，再安装linux系统，在虚拟机下的linux里gcc编译你的程序.

       arm技术需要学什么专业？

       åˆšå¼€å§‹ï¼š1）学习Linux系统安装、常用命令、应用程序安装。2）学习Linux下的C编程、这本书必学《UNIX环境高级编程》、《UNIX网络编程》，RechardStevens写的，C高手大都学习过《C和指针》、《C缺陷与陷阱》、《高质量C/C++编程指南》、《C专家编程》、《TheCprogrammingLanguage》3）程序员大都要学：数据结构，嵌入式程序员数据结构必学！4）底层开发人员大都要学：微机原理、计算机体系结构，嵌入式开发人员必学！5）单片机可以让一个从事软件开发的人了解和如何操作硬件，有必要学，因为一开始就从ARM入手，不太现实！6）ARM体系结构，其中有汇编。7）数字电路有必要学习，不然你在做底层开发时真的会不知道怎么看原理图，起码也得懂与入门吧。8）ARM+Linux应用程序开发（前提是要有开发板）到此，勉强算是在嵌入式Linux这个行业有了初步入门了，但遗憾的是这还远远不够，还得继续，因为这上嵌入式，得变成高手。9）要做底层开发，就必须知道软硬件之间是如何衔接和配合工作的，那么电子技术应该要好好学习了，很多时候会用到模拟电路知识，这是区别好手与菜鸟的不同之处之一。）Linux下的汇编要学，这样你才能真正了解你写的程序是如何在一个特定的硬件上跑的。这是区别好手与菜鸟的不同之处之二。）TCP/IP协议栈要学，所有的嵌入式高手都得掌握的东西，这是区别好手与菜鸟的不同之处之三。）有了这些东西，拿下Linux驱动已经不再话下，需要你去学习Linux内核源代码和Linux驱动程序设计，这是一个技术升华。到此，你已经算是嵌入式Linux的中级人物了，继续往下：）音频、视频的解码译码技术你得学。）各种IC，各种bootloader你能够参与其开发设计。）自行设计开发新产品，新技术。

       arm版的ubuntu可以安装什么软件?可以和xubuntu的软件通用吗？

       æž¶æž„不一样一个x一个arm，软件不能通用，不过linux一般都提供源代码的，用arm-linux-gcc编译一下就能用了.

技术干货！DPDK新手入门到网络功能深入理解

       DPDK新手入门

       一、安装

       1. 下载源码

       DPDK源文件由几个目录组成。

       2. 编译

       二、配置

       1. 预留大页

       2. 加载 UIO 驱动

       三、运行 Demo

       DPDK在examples文件下预置了一系列示例代码，这里以Helloworld为例进行编译。

       编译完成后会在build目录下生成一个可执行文件，通过附加一些EAL参数可以运行起来。

       以下参数都是比较常用的

       四、核心组件

       DPDK整套架构是基于以下四个核心组件设计而成的

       1. 环形缓冲区管理(librte_ring)

       一个无锁的多生产者，多消费者的FIFO表处理接口，可用于不同核之间或是逻辑核上处理单元之间的通信。

       2. 内存池管理(librte_mempool)

       主要职责是在内存中分配用来存储对象的pool。 每个pool以名称来唯一标识，并且使用一个ring来存储空闲的对象节点。 它还提供了一些其他的服务，如针对每个处理器核心的缓存或者一个能通过添加padding来使对象均匀分散在所有内存通道的对齐辅助工具。

       3. 网络报文缓冲区管理(librte_mbuf)

       它提供了创建、释放报文缓存的能力，DPDK应用程序可能使用这些报文缓存来存储数据包。这个缓存通常在程序开始时通过DPDK的mempool库创建。这个库提供了创建和释放mbuf的API，能用来暂存数据包。

       4. 定时器管理(librte_timer)

       这个模块为DPDK的执行单元提供了异步执行函数的能力，也能够周期性的触发函数。它是通过环境抽象层EAL提供的能力来获取的精准时间。

       五、环境抽象层（EAL）

       EAL是用于为DPDK程序提供底层驱动能力抽象的，它使DPDK程序不需要关注下层具体的网卡或者操作系统，而只需要利用EAL提供的抽象接口即可，EAL会负责将其转换为对应的API。

       六、通用流rte_flow

       rte_flow提供了一种通用的方式来配置硬件以匹配特定的Ingress或Egress流量，根据用户的任何配置规则对其进行操作或查询相关计数器。

       这种通用的方式细化后就是一系列的流规则，每条流规则由多种匹配模式和动作列表组成。

       一个流规则可以具有几个不同的动作(如在将数据重定向到特定队列之前执行计数，封装，解封装等操作)，而不是依靠几个规则来实现这些动作，应用程序操作具体的硬件实现细节来顺序执行。

       1. 属性rte_flow_attr

       a. 组group

       流规则可以通过为其分配一个公共的组号来分组，通过jump的流量将执行这一组的操作。较低的值具有较高的优先级。组0具有最高优先级，且只有组0的规则会被默认匹配到。

       b. 优先级priority

       可以将优先级分配给流规则。像Group一样，较低的值表示较高的优先级，0为最大值。

       组和优先级是任意的，取决于应用程序，它们不需要是连续的，也不需要从0开始，但是最大数量因设备而异，并且可能受到现有流规则的影响。

       c. 流量方向ingress or egress

       流量规则可以应用于入站和/或出站流量(Ingress/Egress)。

       2. 模式条目rte_flow_item

       模式条目类似于一套正则匹配规则，用来匹配目标数据包，其结构如代码所示。

       首先模式条目rte_flow_item_type可以分成两类：

       同时每个条目可以最多设置三个相同类型的结构：

       a. ANY可以匹配任何协议，还可以一个条目匹配多层协议。

       b. ETH

       c. IPv4

       d. TCP

       3. 操作rte_flow_action

       操作用于对已经匹配到的数据包进行处理，同时多个操作也可以进行组合以实现一个流水线处理。

       首先操作类别可以分成三类：

       a. MARK对流量进行标记，会设置PKT_RX_FDIR和PKT_RX_FDIR_ID两个FLAG，具体的值可以通过hash.fdir.hi获得。

       b. QUEUE将流量上送到某个队列中

       c. DROP将数据包丢弃

       d. COUNT对数据包进行计数，如果同一个flow里有多个count操作，则每个都需要指定一个独立的id，shared标记的计数器可以用于统一端口的不同的flow一同进行计数。

       e. RAW_DECAP用来对匹配到的数据包进行拆包，一般用于隧道流量的剥离。在action定义的时候需要传入一个data用来指定匹配规则和需要移除的内容。

       f. RSS对流量进行负载均衡的操作，他将根据提供的数据包进行哈希操作，并将其移动到对应的队列中。

       其中的level属性用来指定使用第几层协议进行哈希：

       g. 拆包Decap

       h. One\Two Port Hairpin

       七、常用API

       1. 程序初始化

       2. 端口初始化

       3. 队列初始化

       DPDK-网络协议栈-vpp-ovs-DDoS-虚拟化技术

       DPDK技术路线视频教程地址立即学习

       一、DPDK网络

       1. 网络协议栈项目

       2.dpdk组件项目

       3.dpdk经典项目

       二、DPDK框架

       1. 可扩展的矢量数据包处理框架vpp(c/c++)

       2.DPDK的虚拟交换机框架OvS

       3.golang的网络开发框架nff-go(golang)

       4. 轻量级的switch框架snabb(lua)

       5. 高效磁盘io读写spdk(c)

       三、DPDK源码

       1. 内核驱动

       2. 内存

       3. 协议

       4. 虚拟化

       5. cpu

       6. 安全

       四、性能测试

       1. 性能指标

       2. 测试方法

       3. 测试工具DPDK相关学习资料分享：点击领取，备注DPDK

       DPDK新手入门原文链接：DPDK上手