1.深入理解Linux的源码epoll机制
2.io_uring – 我们为什么会需要 io_uring
3.让事件飞 ——Linux eventfd 原理与实践
4.新CPU特性 - User space interrupt
5.从kvmtools学习虚拟化七 Virtio Console的实现
6.Linux fd 系列 — socket fd 是什么？

深入理解Linux的epoll机制

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

IO多路复用

       在Go里最核心的分析是Goroutine，也就是源码所谓的协程，协程最妙的分析vbs病毒源码6一个实现就是异步的代码长的跟同步代码一样。比如在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的错误即可，不会卡住线程，从而整个系统就运转起来了。比如上面句柄还未就绪，那么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，java源码保卫萝卜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池的？敬请期待哦。

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

io_uring – 我们为什么会需要 io_uring

       Linux的文件操作方式多种多样，最早的read和write接口简洁直观，但效率不高。随后出现了pread和pwrite等接口，允许直接传递offset，提高了代码的健壮性。后来又出现了可以一次性发送多个IO的接口，如preadv和pwritev，以及变种函数preadv2和pwritev2，它们不仅可以发送向量型的IO，还能设置IO标志。

       上述接口都是同步接口，意味着在读写IO时，调用者会阻塞等待结果。这对于传统编程模型来说问题不大，但在高效情况下，同步IO会导致调用者无法执行其他操作。异步IO模型则允许调用者将IO buffer提交给内核，然后继续执行其他操作，内核处理完毕后主动通知调用者。例如，一个ftp服务器在处理文件上传时，如果忙于等待文件读写结果，就会拒绝其他客户机的请求。

       异步IO模型有poll/epoll和非阻塞轮询模式，以及异步模式。AIO应运而生，提供了aio_read和aio_write等标准接口，但存在许多缺陷，如不支持buffer-io、API函数不友好等，导致在实际生产环境中应用较少。

       为了解决这些问题，需要设计一个简单、可扩展、功能丰富、高效的接口。io_uring就是这样一种接口，它比AIO更优秀，可以减少系统调用次数，提高效率，并提供多种优化方案，如sqo_thread、io_poll模式、fixed_file模式和fixed_buffer模式等。

       io_uring通过setup系统调用创建fd，使用mmap内存实现内核与核外的交互。它可以通过eventfd或SIGIO通知核外收割IO完成事件，通过io_uring的poll模式实现统一的编程模型。io_uring_enter可以回收完成状态，sqo_thread可以自动发送数据，io_poll模式可以加速IO推进，fixed_file和fixed_buffer模式可以减少内存拷贝和基础信息检测。

       io_uring提供了多种优化方案，可以根据实际情况进行组合，实现高效的IO处理。

让事件飞 ——Linux eventfd 原理与实践

       在当今的程序设计中，事件驱动的方式变得越来越普遍。为了有效地利用系统资源并实现通知的管理和送达，Linux 系统中提供了事件通知的机制，如 eventfd 和 timerfd。这两个机制，前者用于触发事件通知，后者则用于定时器事件通知。

       使用 eventfd 时，开发者只需包含相应的头文件即可。创建一个 eventfd 对象，类似于普通文件的 open 操作，该对象内部维护一个无符号的 位计数器，初始化值为用户指定。事件通知可通过两种操作实现：read 操作将计数器值置零，而 write 操作用于设置计数器值。同时，该对象支持 epoll/poll/select 操作，以及关闭操作。

       对于 timerfd，开发者需调用 timerfd_create 函数创建新的 timerfd 对象，指定时钟类型，通常选择实时时钟（CLOCK_REALTIME）或单调递增时钟（CLOCK_MONOTONIC）。timerfd_settime 函数用于设置定时器的过期时间，其中包含首次过期时间及周期性触发的间隔时间。timerfd_gettime 函数用于获取当前设置值，而 read 操作返回已过期的次数或阻塞至过期，取决于是否设置了 NONBLOCK 标志。

       使用实例展示了如何实现高性能的消费者线程池，通过生产者-消费者设计模式，将 eventfd 和 timerfd 用于事件通知。消费者线程池中的线程共用一个 epoll 对象，通过 epoll_wait 以轮询方式处理针对 eventfd 或 timerfd 触发的事件。在 eventfd 实现中，推荐在打开时设置 NON_BLOCKING，并在 epoll 监听对象上设置 EPOLLET，以发挥非阻塞 IO 和边沿触发的最大并发能力。

       在 timerfd 实现中，main 函数和消费者线程与 eventfd 类似，而生产者线程则创建 timerfd 并将其注册到事件循环中。timer 的 it_value 设为 1 秒，it_interval 设为 3 秒，用于设置定时器事件。执行过程与 eventfd 类似，通过 epoll 监控 timerfd 触发的事件。

       事件通知场景中，使用 eventfd/timerfd 相较于 pipe 有显著的优势，主要体现在资源管理和性能方面。在信号通知场景下，eventfd/timerfd 与 pipe 相比，提供了更高效的资源利用和性能。因此，当 pipe 仅用于发送通知而非数据传输时，应优先选择 eventfd/timerfd。

       eventfd/timerfd 与 epoll 结合使用时，可实现非阻塞的读取等特性，进一步提升性能。同时，这两个机制的设计使得它们与 epoll 的集成更加紧密，能够支持在监控其他文件描述符状态的同时，同时监控内核通知机制。这为应用程序提供了更高效和灵活的事件处理方式。

       在内核源码中，eventfd 的实现作为系统调用在 fs/eventfd.c 下实现在 2.6. 版本中引入，并在 2.6. 版本后增加了对 flag 的支持。其核心数据结构是 eventfd_ctx，包含一个 位计数器和其他相关组件。read 函数通过加锁实现对计数器的独占访问，并在阻塞或非阻塞模式下返回相应的结果。write 函数则同步更新计数器值并唤醒等待队列中的线程。poll 操作则用于监控 eventfd 的可读事件状态。

       总结而言，eventfd/timerfd 提供了高效和简单的事件通知机制，内核源码中实现了这些机制的精巧高效性。这些机制不仅功能实用，而且调用方式简单，为用户态应用程序封装了高效的事件通知机制，同时也与 epoll 等系统功能高度集成，提供了丰富的事件处理方式。

       

