當(dāng)你在虛擬機(jī)中流暢傳輸文件時，是否想過背后是誰在高效調(diào)度 IO 資源？當(dāng)云計算平臺承載千萬級并發(fā)請求時，又是誰在底層保障數(shù)據(jù)通路的穩(wěn)定？答案藏在一個低調(diào)卻關(guān)鍵的技術(shù)里 ——virtio。作為 Linux IO 虛擬化的 “隱形引擎”，virtio 用獨特的半虛擬化設(shè)計，架起了虛擬機(jī)與物理設(shè)備間的高效橋梁。它跳過傳統(tǒng)虛擬化的性能損耗陷阱，用極簡接口實現(xiàn)接近原生的 IO 速度，如今已成為 KVM、QEMU 等主流虛擬化方案的 “標(biāo)配心臟”。

但 virtio 的魔力遠(yuǎn)不止于此：環(huán)形緩沖區(qū)如何實現(xiàn)零拷貝傳輸？前端驅(qū)動與后端設(shè)備如何默契配合？中斷機(jī)制又藏著怎樣的優(yōu)化智慧？今天，我們就撕開技術(shù)面紗，從架構(gòu)邏輯到運(yùn)行細(xì)節(jié)，解密 virtio 成為 Linux IO 虛擬化核心的真正密碼。

Part1 Linux IO 虛擬化概述

簡單來說，虛擬化是通過 “軟件定義” 將物理硬件抽象邏輯化，實現(xiàn)邏輯資源與底層硬件的隔離，以達(dá)到物理硬件資源利用的最大化。其中，虛擬機(jī)技術(shù)便是虛擬化技術(shù)的典型代表，它可以在一臺物理主機(jī)上同時運(yùn)行多個相互隔離的虛擬機(jī)，每個虛擬機(jī)仿佛都擁有獨立的硬件資源，能夠運(yùn)行不同的操作系統(tǒng)和應(yīng)用程序。

在虛擬化的龐大體系中，Linux IO 虛擬化占據(jù)著舉足輕重的地位，主要負(fù)責(zé)處理虛擬機(jī)與物理硬件之間的輸入 / 輸出（I/O）通信，致力于突破 I/O 性能瓶頸。打個比方，若將虛擬機(jī)看作是一個個忙碌的工廠，不斷需要原材料（輸入數(shù)據(jù)）并輸出產(chǎn)品（輸出數(shù)據(jù)），那么 Linux IO 虛擬化就是優(yōu)化工廠運(yùn)輸線路和裝卸流程的關(guān)鍵技術(shù)，確保原材料和產(chǎn)品能夠快速、高效地進(jìn)出工廠，保障虛擬機(jī)在數(shù)據(jù)傳輸方面的順暢。

傳統(tǒng)的 Linux IO 虛擬化通常采用 Qemu 模擬的方式。當(dāng)客戶機(jī)中的設(shè)備驅(qū)動程序發(fā)起 I/O 操作請求時，KVM 模塊中的 I/O 操作捕獲代碼會首先攔截該請求，隨后將 I/O 請求信息存放到 I/O 共享頁，并通知用戶空間的 Qemu 程序。Qemu 模擬程序獲取 I/O 操作的具體信息后，交由硬件模擬代碼模擬此次 I/O 操作，完成后將結(jié)果放回 I/O 共享頁，再通知 KVM 模塊中的 I/O 操作捕獲代碼，最后由捕獲代碼讀取操作結(jié)果并返回給客戶機(jī)。

這種模擬方式雖然靈活性高，能夠通過軟件模擬出各種硬件設(shè)備，且無需修改客戶機(jī)操作系統(tǒng)就能使模擬設(shè)備正常工作，為軟件開發(fā)及調(diào)試提供了便利，但是缺點也很明顯。每次 I/O 操作路徑長，會頻繁發(fā)生 VMEntry、VMExit ，需要多次上下文切換，就像接力賽中選手不斷交接接力棒，耗時費(fèi)力。同時，多次的數(shù)據(jù)復(fù)制操作進(jìn)一步降低了效率，導(dǎo)致整體性能不佳。在一些對 I/O 性能要求嚴(yán)苛的場景，如大規(guī)模數(shù)據(jù)處理、實時通信等，傳統(tǒng)的 Qemu 模擬 I/O 設(shè)備的方式往往難以滿足需求。

Part2 Linux IO 虛擬化中virtio

2.1 virtio 是什么

virtio 是一種用于虛擬化平臺的 I/O 虛擬化標(biāo)準(zhǔn)，由澳大利亞天才級程序員 Rusty Russell 開發(fā) ，最初是為了支持他自己的虛擬化解決方案 lguest。在半虛擬化架構(gòu)中，它就像是一座連接來賓操作系統(tǒng)（運(yùn)行在虛擬機(jī)中的操作系統(tǒng)）和 Hypervisor（虛擬機(jī)監(jiān)視器）的橋梁，起著至關(guān)重要的作用。

從本質(zhì)上來說，virtio 是對半虛擬化 hypervisor 中的一組通用模擬設(shè)備的抽象。它定義了一套通用的設(shè)備模型和接口，將各種物理設(shè)備的功能抽象出來，無論是網(wǎng)絡(luò)適配器、磁盤驅(qū)動器還是其他設(shè)備，virtio 都為它們提供了統(tǒng)一的抽象表示，就像一個萬能的模具，可以根據(jù)不同的需求塑造出各種虛擬設(shè)備，使得不同的虛擬化平臺可以基于它實現(xiàn)統(tǒng)一的 I/O 虛擬化。例如，在 KVM 虛擬化環(huán)境中，通過 virtio 可以高效地實現(xiàn)虛擬機(jī)的網(wǎng)絡(luò)和磁盤 I/O 虛擬化。

在完全虛擬化的解決方案中，guest VM 要使用底層 host 資源，需要 Hypervisor 來截獲所有的請求指令，然后模擬出這些指令的行為，這樣勢必會帶來很多性能上的開銷。半虛擬化通過底層硬件輔助的方式，將部分沒必要虛擬化的指令通過硬件來完成，Hypervisor 只負(fù)責(zé)完成部分指令的虛擬化，要做到這點，需要 guest 來配合，guest 完成不同設(shè)備的前端驅(qū)動程序，Hypervisor 配合 guest 完成相應(yīng)的后端驅(qū)動程序，這樣兩者之間通過某種交互機(jī)制就可以實現(xiàn)高效的虛擬化過程。

由于不同 guest 前端設(shè)備其工作邏輯大同小異（如塊設(shè)備、網(wǎng)絡(luò)設(shè)備、PCI設(shè)備、balloon驅(qū)動等），單獨為每個設(shè)備定義一套接口實屬沒有必要，而且還要考慮擴(kuò)平臺的兼容性問題，另外，不同后端 Hypervisor 的實現(xiàn)方式也大同小異（如KVM、Xen等），這個時候，就需要一套通用框架和標(biāo)準(zhǔn)接口（協(xié)議）來完成兩者之間的交互過程，virtio 就是這樣一套標(biāo)準(zhǔn)，它極大地解決了這些不通用的問題。

