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，也就是源码所谓的协程，协程最妙的分析多目标优化智能算法源码一个实现就是异步的代码长的跟同步代码一样。比如在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的时候，如果数据没准备好，spring源码入手返回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，attr 方法源码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应用中的消息处理逻辑。