参考资料：

       - Linux 内核源码：elixir.bootlin.com/linu...

       - Linux Programmer's Manual：eventfd(2) - Linux manual page

新CPU特性 - User space interrupt

       Intel的新CPU架构Sapphire Rapid支持用户态接收中断，其第三点特别指出，设备可以直接与用户态处理程序进行通信，从而避免了使用DPDK等黑客式技术的必要。此功能支持嵌套中断。

       发送中断通过SENDUIPI指令实现，指令格式为senduipi reg，其中reg参数代表中断索引编号。在执行此指令后，硬件会基于UITT（user interrupt target table）查找中断接收方的UPID（user posted interrupt descriptor），并对此UPID进行中断标记设置。随后，一个IPI中断被硬件发出到目标CPU，中断向量为UPID.Notification vector。目标CPU收到IPI中断，通过ACPI中断进行用户态中断识别，若识别为UINTR_NOTIFICATION_VECTOR，则进入用户态中断处理流程。否则，按普通中断处理方式执行。

       用户态中断的基础设施包括UITT，用于建立中断发送方和接收方的连接，UPID描述中断信息，包括中断接收CPU、中断向量等。硬件处理流程涉及UITT和UPID的使用，SENDUIPI指令执行后，硬件完成中断接收方UPID的查找和标记设置，然后发出IPI中断到目标CPU。目标CPU收到IPI中断后，进行用户态中断识别和处理。

       Linux内核目前支持sendUIPI，允许用户态到用户态的中断发送。为了支持这一功能，内核实现了一系列syscall，辅助构建硬件工作所需的数据结构。

       用户态发送IPI时，与使用共享内存相比，意义可能不大。不过，这种方法确实可以减少发送者进入内核态的开销，但对接收方来说，仍需从内核态唤醒。在某些场景下，如替代io-uring的eventfd，使用UIPI可能展现出一定优势，但具体收益需要进一步分析。