與傳統(tǒng)的 Linux IO 虛擬化實現(xiàn)方式相比，virtio 具有多方面的顯著優(yōu)勢。首先，它提供了通用接口，大大提高了代碼的可重用性和跨平臺性。以往針對不同的虛擬化平臺和設(shè)備，需要開發(fā)不同的驅(qū)動程序，而有了 virtio，基于其通用接口，開發(fā)者可以更輕松地編寫適用于多種虛擬化環(huán)境的驅(qū)動，減少了開發(fā)成本和工作量。

其次，在性能提升方面，virtio 表現(xiàn)出色。傳統(tǒng)方式中頻繁的 VMEntry、VMExit 以及多次上下文切換和數(shù)據(jù)復(fù)制導(dǎo)致性能低下，而 virtio 采用半虛擬化技術(shù)，通過底層硬件輔助，將部分沒必要虛擬化的指令通過硬件完成，Hypervisor 只負(fù)責(zé)完成部分指令的虛擬化。同時，它通過虛擬隊列（virtqueue）和環(huán)形緩沖區(qū)（virtio-ring）來實現(xiàn)前端驅(qū)動和后端處理程序之間高效的數(shù)據(jù)傳輸，減少了 VMEXIT 次數(shù)，使得數(shù)據(jù)傳輸更加高效，極大地提升了 I/O 性能，其性能幾乎可以達(dá)到和非虛擬化環(huán)境中的原生系統(tǒng)差不多的 I/O 性能。

2.2 virtio數(shù)據(jù)流交互機(jī)制

vring 主要通過兩個環(huán)形緩沖區(qū)來完成數(shù)據(jù)流的轉(zhuǎn)發(fā)，如下圖所示：

vring 包含三個部分，描述符數(shù)組 desc，可用的 available ring 和使用過的 used ring。

desc 用于存儲一些關(guān)聯(lián)的描述符，每個描述符記錄一個對 buffer 的描述，available ring 則用于 guest 端表示當(dāng)前有哪些描述符是可用的，而 used ring 則表示 host 端哪些描述符已經(jīng)被使用。

Virtio 使用 virtqueue來實現(xiàn) I/O 機(jī)制，每個 virtqueue 就是一個承載大量數(shù)據(jù)的隊列，具體使用多少個隊列取決于需求，例如，virtio 網(wǎng)絡(luò)驅(qū)動程序（virtio-net）使用兩個隊列（一個用于接受，另一個用于發(fā)送），而 virtio 塊驅(qū)動程序（virtio-blk）僅使用一個隊列。

具體的，假設(shè) guest 要向 host 發(fā)送數(shù)據(jù)，首先，guest 通過函數(shù) virtqueue_add_buf 將存有數(shù)據(jù)的 buffer 添加到 virtqueue 中，然后調(diào)用 virtqueue_kick 函數(shù)，virtqueue_kick 調(diào)用 virtqueue_notify 函數(shù)，通過寫入寄存器的方式來通知到 host。host 調(diào)用 virtqueue_get_buf 來獲取 virtqueue 中收到的數(shù)據(jù)。

存放數(shù)據(jù)的 buffer 是一種分散-聚集的數(shù)組，由 desc 結(jié)構(gòu)來承載，如下是一種常用的 desc 的結(jié)構(gòu)：

• 當(dāng) guest 向 virtqueue 中寫數(shù)據(jù)時，實際上是向 desc 結(jié)構(gòu)指向的 buffer 中填充數(shù)據(jù)，完了會更新 available ring，然后再通知 host。
• 當(dāng) host 收到接收數(shù)據(jù)的通知時，首先從 desc 指向的 buffer 中找到 available ring 中添加的 buffer，映射內(nèi)存，同時更新 used ring，并通知 guest 接收數(shù)據(jù)完畢。

2.3 Virtio緩沖池

來賓操作系統(tǒng)（前端）驅(qū)動程序通過緩沖池與 hypervisor 交互。對于 I/O，來賓操作系統(tǒng)提供一個或多個表示請求的緩沖池。例如，您可以提供 3 個緩沖池，第一個表示 Read 請求，后面兩個表示響應(yīng)數(shù)據(jù)。該配置在內(nèi)部被表示為一個散集列表（scatter-gather），列表中的每個條目表示一個地址和一個長度。

2.4 核心API

通過 virtio_device 和 virtqueue（更常見）將來賓操作系統(tǒng)驅(qū)動程序與 hypervisor 的驅(qū)動程序鏈接起來。virtqueue 支持它自己的由 5 個函數(shù)組成的 API。您可以使用第一個函數(shù) add_buf 來向 hypervisor 提供請求。如前面所述，該請求以散集列表的形式存在。對于 add_buf，來賓操作系統(tǒng)提供用于將請求添加到隊列的 virtqueue、散集列表（地址和長度數(shù)組）、用作輸出條目（目標(biāo)是底層 hypervisor）的緩沖池數(shù)量，以及用作輸入條目（hypervisor 將為它們儲存數(shù)據(jù)并返回到來賓操作系統(tǒng)）的緩沖池數(shù)量。當(dāng)通過 add_buf 向 hypervisor 發(fā)出請求時，來賓操作系統(tǒng)能夠通過 kick 函數(shù)通知 hypervisor 新的請求。為了獲得最佳的性能，來賓操作系統(tǒng)應(yīng)該在通過 kick 發(fā)出通知之前將盡可能多的緩沖池裝載到 virtqueue。

通過 get_buf 函數(shù)觸發(fā)來自 hypervisor 的響應(yīng)。來賓操作系統(tǒng)僅需調(diào)用該函數(shù)或通過提供的 virtqueue callback 函數(shù)等待通知就可以實現(xiàn)輪詢。當(dāng)來賓操作系統(tǒng)知道緩沖區(qū)可用時，調(diào)用 get_buf 返回完成的緩沖區(qū)。

virtqueue API 的最后兩個函數(shù)是 enable_cb 和 disable_cb。您可以使用這兩個函數(shù)來啟用或禁用回調(diào)進(jìn)程（通過在 virtqueue 中由 virtqueue 初始化的 callback 函數(shù)）。注意，該回調(diào)函數(shù)和 hypervisor 位于獨立的地址空間中，因此調(diào)用通過一個間接的 hypervisor 來觸發(fā)（比如 kvm_hypercall）。

緩沖區(qū)的格式、順序和內(nèi)容僅對前端和后端驅(qū)動程序有意義。內(nèi)部傳輸（當(dāng)前實現(xiàn)中的連接點）僅移動緩沖區(qū)，并且不知道它們的內(nèi)部表示。

Part3 virtio架構(gòu)剖析

3.1 整體架構(gòu)概覽

virtio 的架構(gòu)精妙而復(fù)雜，猶如一座精心設(shè)計的大廈，主要由四層構(gòu)成，每一層都肩負(fù)著獨特而重要的使命，它們相互協(xié)作，共同構(gòu)建起高效的 I/O 虛擬化橋梁。