从kvmtools学习虚拟化七 Virtio Console的实现

       设备与驱动之间的IO

       我们将重点放在驱动如何同时处理设备请求，以及设备处理完毕后如何通知驱动上。此过程可细分为同步IO与异步IO两种模式。

       同步IO模式中，设备处理期间，虚拟机被挂起，等待设备处理完毕后才继续运行。这种模式下，整个过程图示显示设备处理的延迟对虚拟机运行产生了显著影响。

       异步IO模式下，内核仅挂起发起IO的任务，并继续运行其他任务。这样，模拟设备可以将处理过程抽象为另一个线程，与Guest虚拟的cpu线程协同执行。异步模式下的流程图示展示了这种模式下的高效性。

       最初，kvmtool仅使用一个线程，为避免线程初始化的开销，后增加了线程池机制。每当请求到来，kvmtool就将请求队列加入线程池，唤醒线程处理请求。

       总结上述过程，无论是同步还是异步IO，Guest每次请求都需要经历从Guest到Host内核态，再到Host用户态的切换。这种内核态切换的开销高昂，因此寻求直接在内核态唤醒用户空间线程的方法。

       为此，KVM开发者基于eventfd设计了ioeventfd概念，eventfd是一个通知事件的文件描述符。在kvmtool中，模拟设备创建eventfd并通知内核KVM模块监听。Guest因IO导致vmexit时，处理函数直接唤醒等待在eventfd上的kvmtool监听线程，然后继续在虚拟机中执行。

       监听线程被唤醒后，完成virtio queue中的任务，并通过kvm__irq_line()向Guest注入中断，通知Guest处理完毕。这一过程在KVM的ioevent实现中展现得尤为清晰。

       轻量虚拟机退出的实现细节

       针对轻量虚拟机退出，KVM模块提供ioctl(vm_fd, KVM_IOEVENTFD, &kvm_ioevent) API，将ioeventfd挂载到Guest内部的pmio或mmio地址上。每当Guest尝试写入该地址，会直接从内核态唤醒对应事件，无需切换回用户态。

       kvm_ioevent的定义包括设置KVM_IOEVENTFD_FLAG_DATAMATCH标志，当虚拟机向地址写入的值等于datamatch时才会触发事件。kvmtool封装了KVM提供的API，形成自己的ioeventfd模块，使用struct ioevent描述监听的ioevent。

       在虚拟机初始化时，init_list__init()调用ioeventfd__init()初始化KVM的ioeventfd模块，创建事件监听epoll_fd并启动线程处理监听的所有fd事件。ioevent模块还提供了ioeventfd__add_event()函数添加监听事件。

       Virtio Console的工作流程

       在执行具体IO前，需搭建Virtqueue基础设施。Virtio协议规定Guest中的驱动负责Virtio queue的管理，因此初始化部分位于linux内核的drivers/virtio/virtio_pci.c中。

       Virtio协议还规定设备负责如Virtqueue大小等参数的设定，这些参数映射到BAR[0]指向的地址中。

       首先，驱动向Virtio设备的Device Status中写入Device Acknowledged和Driver Loaded标志，表示设备发现与驱动加载完成。Device Status属于virtio header的一部分。

       接着，驱动向QUEUE NOTIFY寄存器注册ioevent，Guest写入时触发回调函数。总体流程包括注册ioevent，初始化队列，调用notify_vq函数处理请求。

       最终，virtio_pci__ioevent_callback()调用通知队列的处理函数，输出数据到STDOUT，显示虚拟机输出。同时，处理输入数据并发送到虚拟机中。

       综上所述，kvmtool采用线程模型处理virtio console设备，实现高效IO操作与轻量虚拟机退出。

Linux fd 系列 — socket fd 是什么？

       在Linux系统中，socket fd 是一种网络文件描述符，实质上是一种用于网络通信的文件句柄。它在客户端和服务端的C/S编程模式中被广泛使用，实现网络数据的读写操作。尽管网络通信接口与文件读写接口在表面上有细微差别，但实质上都是I/O操作，即数据的输入输出。

       例如，当我们查看进程的文件描述符时，会发现其中包含了7、8两个socket fd，其名称为"socket:[]"。这一名称包含了该fd的类型信息，类似于文件fd后紧跟的路径名称。这个inode编号在其他地方也能看到，如在proc目录下的net子目录中，对于使用tcp协议的服务端，我们能查看到与连接状态相关的信息。

       实际上，socket fd与文件句柄在功能上并无本质区别，二者都能实现基本的I/O操作。在理解socket fd时，我们应将其与TCP/IP协议栈区别开来。尽管TCP/IP协议栈是网络通信的基础，但进行网络编程时，操作系统的socket接口更为直观和实用。

       在描述socket fd时，我们首先需要了解环境和术语基础，Linux内核版本为4.，假设未特别说明协议时默认为TCP协议。socket是一个常见的术语，用于指代Linux网络编程中的套接字接口。网络模型通常包括网络协议栈的不同层次，每层执行特定任务，通过不断封装实现更高级功能。

       在Linux环境下，网络编程往往被称为套接字编程，这是因为socket接口为程序员提供了与网络通信相关的简化接口。例如，进行基于TCP的C/S网络程序开发时，主要涉及socket的创建、读写和关闭过程。socket的创建通过socket(int domain, int type, int protocol)函数实现，类似于文件句柄的获取。

       网络模型通常分为两层，上层为应用层，下层为协议层。不同层次之间通过封装实现，使得应用层程序员能够专注于业务逻辑，而无需关心底层细节。在Linux系统中，套接字位于所有网络协议之上，提供了一种统一的接口，用于执行网络通信操作。

       监听套接字与普通套接字是两种不同的类型。监听套接字仅用于管理连接的建立，而普通套接字则用于数据流传输。监听套接字在可读事件中关注的是连接队列的非空状态，而普通套接字则关注可读和可写事件。

       为了使socket fd具备文件句柄的语义，Linux内核实现了sockfs文件系统。这个系统为socket提供了统一的接口，与eventfd、ext2 fd等句柄一样，实现对外I/O操作的一致性。sockfs文件系统的核心在于sock_mnt全局变量中的超级块操作表sockfs_ops，该表指明了inode分配规则。

       在理解inode与具体文件系统（如ext4）之间的关系时，我们发现inode是vfs抽象的适配所有文件系统的结构体，由具体文件系统分配。在Linux中，inode与不同文件系统中的特定结构体（如ext4_inode_info）关联，通过强制类型转化在不同层次之间切换。

       类似地，sockfs文件系统也有自己的“inode”结构，即struct socket_alloc。这个结构体关联了socket与inode，是文件抽象的核心之一。socket的创建过程实际上是创建了一个struct socket_alloc结构体，并返回了其中的socket字段地址。

       对于socket编程，我们需要关注服务端和客户端的几个关键函数。服务端主要涉及socket、bind、listen、accept等函数；客户端则通常使用socket、connect等函数。下面简要描述了这几个函数的实现。

       socket函数主要负责创建socket，并根据协议族查找对应的操作表。内核中涉及的函数调用包括sock_create、sock_init_data等，这些函数初始化了socket结构体，包括接收队列和发送队列的初始化，以及socket唤醒回调的设置。

       bind函数用于将socket与特定的IP和端口号关联。对于客户端，尽管可以调用bind，但通常没有必要，因为内核会在建立连接时自动选择端口号。服务端则必须使用bind明确指定监听的IP和端口。

       listen函数将普通socket转换为监听socket，使socket能够接收连接请求。listen系统调用执行的主要任务是将socket置于监听状态，并在连接请求队列中等待新连接。

       accept函数从连接队列中接受新连接，并返回一个新的socket描述符。当监听套接字可读时，意味着有新连接可用，accept函数被调用以处理这些连接。

       最后，我们回顾了socket fd与文件句柄之间的关系，以及如何通过epoll机制实现对socket fd的高效事件管理。epoll机制允许我们注册socket fd并监听其可读、可写事件，以实现高效的异步I/O操作。通过理解socket fd和相关函数的实现，我们可以更深入地掌握Linux网络编程的技巧。

Android组件系列：再谈Handler机制（Native篇）

       前文已介绍过Java层Handler机制的设计与实现，本篇将深入探讨Native层的Looper#loop()为何不会卡死主线程的原理。

       从Android 2.3版本开始，Google将Handler的阻塞/唤醒机制从Object#wait() / notify()改为了利用Linux epoll来实现，为的是在Native层引入一套消息管理机制，以支持C/C++开发者。

       在Native层实现类似Java层的阻塞/唤醒机制，主要面临两种选择：要么继续使用Object#wait() / notify()，通过Java层通知Native层何时唤醒；要么在Native层重新实现一套阻塞/唤醒方案，并通过JNI调用Java层进入阻塞态。最终，Google选择了后者。

       虽然将Java层的阻塞/唤醒机制直接移植到Native层并非必要，使用pthread_cond_wait也能实现相同效果，但epoll提供了一种更高效、更灵活的方案，特别是对于监听多个流事件的需求。

       理解I/O多路复用之epoll

       epoll是Linux I/O多路复用实现之一，与select和poll并列。它能够高效地同时监听多个流事件，而无需为每个流创建单独的线程或阻塞CPU资源。

       epoll通过将流事件转发到用户空间，让用户程序能实时响应事件。为了实现这一功能，epoll与eventfd配合使用。eventfd提供了一个用于累计计数的特殊文件描述符，只有当有新事件发生时，用户程序才能从eventfd中读取到计数增加。

       Native Handler机制解析

       Native层Handler机制的核心是Looper、MessageQueue和epoll+eventfd的组合。以下是关键步骤：

       消息队列初始化

       消息队列初始化涉及创建Looper对象，该对象持有mEpollFd和mWakeEventFd两个关键对象。mWakeEventFd用于监听消息队列的新消息，而mEpollFd用于管理监听的流事件。

       消息循环与阻塞

       Java和Native层的消息队列创建后，线程将阻塞在Looper#loop()方法中。在Java层，消息队列的循环与阻塞由nativePollOnce()方法实现，最终调用到NativeMessageQueue#pollOnce()方法。这个方法将请求转发给Looper#pollOnce()方法执行。

       消息发送与唤醒机制

       发送消息时，无论是Java还是Native层，最终都会调用到唤醒线程的方法。Java中，通过nativeWake()方法唤醒，而Native层直接通过write()方法向mWakeEventFd写入值来唤醒线程。

       唤醒后的消息分发处理

       线程唤醒后，首先判断唤醒原因，然后根据不同的情况执行相应的逻辑。关键步骤包括检查mWakeEventFd、处理Native层消息、处理自定义fd的事件等。

       结语

       通过深入理解epoll机制及其与Native Handler的集成，我们可以清晰地理解Handler机制的底层实现。理解了这些关键技术点后，开发者能够更深入地掌握并优化Android应用中的消息处理逻辑。