最上層是前端驅(qū)動，它就像是虛擬機(jī)內(nèi)部的 “大管家”，運(yùn)行在虛擬機(jī)之中，針對不同類型的設(shè)備，如塊設(shè)備（如磁盤）、網(wǎng)絡(luò)設(shè)備、PCI 模擬設(shè)備、balloon 驅(qū)動（用于動態(tài)管理客戶機(jī)內(nèi)存使用）和控制臺驅(qū)動等，有著不同的驅(qū)動程序，但與后端驅(qū)動交互的接口卻是統(tǒng)一的。這些前端驅(qū)動主要負(fù)責(zé)接收用戶態(tài)的請求，就像管家接收家中成員的各種需求，然后按照傳輸協(xié)議將這些請求進(jìn)行封裝，使其能夠在虛擬化環(huán)境中順利傳輸，最后寫 I/O 端口，發(fā)送一個通知到 Qemu 的后端設(shè)備，告知后端有任務(wù)需要處理。

最下層是后端處理程序，它位于宿主機(jī)的 Qemu 中，是操作硬件設(shè)備的 “執(zhí)行者”。當(dāng)它接收到前端驅(qū)動發(fā)過來的 I/O 請求后，會從接收的數(shù)據(jù)中按照傳輸協(xié)議的格式進(jìn)行解析，理解請求的具體內(nèi)容。對于網(wǎng)卡等需要與實際物理設(shè)備交互的請求，后端驅(qū)動會對物理設(shè)備進(jìn)行操作，比如向內(nèi)核協(xié)議棧發(fā)送一個網(wǎng)絡(luò)包完成虛擬機(jī)對于網(wǎng)絡(luò)的操作，從而完成請求，并且會通過中斷機(jī)制通知前端驅(qū)動，告知前端任務(wù)已完成。

中間兩層是 virtio 層和 virtio-ring 層，它們是前后端通信的關(guān)鍵紐帶。virtio 層實現(xiàn)的是虛擬隊列接口，是前后端通信的 “橋梁設(shè)計師”，它在概念上將前端驅(qū)動程序附加到后端驅(qū)動，不同類型的設(shè)備使用的虛擬隊列數(shù)量不同，例如，virtio 網(wǎng)絡(luò)驅(qū)動使用兩個虛擬隊列，一個用于接收，一個用于發(fā)送；而 virtio 塊驅(qū)動僅使用一個隊列 。虛擬隊列實際上被實現(xiàn)為跨越客戶機(jī)操作系統(tǒng)和 hypervisor 的銜接點，只要客戶機(jī)操作系統(tǒng)和 virtio 后端程序都遵循一定的標(biāo)準(zhǔn)，以相互匹配的方式實現(xiàn)它，就可以實現(xiàn)高效通信。

virtio-ring 層則是這座橋梁的 “建筑工人”，它實現(xiàn)了環(huán)形緩沖區(qū)（ring buffer），用于保存前端驅(qū)動和后端處理程序執(zhí)行的信息。它可以一次性保存前端驅(qū)動的多次 I/O 請求，并且交由后端去批量處理，最后實際調(diào)用宿主機(jī)中設(shè)備驅(qū)動實現(xiàn)物理上的 I/O 操作，這樣就可以根據(jù)約定實現(xiàn)批量處理，而不是客戶機(jī)中每次 I/O 請求都需要處理一次，從而大大提高了客戶機(jī)與 hypervisor 信息交換的效率。

3.2 關(guān)鍵組件解析

在 virtio 的架構(gòu)中，虛擬隊列接口和環(huán)形緩沖區(qū)是至關(guān)重要的組件，它們就像是人體的神經(jīng)系統(tǒng)和血液循環(huán)系統(tǒng)，確保了數(shù)據(jù)的高效傳輸和系統(tǒng)的正常運(yùn)行。

虛擬隊列接口是 virtio 實現(xiàn)前后端通信的核心機(jī)制之一，它定義了一組標(biāo)準(zhǔn)的接口，使得前端驅(qū)動和后端處理程序能夠進(jìn)行有效的交互。每個前端驅(qū)動可以根據(jù)需求使用零個或多個虛擬隊列，這些隊列就像是一條條數(shù)據(jù)傳輸?shù)?“高速公路”，不同類型的設(shè)備根據(jù)自身的特點選擇合適數(shù)量的隊列。virtio 網(wǎng)絡(luò)驅(qū)動需要同時處理數(shù)據(jù)的接收和發(fā)送，因此使用兩個虛擬隊列，一個專門用于接收數(shù)據(jù)，另一個用于發(fā)送數(shù)據(jù)，這樣可以提高數(shù)據(jù)處理的效率，避免接收和發(fā)送數(shù)據(jù)時的沖突。

而環(huán)形緩沖區(qū)則是虛擬隊列的具體實現(xiàn)方式，它是一段共享內(nèi)存，被劃分為三個主要部分：描述符表（Descriptor Table）、可用描述符表（Available Ring）和已用描述符表（Used Ring） 。描述符表用于存儲一些關(guān)聯(lián)的描述符，每個描述符記錄一個對 buffer 的描述，就像一個個貨物清單，詳細(xì)記錄了數(shù)據(jù)的位置、大小等信息；可用描述符表用于保存前端驅(qū)動提供給后端設(shè)備且后端設(shè)備可以使用的描述符，它就像是一個 “待處理任務(wù)清單”，后端設(shè)備可以從中獲取需要處理的數(shù)據(jù)；已用描述符表用于保存后端處理程序已經(jīng)處理過并且尚未反饋給前端驅(qū)動的描述，它就像是一個 “已完成任務(wù)清單”，前端驅(qū)動可以從中了解哪些數(shù)據(jù)已經(jīng)被處理完畢。

當(dāng)虛擬機(jī)需要發(fā)送請求到后端設(shè)備時，前端驅(qū)動會將存有數(shù)據(jù)的 buffer 添加到 virtqueue 中，然后更新可用描述符表，將對應(yīng)的描述符標(biāo)記為可用，并通過寫入寄存器的方式通知后端設(shè)備，就像在 “待處理任務(wù)清單” 上添加了一項任務(wù)，并通知后端工作人員。后端設(shè)備接收到通知后，從可用描述符表中讀取請求信息，根據(jù)描述符表中的信息從共享內(nèi)存中讀出數(shù)據(jù)進(jìn)行處理。

處理完成后，后端設(shè)備將響應(yīng)狀態(tài)存放在已用描述符表中，并通知前端驅(qū)動，就像在 “已完成任務(wù)清單” 上記錄下完成的任務(wù)，并通知前端工作人員。前端驅(qū)動從已用描述符表中得到請求完成信息，并獲取請求的數(shù)據(jù)，完成一次數(shù)據(jù)傳輸?shù)倪^程。

3.3 Virtio初始化

⑴前端初始化

Virtio設(shè)備遵循linux內(nèi)核通用的設(shè)備模型，bus類型為virtio_bus,對它的理解可以類似PCI設(shè)備。設(shè)備模型的實現(xiàn)主要在driver/virtio/virtio.c文件中。

• 設(shè)備注冊

int register_virtio_device(struct virtio_device *dev)
-> dev->dev.bus = &virtio_bus;			//填寫bus類型
-> err = ida_simple_get(&virtio_index_ida, 0, 0, GFP_KERNEL);//分配一個唯一的設(shè)備index標(biāo)示
-> dev->config->reset(dev);				//重置config
-> err = device_register(&dev->dev);	//在系統(tǒng)中注冊設(shè)備

• 驅(qū)動注冊

int register_virtio_driver(struct virtio_driver *driver)
-> driver->driver.bus = &virtio_bus; 	//填寫bus類型
->driver_register(&driver->driver);		//向系統(tǒng)中注冊driver

• 設(shè)備匹配

virtio_bus. match = virtio_dev_match
//用于甄別總線上設(shè)備是否與virtio對應(yīng)的設(shè)備匹配，
//方法是查看設(shè)備id是否與driver中保存的id_table中的某個id匹配。

• 設(shè)備發(fā)現(xiàn)

virtio_bus. probe = virtio_dev_probe
// virtio_dev_probe函數(shù)首先是
-> device_features = dev->config->get_features(dev);	//獲得設(shè)備的配置信息
-> // 查找device和driver共同支持的feature，設(shè)置dev->features
-> dev->config->finalize_features(dev);	//確認(rèn)需要使用的features
-> drv->probe(dev);	//調(diào)用driver的probe函數(shù)，通常這個函數(shù)進(jìn)行具體設(shè)備的初始化，

例如virtio_blk驅(qū)動中用于初始化queue，創(chuàng)建磁盤設(shè)備并初始化一些必要的數(shù)據(jù)結(jié)構(gòu)

當(dāng)virtio后端模擬出virtio_blk設(shè)備后，guest os掃描到此virtio設(shè)備，然后調(diào)用virtio_pci_driver中virtio_pci_probe函數(shù)完成pci設(shè)備的啟動。

注冊一條virtio_bus，同時在virtio總線進(jìn)行注冊設(shè)備。當(dāng)virtio總線進(jìn)行注冊設(shè)備register_virtio_device，將調(diào)用virtio總線的probe函數(shù)：virtio_dev_probe（）。該函數(shù)遍歷驅(qū)動，找到支持驅(qū)動關(guān)聯(lián)到該設(shè)備并且調(diào)用virtio_driver probe。

virtblk_probe函數(shù)調(diào)用流程如下：

• virtio_config_val：得到硬件上支持多少個segments（因為都是聚散IO，segment應(yīng)該是指聚散列表的最大項數(shù)），這里需要注意的是頭部和尾部各需要一個額外的segment
• init_vq：調(diào)用init_vq函數(shù)進(jìn)行virtqueue、vring等相關(guān)的初始化設(shè)置工作。
• alloc_disk：調(diào)用alloc_disk為此虛擬磁盤分配一個gendisk類型的對象
• blk_init_queue：注冊queue的處理函數(shù)為do_virtblk_request

static int __devinit virtblk_probe(struct virtio_device *vdev)
{
	...
	/* 得到硬件上支持多少個segments
	   （因為都是聚散IO，這個segment應(yīng)該是指聚散列表的最大項數(shù)），	
	   這里需要注意的是頭部和尾部各需要一個額外的segment */

	err = virtio_config_val(vdev, VIRTIO_BLK_F_SEG_MAX,offsetof(struct virtio_blk_config, seg_max),&sg_elems);
	...

	/* 分配vq，調(diào)用virtio_find_single_vq(vdev, blk_done, "requests");
	   分配單個vq，名字為”request”，注冊	的通知函數(shù)是blk_done */
	err = init_vq(vblk);

	/* 調(diào)用alloc_disk為此虛擬磁盤分配一個gendisk類型的對象，
		對象指針保存在virtio_blk結(jié)構(gòu)的disk	中*/
	vblk->disk = alloc_disk(1 << PART_BITS);

	/* 分配request_queue結(jié)構(gòu)，從屬于virtio-blk的gendisk結(jié)構(gòu)下
	   初始化gendisk及disk queue，注冊queue	的處理函數(shù)為do_virtblk_request，
	   其中queuedata也設(shè)置為virtio_blk結(jié)構(gòu)。*/
	q = vblk->disk->queue = blk_init_queue(do_virtblk_request, NULL);
	...

	add_disk(vblk->disk); //使設(shè)備對外生效
}

init_vq完成virtqueue和vring的分配，設(shè)置隊列的回調(diào)函數(shù)，中斷處理函數(shù)，流程如下：

-->init_vq
	-->virtio_find_single_vq
		-->vp_find_vqs
			-->vp_try_to_find_vqs
				-->setup_vq
					-->vring_new_virtqueue
				-->request_irq

分配vq的函數(shù)init_vq:

static int init_vq(struct virtio_blk *vblk)
{
	...
	vblk->vq = virtio_find_single_vq(vblk->vdev, blk_done, "requests");
	...
}

struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev,vq_callback_t *c, const char *n)
{
	vq_callback_t *callbacks[] = { c };
	const char *names[] = { n };
		struct virtqueue *vq;

	/* 調(diào)用find_vqs回調(diào)函數(shù)(對應(yīng)vp_find_vqs函數(shù)，
	   在virtio_pci_probe中設(shè)置)進(jìn)行具體的設(shè)置。
	   會將相應(yīng)的virtqueue對象指針存放在vqs這個臨時指針數(shù)組中 */
	int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names);
	if (err < 0)
		return ERR_PTR(err);
	return vq;
}

static int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs,
		       struct virtqueue *vqs[],
		       vq_callback_t *callbacks[],
		       const char *names[])
{
	int err;
	/* 這個函數(shù)中只是三次調(diào)用了vp_try_to_find_vqs函數(shù)來完成操作，
	   只是每次想起傳送的參數(shù)有些不一樣，該函數(shù)的最后兩個參數(shù)：
	   use_msix表示是否使用MSI-X機(jī)制的中斷、per_vq_vectors表示是否對
	   每一	個virtqueue使用使用一個中斷vector */
	/* Try MSI-X with one vector per queue. */
	err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names, true, true);
	if (!err)
		return 0;
	err = vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,true, false);
	if (!err)
		return 0;
	return vp_try_to_find_vqs(vdev, nvqs, vqs, callbacks, names,false, false);
}

Virtio設(shè)備中斷，有兩種產(chǎn)生中斷情況：

• 當(dāng)設(shè)備的配置信息發(fā)生改變（config changed），會產(chǎn)生一個中斷（稱為change中斷），中斷處理程序需要調(diào)用相應(yīng)的處理函數(shù)（需要驅(qū)動定義）
• 當(dāng)設(shè)備向隊列中寫入信息時，會產(chǎn)生一個中斷（稱為vq中斷），中斷處理函數(shù)需要調(diào)用相應(yīng)的隊列的回調(diào)函數(shù)（需要驅(qū)動定義）

三種中斷處理方式：

1). 不用msix中斷，則change中斷和所有vq中斷共用一個中斷irq。

中斷處理函數(shù)：vp_interrupt。
vp_interrupt函數(shù)中包含了對change中斷和vq中斷的處理。

2). 使用msix中斷，但只有2個vector；一個用來對應(yīng)change中斷，一個對應(yīng)所有隊列的vq中斷。

change中斷處理函數(shù)：vp_config_changed
vq中斷處理函數(shù)：vp_vring_interrupt

3). 使用msix中斷，有n+1個vector；一個用來對應(yīng)change中斷，n個分別對應(yīng)n個隊列的vq中斷。每個vq一個vector。

static int vp_try_to_find_vqs(struct virtio_device *vdev, unsigned nvqs,
			      struct virtqueue *vqs[],
			      vq_callback_t *callbacks[],
			      const char *names[],
			      bool use_msix,
			      bool per_vq_vectors)
{
	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
	u16 msix_vec;
	int i, err, nvectors, allocated_vectors;

	if (!use_msix) {
 	/* 不用msix，所有vq共用一個irq ，設(shè)置中斷處理函數(shù)vp_interrupt*/
		err = vp_request_intx(vdev);
	} else {
		if (per_vq_vectors) {
			nvectors = 1;
			for (i = 0; i < nvqs; ++i)
				if (callbacks[i])
					++nvectors;
		} else {
			/* Second best: one for change, shared for all vqs. */
			nvectors = 2;
		}
		/*per_vq_vectors為0，設(shè)置處理函數(shù)vp_vring_interrupt*/
		err = vp_request_msix_vectors(vdev, nvectors, per_vq_vectors);
	}

	for (i = 0; i < nvqs; ++i) {
		if (!callbacks[i] || !vp_dev->msix_enabled)
			msix_vec = VIRTIO_MSI_NO_VECTOR;
		else if (vp_dev->per_vq_vectors)
			msix_vec = allocated_vectors++;
		else
			msix_vec = VP_MSIX_VQ_VECTOR;
		vqs[i] = setup_vq(vdev, i, callbacks[i], names[i], msix_vec);
		...

		/* 如果per_vq_vectors為1，則為每個隊列指定一個vector，
		   vq中斷處理函數(shù)為vring_interrupt*/
		err = request_irq(vp_dev->msix_entries[msix_vec].vector,
				  vring_interrupt, 0,
				  vp_dev->msix_names[msix_vec],
				  vqs[i]);
	}
	return 0;
}

setup_vq完成virtqueue（主要用于數(shù)據(jù)的操作）、vring（用于數(shù)據(jù)的存放）的分配和初始化任務(wù)：

static struct virtqueue *setup_vq(struct virtio_device *vdev, unsigned index, 
								  void (*callback)(struct virtqueue *vq),
								  const char *name,u16 msix_vec)
{
	struct virtqueue *vq;

	/* 寫寄存器退出guest，設(shè)置設(shè)備的隊列序號，
	對于塊設(shè)備就是0（最大只能為VIRTIO_PCI_QUEUE_MAX 64） */
	iowrite16(index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);

	/*得到硬件隊列的深度num*/
	num = ioread16(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NUM);
	...
	/* IO同步信息，如虛擬隊列地址，會調(diào)用virtio_queue_set_addr進(jìn)行處理*/
	iowrite32(virt_to_phys(info->queue) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
		      vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
	...
	/* 調(diào)用該函數(shù)分配vring_virtqueue對象，該結(jié)構(gòu)中既包含了vring、又包含了virtqueue，并且返回	virtqueue對象指針*/
	vq = vring_new_virtqueue(info->num, VIRTIO_PCI_VRING_ALIGN,
				 vdev, info->queue, vp_notify, callback, name);
	...
	return vq;
}

IO同步信息，如虛擬隊列地址，會調(diào)用virtio_queue_set_addr進(jìn)行處理：

virtio_queue_set_addr(vdev, vdev->queue_sel, addr);
--> vdev->vq[n].pa = addr;				//n=vdev->queue_sel，即同步隊列地址
--> virtqueue_init(&vdev->vq[n]);		//初始化后端的虛擬隊列
--> target_phys_addr_t pa = vq->pa;	    //主機(jī)vring虛擬首地址
--> vq->vring.desc = pa; 				//同步desc地址
--> vq->vring.avail = pa + vq->vring.num * sizeof(VRingDesc); //同步avail地址
--> vq->vring.used = vring_align(vq->vring.avail + 
								 offsetof(VRingAvail, ring[vq->vring.num]),
								 VIRTIO_PCI_VRING_ALIGN); 	  //同步used地址

其中，pa是由客戶機(jī)傳送過來的物理頁地址，在主機(jī)中就是主機(jī)的虛擬頁地址，賦值給主機(jī)中對應(yīng)vq中的vring，則同步了主客機(jī)中虛擬隊列地址，之后vring中的當(dāng)前可用緩沖描述符avail、已使用緩沖used均得到同步。

分配vring_virtqueue對象由vring_new_virtqueue函數(shù)完成：

struct virtqueue *vring_new_virtqueue(unsigned int num,							      unsigned int vring_align,
								      struct virtio_device *vdev,							      void *pages,							      void (*notify)(struct virtqueue *),							      void (*callback)(struct virtqueue *),							      const char *name)
{
	struct vring_virtqueue *vq;
	unsigned int i;

	/* We assume num is a power of 2. */
	if (num & (num - 1)) {
		dev_warn(&vdev->dev, "Bad virtqueue length %u\n", num);
		return NULL;
	}
	/* 調(diào)用vring_init函數(shù)初始化vring對象，
	   其desc、avail、used三個域瓜分了上面的
	   setup_vp函數(shù)第一步中分配的內(nèi)存頁面 */
	vring_init(&vq->vring, num, pages, vring_align);

	/*初始化virtqueue對象(注意其callback會被設(shè)置成virtblk_done函數(shù)*/
	vq->vq.callback = callback;
	vq->vq.vdev = vdev;
	vq->vq.name = name;
	vq->notify = notify;
	vq->broken = false;
	vq->last_used_idx = 0;
	vq->num_added = 0;
	list_add_tail(&vq->vq.list, &vdev->vqs);

	/* No callback? Tell other side not to bother us. */
	if (!callback)
		vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
	/* Put everything in free lists. */
	vq->num_free = num;
	vq->free_head = 0;
	for (i = 0; i < num-1; i++) {
		vq->vring.desc[i].next = i+1;
		vq->data[i] = NULL;
	}
	vq->data[i] = NULL;
	/*返回virtqueue對象指針*/
	return &vq->vq;
}

調(diào)用vring_init函數(shù)初始化vring對象：

static inline void vring_init(struct vring *vr, unsigned int num, void *p,
			     			  unsigned long align)
{
	vr->num = num;
	vr->desc = p;
	vr->avail = p + num*sizeof(struct vring_desc);
	vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + align-1)& ~(align - 1));
}

⑵后端初始化

后端驅(qū)動的初始化流程實際是后端驅(qū)動的數(shù)據(jù)結(jié)構(gòu)進(jìn)行初始化，設(shè)置PCI設(shè)備的信息，并結(jié)合到virtio設(shè)備中，設(shè)置主機(jī)狀態(tài)，配置并初始化虛擬隊列，為每個塊設(shè)備綁定一個虛擬隊列及隊列處理函數(shù)，并綁定設(shè)備處理函數(shù)，以處理IO請求。virtio-block后端初始化流程：

type_init(virtio_pci_register_types)
	--> type_register_static(&virtio_blk_info) // 注冊一個設(shè)備結(jié)構(gòu)，為PCI子設(shè)備
		--> class_init = virtio_blk_class_init,
			--> k->init = virtio_blk_init_pci;

static int virtio_blk_init_pci(PCIDevice *pci_dev)
{
    VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
    VirtIODevice *vdev;
	...

    vdev = virtio_blk_init(&pci_dev->qdev, &proxy->blk);
	...
    virtio_init_pci(proxy, vdev);

    /* make the actual value visible */
    proxy->nvectors = vdev->nvectors;
    return 0;
}

調(diào)用virtio_blk_init來初始化virtio-blk設(shè)備，virtio_blk_init代碼如下：

VirtIODevice *virtio_blk_init(DeviceState *dev, VirtIOBlkConf *blk)
{
    VirtIOBlock *s;
    static int virtio_blk_id;
	...
	/* virtio_common_init初始化一個VirtIOBlock結(jié)構(gòu)，
	   這里主要是分配一個VirtIODevice	結(jié)構(gòu)并為它賦值，
	   VirtIODevice結(jié)構(gòu)主要描述IO設(shè)備的一些配置接口和屬性。
	   VirtIOBlock結(jié)構(gòu)第一個域是VirtIODevice結(jié)構(gòu)，VirtIOBlock結(jié)構(gòu)
	   還包括一些其他的塊設(shè)備屬性和狀態(tài)參數(shù)。*/
    s = (VirtIOBlock *)virtio_common_init("virtio-blk", VIRTIO_ID_BLOCK,
                                          sizeof(struct virtio_blk_config),
                                          sizeof(VirtIOBlock));
	/* 對VirtIOBlock結(jié)構(gòu)中的域賦值，其中比較重要的是對一些virtio
	   通用配置接口的賦值（get_config，set_config，get_features，set_status，reset），
	   如此，virtio_blk便	有了自定義的配置。*/
    s->vdev.get_config = virtio_blk_update_config;
    s->vdev.set_config = virtio_blk_set_config;
    s->vdev.get_features = virtio_blk_get_features;
    s->vdev.set_status = virtio_blk_set_status;
    s->vdev.reset = virtio_blk_reset;
    s->bs = blk->conf.bs;
    s->conf = &blk->conf;
    s->blk = blk;
    s->rq = NULL;
    s->sector_mask = (s->conf->logical_block_size / BDRV_SECTOR_SIZE) - 1;

	/* 初始化vq，virtio_add_queue為設(shè)置vq的中vring處理的最大個數(shù)是128，
	   注冊	handle_output函數(shù)為virtio_blk_handle_output（host端處理函數(shù)）*/
    s->vq = virtio_add_queue(&s->vdev, 128, virtio_blk_handle_output);

	/* qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);
	   設(shè)置vm狀態(tài)改	變的處理函數(shù)為virtio_blk_dma_restart_cb*/
    qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);
    s->qdev = dev;

	/* register_savevm注冊虛擬機(jī)save和load函數(shù)（熱遷移）*/
	register_savevm(dev, "virtio-blk", virtio_blk_id++, 2,
                    virtio_blk_save, virtio_blk_load, s);
	...
    return &s->vdev;
}

//初始化vq，調(diào)用virtio_add_queue：
VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
                            void (*handle_output)(VirtIODevice *, VirtQueue *))
{
	...
    vdev->vq[i].vring.num = queue_size;  //設(shè)置隊列的深度
    vdev->vq[i].handle_output = handle_output;  //注冊隊列的處理函數(shù)
    return &vdev->vq[i];
}

初始化virtio-PCI信息，分配bar，注冊接口以及接口處理函數(shù)；設(shè)備綁定virtio-pci的ops，設(shè)置主機(jī)特征，調(diào)用函數(shù)virtio_init_pci來初始化virtio-blk pci相關(guān)信息：

void virtio_init_pci(VirtIOPCIProxy *proxy, VirtIODevice *vdev)
{
    uint8_t *config;
    uint32_t size; 
	...
	/* memory_region_init_io()：初始化IO內(nèi)存，
	   并設(shè)置IO內(nèi)存操作和內(nèi)存讀寫函數(shù)	virtio_pci_config_ops*/
    memory_region_init_io(&proxy->bar, &virtio_pci_config_ops, proxy,"virtio-pci", size);

	/*將IO內(nèi)存綁定到PCI設(shè)備，即初始化bar，給bar注冊pci地址*/
    pci_register_bar(&proxy->pci_dev, 0, PCI_BASE_ADDRESS_SPACE_IO,
					 &proxy->bar);

    if (!kvm_has_many_ioeventfds()) {
        proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
    }

	/*綁定virtio-pci總線的ops并指向設(shè)備代理proxy*/
    virtio_bind_device(vdev, &virtio pci_bindings, proxy);

    proxy->host_features |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;
    proxy->host_features |= 0x1 << VIRTIO_F_BAD_FEATURE;
    proxy->host_features = vdev->get_features(vdev, proxy->host_features);
}

其中，virtio-pic讀寫操作為virtio_pci_config_ops：

static const MemoryRegionPortio virtio_portio[] = {
    { 0, 0x10000, 2, .write = virtio_pci_config_writew, },
	...
    { 0, 0x10000, 2, .read = virtio_pci_config_readw, },
};

在設(shè)備注冊完成后，qemu調(diào)用io_region_add進(jìn)行io端口注冊：

static void io_region_add(MemoryListener *listener,MemoryRegionSection *section)
{  
	...
    /*io端口信息初始化*/
    iorange_init(&mrio->iorange, &memory_region_iorange_ops,
                 section->offset_within_address_space, section->size);
    /*io端口注冊*/
    ioport_register(&mrio->iorange);
}

ioport_register調(diào)用register_ioport_read及register_ioport_write將io端口對應(yīng)的回調(diào)函數(shù)保存到ioport_write_table數(shù)組中：

int register_ioport_write(pio_addr_t start, int length, int size,IOPortWriteFunc *func, void *opaque)
{
	...
    for(i = start; i < start + length; ++i) {
    	/*設(shè)置對應(yīng)端口的回調(diào)函數(shù)*/
        ioport_write_table[bsize][i] = func;  
		...
   }
   return 0;
}

Part4 virtio 的工作原理

虛擬隊列（virtqueue）是 virtio 實現(xiàn)高效數(shù)據(jù)傳輸?shù)暮诵臋C(jī)制，而描述符表、可用環(huán)和已用環(huán)則是虛擬隊列的關(guān)鍵組成部分，它們各自承擔(dān)著重要的職責(zé)，相互配合完成數(shù)據(jù)的傳輸任務(wù)。

描述符表可以看作是一個詳細(xì)的 “數(shù)據(jù)清單”，它存放著真正的數(shù)據(jù)報文信息，每個描述符都詳細(xì)記錄了數(shù)據(jù)的起始地址、長度以及一些標(biāo)志位等關(guān)鍵信息。這些信息就像是貨物的標(biāo)簽，準(zhǔn)確地告訴接收方如何正確地處理這些數(shù)據(jù)。當(dāng)客戶機(jī)需要發(fā)送一個網(wǎng)絡(luò)數(shù)據(jù)包時，前端驅(qū)動會創(chuàng)建一個描述符，在描述符中記錄下數(shù)據(jù)包在內(nèi)存中的起始地址、數(shù)據(jù)包的長度以及一些與傳輸相關(guān)的標(biāo)志位信息，然后將這個描述符添加到描述符表中。

可用環(huán)是前端驅(qū)動用來告知后端驅(qū)動有哪些數(shù)據(jù)是可供處理的 “待處理任務(wù)列表”。前端驅(qū)動將數(shù)據(jù)描述符的索引放入可用環(huán)中，后端驅(qū)動從這里獲取任務(wù)并進(jìn)行處理。繼續(xù)以上述網(wǎng)絡(luò)數(shù)據(jù)包發(fā)送為例，前端驅(qū)動在將描述符添加到描述符表后，會將該描述符的索引放入可用環(huán)中，并通知后端驅(qū)動有新的數(shù)據(jù)可供處理。

已用環(huán)則是后端驅(qū)動用來通知前端驅(qū)動哪些數(shù)據(jù)已經(jīng)處理完成的 “完成任務(wù)反饋清單”。后端驅(qū)動在處理完數(shù)據(jù)后，會將描述符的索引放入已用環(huán)中，前端驅(qū)動看到已用環(huán)的反饋后，就知道哪些數(shù)據(jù)包已經(jīng)成功處理，可以進(jìn)行后續(xù)的操作，比如回收相關(guān)的資源。當(dāng)后端驅(qū)動將網(wǎng)絡(luò)數(shù)據(jù)包成功發(fā)送到物理網(wǎng)絡(luò)接口后，它會將對應(yīng)的描述符索引放入已用環(huán)中，通知前端驅(qū)動該數(shù)據(jù)包已發(fā)送完成。

在數(shù)據(jù)傳輸過程中，當(dāng)客戶機(jī)的前端驅(qū)動有數(shù)據(jù)要發(fā)送時，它首先會將數(shù)據(jù)存儲在內(nèi)存中的特定位置，并創(chuàng)建相應(yīng)的描述符記錄數(shù)據(jù)的相關(guān)信息，然后將描述符添加到描述符表中，并把描述符的索引放入可用環(huán)中，接著通過通知機(jī)制（如中斷）告知后端驅(qū)動有新的數(shù)據(jù)到來。后端驅(qū)動接收到通知后，從可用環(huán)中獲取描述符索引，根據(jù)索引從描述符表中讀取描述符，進(jìn)而獲取數(shù)據(jù)的位置和相關(guān)信息，完成對數(shù)據(jù)的處理，比如將數(shù)據(jù)發(fā)送到物理設(shè)備。

處理完成后，后端驅(qū)動將描述符索引放入已用環(huán)中，并通知前端驅(qū)動數(shù)據(jù)已處理完畢。前端驅(qū)動從已用環(huán)中得知數(shù)據(jù)處理結(jié)果后，進(jìn)行相應(yīng)的后續(xù)操作，如釋放已處理數(shù)據(jù)占用的內(nèi)存空間等。通過這樣的方式，數(shù)據(jù)在前后端之間通過虛擬隊列實現(xiàn)了高效、有序的傳輸 。

Part5 virtio 代碼分析

5.1 關(guān)鍵數(shù)據(jù)結(jié)構(gòu)

在 virtio 的代碼實現(xiàn)中，有幾個關(guān)鍵的數(shù)據(jù)結(jié)構(gòu)起著核心作用，它們相互協(xié)作，共同構(gòu)建了 virtio 高效的 I/O 虛擬化功能。

virtio_bus是基于總線驅(qū)動模型的公共數(shù)據(jù)結(jié)構(gòu)，定義新的 bus 時需要填充該結(jié)構(gòu)，在drivers/virtio/virtio.c中進(jìn)行定義。它以core_initcall的方式被注冊，啟動順序優(yōu)先級很高，就像是系統(tǒng)啟動時的 “先鋒隊”，早早地為后續(xù)設(shè)備和驅(qū)動的注冊搭建好舞臺。在virtio_dev_match函數(shù)中，涉及到virtio_device_id結(jié)構(gòu)的匹配，通過先匹配device字段，后匹配vendor字段的方式，確保驅(qū)動與設(shè)備的正確匹配，就像在茫茫人海中精準(zhǔn)找到對應(yīng)的合作伙伴。

virtio_device定義在include/linux/virtio.h中，其中的id成員標(biāo)識了當(dāng)前virtio_device的用途，以virtio-net為例，它就是其中一種具體的用途。config成員指向virtio_config_ops操作集，其中的函數(shù)主要與virtio_device的配置相關(guān)，包括實例化 / 反實例化virtqueue，以及獲取 / 設(shè)置設(shè)備的屬性與狀態(tài)等重要操作。vqs是一個鏈表，用于持有virtio_device所持有的virtqueue，在virtio-net中通常會建立兩條virtqueue，分別用于數(shù)據(jù)的接收和發(fā)送，就像兩條繁忙的運(yùn)輸通道，保障數(shù)據(jù)的高效傳輸。features則記錄了virtio_driver和virtio_device同時支持的通信特性，是前后端最終協(xié)商的通信特性集合，這些特性決定了數(shù)據(jù)傳輸?shù)姆绞胶托?。

virtio_driver同樣定義在include/linux/virtio.h中，id_table對應(yīng)virtio_device結(jié)構(gòu)中的id成員，它是當(dāng)前driver支持的所有id列表，通過這個列表，驅(qū)動可以快速識別和匹配支持的設(shè)備。feature_table和feature_table_size分別表示當(dāng)前driver支持的所有virtio傳輸屬性列表以及屬性數(shù)組的元素個數(shù)，這些屬性為驅(qū)動的功能實現(xiàn)提供了豐富的選項。probe函數(shù)是virtio_driver層面注冊的重要函數(shù)，當(dāng)virtio_device和virtio_driver匹配成功后，會先調(diào)用bus層面的probe函數(shù)，然后在virtio_bus層面的probe函數(shù)中，進(jìn)一步調(diào)用virtio_driver層面的probe函數(shù)，這個過程就像是接力賽中的交接棒，確保設(shè)備驅(qū)動的順利初始化 。

virtqueue是實現(xiàn)數(shù)據(jù)傳輸?shù)年P(guān)鍵數(shù)據(jù)結(jié)構(gòu)，它是virtio前端與后端通信的主要方式。每個virtqueue包含描述符表（Descriptor Table）、可用環(huán)（Available Ring）和已用環(huán)（Used Ring）。描述符表由一組描述符組成，每個描述符代表一個緩沖區(qū)的地址和長度，用于指定設(shè)備操作時數(shù)據(jù)傳輸?shù)膩碓椿蚰康牡兀拖褚环菰敿?xì)的貨物清單，記錄著數(shù)據(jù)的存放位置和數(shù)量。

可用環(huán)用于前端通知后端有新的 I/O 操作請求，前端驅(qū)動會將描述符的索引填充到可用環(huán)中，后端可通過遍歷可用環(huán)來處理這些請求，就像在任務(wù)列表中領(lǐng)取待辦任務(wù)。已用環(huán)用于后端通知前端一個操作已經(jīng)完成，后端會將描述符索引寫入已用環(huán)，前端可以從中獲取完成信息，就像收到任務(wù)完成的反饋通知 。

5.2 代碼實現(xiàn)細(xì)節(jié)

以virtio-net模塊為例，深入剖析其前端驅(qū)動和后端驅(qū)動的代碼實現(xiàn)，能讓我們更清晰地了解 virtio 在網(wǎng)絡(luò) I/O 虛擬化中的工作機(jī)制。

在前端驅(qū)動中，設(shè)備初始化是一個關(guān)鍵步驟。在virtnet_probe函數(shù)中，首先會進(jìn)行一系列的初始化操作，包括識別和初始化接收和發(fā)送的virtqueues。如果協(xié)商了VIRTIO_NET_F_MQ特性位，會根據(jù)max_virtqueue_pairs來確定virtqueues的數(shù)量；否則，通常識別N=1。如果協(xié)商了VIRTIO_NET_F_CTRL_VQ特性位，還會識別控制virtqueue。接著，會填充接收隊列的緩沖區(qū)，為數(shù)據(jù)接收做好準(zhǔn)備。同時，根據(jù)協(xié)商的特性位，還會進(jìn)行一些其他的配置，如設(shè)置 MAC 地址、判斷鏈接狀態(tài)、協(xié)商校驗和及分段卸載等特性 。

在數(shù)據(jù)發(fā)送流程中，當(dāng)內(nèi)核協(xié)議棧調(diào)用dev_hard_start_xmit函數(shù)時，會逐步調(diào)用到virtio_net.c中的start_xmit函數(shù)。在start_xmit函數(shù)中，會調(diào)用xmit_skb函數(shù)，將skb（Socket Buffer，套接字緩沖區(qū)，用于存儲網(wǎng)絡(luò)數(shù)據(jù)包）放到vqueue中。具體操作是先通過sg_init_table初始化sg列表，sg_set_buf將sg指向特定的buffer，skb_to_sgvec將socket buffer中的數(shù)據(jù)填充到sg中，然后通過virtqueue_add_outbuf將sg添加到Virtqueue中，并更新Avail隊列中描述符的索引值。最后，通過virtqueue_notify通知后端驅(qū)動可以來取數(shù)據(jù)，整個過程就像將貨物裝上運(yùn)輸車輛，并通知物流公司來取貨 。

數(shù)據(jù)接收流程則相對復(fù)雜一些。當(dāng)有數(shù)據(jù)到達(dá)時，會觸發(fā)中斷，進(jìn)入中斷處理流程。在中斷處理的上半部，通常是一些簡單的操作，比如將napi掛到本地cpu的softnet_data->poll_list鏈表，并通過raise_softirq觸發(fā)網(wǎng)絡(luò)收包軟中斷。在中斷處理的下半部，會執(zhí)行軟中斷回調(diào)函數(shù)net_rx_action，進(jìn)而調(diào)用virtio_net.c中的virtnet_poll函數(shù)。

在virtnet_poll函數(shù)中，會從virtqueue中獲取數(shù)據(jù)，將接收到的數(shù)據(jù)轉(zhuǎn)換成skb，并根據(jù)接收類型進(jìn)行不同的處理。最后，通過napi_gro_receive將skb上傳到上層協(xié)議棧，如果檢測到本次中斷接收數(shù)據(jù)完成，會重新開啟中斷，等待下一次數(shù)據(jù)接收，整個過程就像一個高效的物流分揀中心，不斷接收、處理和分發(fā)貨物 。

在后端驅(qū)動中，以vhost-net模塊為例，其注冊主要使用 Linux 內(nèi)核提供的內(nèi)存注冊機(jī)制。在vhost_net_init函數(shù)中，通過misc_register將vhost-net模塊注冊為一個雜項設(shè)備，對應(yīng)的字符設(shè)備為/dev/vhost-net。當(dāng)用戶態(tài)使用open系統(tǒng)調(diào)用時，會執(zhí)行vhost_net_open函數(shù)，對字符設(shè)備進(jìn)行初始化，包括分配內(nèi)存、初始化vhost_dev和vhost_virtqueue等操作。為了獲取tap設(shè)備的數(shù)據(jù)包，vhost-net模塊注冊了tun socket，并實現(xiàn)了相應(yīng)的收發(fā)包函數(shù)。當(dāng)tap獲取到數(shù)據(jù)包時，會調(diào)用virtnet_poll函數(shù)，從virtqueue中獲取數(shù)據(jù)并進(jìn)行處理 。

5.3 代碼中的優(yōu)化技巧

在 virtio 的代碼實現(xiàn)中，采用了多種優(yōu)化技巧來提高性能，使其在 I/O 虛擬化領(lǐng)域表現(xiàn)出色。

批量處理是一個重要的優(yōu)化手段。在數(shù)據(jù)傳輸過程中，不是每次只處理一個數(shù)據(jù)單元，而是將多個數(shù)據(jù)單元組合成一批進(jìn)行處理。以網(wǎng)絡(luò)數(shù)據(jù)包的發(fā)送為例，前端驅(qū)動可以將多個小的網(wǎng)絡(luò)數(shù)據(jù)包合并成一個大的數(shù)據(jù)包，然后通過virtqueue發(fā)送給后端驅(qū)動。這樣做可以減少數(shù)據(jù)傳輸?shù)拇螖?shù)，降低VMEXIT的頻率，從而提高整體性能。就像在物流運(yùn)輸中，將多個小包裹合并成一個大包裹進(jìn)行運(yùn)輸，減少了運(yùn)輸次數(shù)和成本 。

緩存機(jī)制的運(yùn)用也極大地提升了性能。在virtio-net模塊中，會使用緩存來存儲一些頻繁訪問的數(shù)據(jù)或狀態(tài)信息。例如，前端驅(qū)動可能會緩存一些常用的網(wǎng)絡(luò)配置參數(shù)，避免每次進(jìn)行網(wǎng)絡(luò)操作時都去重新讀取配置文件，從而節(jié)省了讀取時間，提高了操作效率。后端驅(qū)動也可能會緩存一些設(shè)備的狀態(tài)信息，以便快速響應(yīng)前端驅(qū)動的請求，就像在圖書館中，將常用的書籍放在方便拿取的位置，讀者借閱時可以更快地獲取 。

此外，virtio還通過合理的中斷處理機(jī)制來優(yōu)化性能。在傳統(tǒng)的 I/O 虛擬化中，頻繁的中斷會導(dǎo)致大量的上下文切換，消耗系統(tǒng)資源。而virtio采用了一些策略來減少中斷的頻率，例如使用中斷合并技術(shù)，將多個中斷請求合并成一個中斷進(jìn)行處理，這樣可以減少中斷處理的開銷，提高系統(tǒng)的整體性能，就像將多個小任務(wù)合并成一個大任務(wù)進(jìn)行處理，減少了任務(wù)切換的時間 。

在數(shù)據(jù)傳輸過程中，virtio還利用了內(nèi)存映射和直接內(nèi)存訪問（DMA）技術(shù)。通過內(nèi)存映射，前端驅(qū)動和后端驅(qū)動可以直接訪問共享內(nèi)存中的數(shù)據(jù)，避免了數(shù)據(jù)在不同內(nèi)存區(qū)域之間的多次復(fù)制，提高了數(shù)據(jù)傳輸?shù)男省MA 技術(shù)則允許設(shè)備直接訪問內(nèi)存，而不需要 CPU 的干預(yù)，進(jìn)一步減輕了 CPU 的負(fù)擔(dān)，提高了系統(tǒng)的整體性能，就像在工廠生產(chǎn)中，引入自動化設(shè)備，讓設(shè)備直接進(jìn)行生產(chǎn)操作，減少了人工干預(yù)，提高了生產(chǎn)效率 。