在當今數(shù)字化時代，虛擬化技術早已成為推動計算機領域發(fā)展的重要力量。想象一下，一臺物理主機上能同時運行多個相互隔離的虛擬機，每個虛擬機都仿佛擁有自己獨立的硬件資源，這一切是如何實現(xiàn)的呢？

今天，就讓我們一起踏上這場充滿奧秘的 Linux IO 虛擬化探索之旅，而我們的主角 ——virtio，將為我們揭開這層神秘的面紗。它是如何在虛擬化的世界里巧妙運作，解決了 I/O 虛擬化中的諸多難題？又有著怎樣獨特的設計和實現(xiàn)，讓眾多開發(fā)者為之著迷？接下來，就跟我一同深入 virtio 的奇妙世界，探尋其中的秘密。

一、Linux IO虛擬化簡介

1.1虛擬化概述

在虛擬化的大家族中，Linux IO 虛擬化占據(jù)著重要的地位。它專注于解決虛擬機與物理硬件之間輸入 / 輸出（I/O）通信的問題，力求打破 I/O 性能瓶頸，讓虛擬機在數(shù)據(jù)傳輸?shù)母咚俟飞蠒承袩o阻。想象一下，虛擬機就像一個個繁忙的工廠，不斷地需要原材料（輸入數(shù)據(jù)）和輸出產品（輸出數(shù)據(jù)），而 Linux IO 虛擬化就是優(yōu)化工廠運輸線路和裝卸流程的關鍵技術，確保原材料和產品能夠快速、高效地進出工廠。

而 virtio，作為 Linux IO 虛擬化領域的璀璨明星，發(fā)揮著舉足輕重的作用。它就像是一座堅固的橋梁，連接著虛擬機和物理設備，為兩者之間的通信搭建了一條高效、穩(wěn)定的通道。virtio 提供了一套通用的 I/O 設備虛擬化框架，使得不同的虛擬機監(jiān)控器（Hypervisor）和設備驅動能夠基于統(tǒng)一的標準進行交互，大大提高了代碼的可重用性和跨平臺性。無論你使用的是 KVM、Xen 還是其他虛擬化解決方案，virtio 都能像一位可靠的伙伴，為你提供出色的 I/O 虛擬化支持。

Virtio的好處：

• virtio作為一種Linux內部的API，提供了多種前端驅動模塊
• 框架通用，方便模擬各種設備
• 使用半虛擬化可以大大減少VMEXIT次數(shù)，提高性能

1.2Linux IO 虛擬化

在深入了解 virtio 之前，讓我們先來回顧一下 Linux IO 虛擬化的傳統(tǒng)實現(xiàn)方式，以及它所面臨的挑戰(zhàn)。傳統(tǒng)的 Linux IO 虛擬化中，Qemu

當客戶機中的設備驅動程序發(fā)起 I/O 操作請求時，整個流程就像一場精心編排的接力賽。KVM 模塊中的 I/O 操作捕獲代碼首先攔截這次 I/O 請求，就像接力賽中的第一棒選手，迅速接過請求的 “接力棒”。然后，它將本次 I/O 請求的信息存放到 I/O 共享頁，并通知用戶空間的 Qemu 程序。

Qemu 模擬程序獲得 I/O 操作的具體信息之后，交由硬件模擬代碼來模擬出本次的 I/O 操作，完成之后，將結果放回到 I/O 共享頁，并通知 KVM 模塊中的 I/O 操作捕獲代碼。最后，由 KVM 模塊中的捕獲代碼讀取 I/O 共享頁中的操作結果，并把結果返回客戶機中。在這個過程中，客戶機作為一個 Qemu 進程在等待 I/O 時也可能被阻塞，就像接力賽中的選手在傳遞接力棒時可能會遇到一些阻礙。

這種模擬方式雖然具有很強的靈活性，能夠通過軟件模擬出各種各樣的硬件設備，包括一些不常用的或很老很經典的設備，而且不用修改客戶機操作系統(tǒng)，就可以使模擬設備在客戶機中正常工作，為解決手上沒有足夠設備的軟件開發(fā)及調試提供了很大的幫助。但它的缺點也很明顯，每次 I/O 操作的路徑比較長，有較多的 VMEntry、VMExit 發(fā)生，需要多次上下文切換，就像接力賽中選手頻繁交接接力棒，耗費大量時間和精力。

同時，也需要多次數(shù)據(jù)復制，這無疑進一步降低了效率，導致其性能較差。在一些對 I/O 性能要求較高的場景中，如大規(guī)模數(shù)據(jù)處理、實時通信等，傳統(tǒng)的 Qemu 模擬 I/O 設備的方式往往難以滿足需求，就像一輛老舊的汽車，在高速公路上無法達到預期的速度。

隨著虛擬化技術的廣泛應用，對 I/O 性能的要求越來越高，傳統(tǒng)的 IO 虛擬化方式逐漸暴露出其局限性，這也促使了新的技術 ——virtio 的出現(xiàn)，它將為我們帶來怎樣的驚喜呢？讓我們繼續(xù)深入探索。

二、揭開virtio神秘面紗

virtio，作為 Linux IO 虛擬化領域的關鍵技術，究竟是什么呢？簡單來說，virtio 是一種用于虛擬化平臺的 I/O 虛擬化標準 ，它就像是一個智能的翻譯官，讓虛擬機和宿主系統(tǒng)能夠順暢地交流。它由 Rusty Russell 開發(fā)，最初是為了支持自己的虛擬化解決方案 lguest。在半虛擬化的世界里，virtio 扮演著至關重要的角色，它是對一組通用模擬設備的抽象，就像一個萬能的模具，可以根據(jù)不同的需求塑造出各種虛擬設備。

在半虛擬化的架構中，來賓操作系統(tǒng)（也就是虛擬機中的操作系統(tǒng)）需要與 Hypervisor（虛擬機監(jiān)視器）進行緊密的合作 。而 virtio 就像是一座橋梁，連接著來賓操作系統(tǒng)和 Hypervisor。它提供了一組通用的接口，讓來賓操作系統(tǒng)能夠以一種標準化的方式與 Hypervisor 進行交互。這樣一來，不同的虛擬化平臺就可以基于 virtio 實現(xiàn)統(tǒng)一的 I/O 虛擬化，大大提高了開發(fā)效率和兼容性。想象一下，有了 virtio 這座橋梁，不同的虛擬化平臺就像不同語言的人，通過 virtio 這個翻譯官，能夠輕松地溝通和協(xié)作，實現(xiàn)高效的 I/O 虛擬化。

那么，virtio 是如何抽象模擬設備的呢？它通過定義一套通用的設備模型和接口，將各種物理設備的功能抽象出來 。無論是網絡適配器、磁盤驅動器還是其他設備，virtio 都為它們提供了統(tǒng)一的抽象表示。在虛擬化環(huán)境中，虛擬機中的網絡設備可以通過 virtio 接口與 Hypervisor 中的網絡后端進行通信，而不需要關心具體的物理網絡設備是什么。這種抽象模擬的方式，使得 virtio 具有很強的通用性和靈活性，能夠適應各種不同的虛擬化場景。就像一個萬能的遙控器，無論你是控制電視、空調還是其他電器，都可以通過這個遙控器進行操作，而不需要為每種電器都配備一個專門的遙控器。

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

圖片

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

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

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

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

圖片

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

圖片

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

2.2Virtio 緩沖池

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

2.3核心 API

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

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

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

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

三、virtio 架構剖析

3.1整體架構概覽

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

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

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

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

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

3.2關鍵組件解析

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

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

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

當虛擬機需要發(fā)送請求到后端設備時，前端驅動會將存有數(shù)據(jù)的 buffer 添加到 virtqueue 中，然后更新可用描述符表，將對應的描述符標記為可用，并通過寫入寄存器的方式通知后端設備，就像在 “待處理任務清單” 上添加了一項任務，并通知后端工作人員。后端設備接收到通知后，從可用描述符表中讀取請求信息，根據(jù)描述符表中的信息從共享內存中讀出數(shù)據(jù)進行處理。處理完成后，后端設備將響應狀態(tài)存放在已用描述符表中，并通知前端驅動，就像在 “已完成任務清單” 上記錄下完成的任務，并通知前端工作人員。前端驅動從已用描述符表中得到請求完成信息，并獲取請求的數(shù)據(jù)，完成一次數(shù)據(jù)傳輸?shù)倪^程。

3.3初始化

⑴前端初始化

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

• 設備注冊

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);//分配一個唯一的設備index標示
-> dev->config->reset(dev);				//重置config
-> err = device_register(&dev->dev);	//在系統(tǒng)中注冊設備

• 驅動注冊

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

• 設備匹配

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

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

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

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

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

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

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

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

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

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

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

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

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

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

init_vq完成virtqueue和vring的分配，設置隊列的回調函數(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;
	
	/* 調用find_vqs回調函數(shù)(對應vp_find_vqs函數(shù)，
	   在virtio_pci_probe中設置)進行具體的設置。
	   會將相應的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ù)中只是三次調用了vp_try_to_find_vqs函數(shù)來完成操作，
	   只是每次想起傳送的參數(shù)有些不一樣，該函數(shù)的最后兩個參數(shù)：
	   use_msix表示是否使用MSI-X機制的中斷、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設備中斷，有兩種產生中斷情況：

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

三種中斷處理方式：

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

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

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

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

3). 使用msix中斷，有n+1個vector；一個用來對應change中斷，n個分別對應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ù)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ù)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ù)的存放）的分配和初始化任務：

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，設置設備的隊列序號，
	對于塊設備就是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同步信息，如虛擬隊列地址，會調用virtio_queue_set_addr進行處理*/
	iowrite32(virt_to_phys(info->queue) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
		      vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
	...
	/* 調用該函數(shù)分配vring_virtqueue對象，該結構中既包含了vring、又包含了virtqueue，并且返回	virtqueue對象指針*/
	vq = vring_new_virtqueue(info->num, VIRTIO_PCI_VRING_ALIGN,
				 vdev, info->queue, vp_notify, callback, name);
	...
	return vq;
}

IO同步信息，如虛擬隊列地址，會調用virtio_queue_set_addr進行處理：

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;	    //主機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是由客戶機傳送過來的物理頁地址，在主機中就是主機的虛擬頁地址，賦值給主機中對應vq中的vring，則同步了主客機中虛擬隊列地址，之后vring中的當前可用緩沖描述符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;
	}
	/* 調用vring_init函數(shù)初始化vring對象，
	   其desc、avail、used三個域瓜分了上面的
	   setup_vp函數(shù)第一步中分配的內存頁面 */
	vring_init(&vq->vring, num, pages, vring_align);

	/*初始化virtqueue對象(注意其callback會被設置成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;
}

調用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));
}

⑵后端初始化

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

type_init(virtio_pci_register_types)
	--> type_register_static(&virtio_blk_info) // 注冊一個設備結構，為PCI子設備
		--> 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;
}

調用virtio_blk_init來初始化virtio-blk設備，virtio_blk_init代碼如下：

VirtIODevice *virtio_blk_init(DeviceState *dev, VirtIOBlkConf *blk)
{
    VirtIOBlock *s;
    static int virtio_blk_id;
	...
	/* virtio_common_init初始化一個VirtIOBlock結構，
	   這里主要是分配一個VirtIODevice	結構并為它賦值，
	   VirtIODevice結構主要描述IO設備的一些配置接口和屬性。
	   VirtIOBlock結構第一個域是VirtIODevice結構，VirtIOBlock結構
	   還包括一些其他的塊設備屬性和狀態(tài)參數(shù)。*/
    s = (VirtIOBlock *)virtio_common_init("virtio-blk", VIRTIO_ID_BLOCK,
                                          sizeof(struct virtio_blk_config),
                                          sizeof(VirtIOBlock));
	/* 對VirtIOBlock結構中的域賦值，其中比較重要的是對一些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為設置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);
	   設置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注冊虛擬機save和load函數(shù)（熱遷移）*/
	register_savevm(dev, "virtio-blk", virtio_blk_id++, 2,
                    virtio_blk_save, virtio_blk_load, s);
	...
    return &s->vdev;
}

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

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

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

	/*將IO內存綁定到PCI設備，即初始化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并指向設備代理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, },
};

在設備注冊完成后，qemu調用io_region_add進行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調用register_ioport_read及register_ioport_write將io端口對應的回調函數(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ù)*/
        ioport_write_table[bsize][i] = func;  
		...
   }
   return 0;
}

四、virtio 代碼深度探索

4.1數(shù)據(jù)結構探秘

在 virtio 的代碼世界里，vring 和 virtqueue 是最為關鍵的數(shù)據(jù)結構，它們就像是代碼大廈的基石，支撐著整個 virtio 的功能實現(xiàn)。

vring 是 virtio 前端驅動和后端 Hypervisor 虛擬設備之間傳輸數(shù)據(jù)的核心載體 ，它主要由描述符表（Descriptor Table）、可用描述符表（Available Ring）和已用描述符表（Used Ring）這三個部分組成。在早期的 virtio 1.0 版本及之前，這三個部分是相互分離的，形成了所謂的 Split Virtqueue。在這種模式下，每個部分都有其特定的讀寫權限，并且通過 next 字段將多個描述符串接成描述符鏈表的形式來描述一個 IO 請求，這種方式雖然能夠實現(xiàn)基本的數(shù)據(jù)傳輸功能，但在數(shù)據(jù)管理和處理效率上存在一定的局限性。

隨著技術的發(fā)展，virtio 1.1 版本引入了 Packed Virtqueue，它將描述符表、可用描述符表和已用描述符表合并在一起，形成了一個更加緊湊的結構。在這種結構中，增加了 Flag 的相關標記值，去除了 next 字段，同時增加了 Buffer ID，對 entries 支持進行了增強。這樣的設計使得數(shù)據(jù)管理更加高效，也更容易增加與硬件的親和性并更好地利用 Cache。就像重新規(guī)劃了倉庫的布局，使得貨物的存放和取用更加方便快捷。

而 virtqueue 則是對 vring 的進一步封裝和管理，它包含了 vring 以及其他一些與隊列相關的信息和操作函數(shù) 。在實際運行中，Client 會把 Buffers 插入到 virtqueue 中，隊列會根據(jù)不同設備安排不同的數(shù)量。網絡設備通常有兩個隊列，一個用于接收數(shù)據(jù)，一個用于發(fā)送數(shù)據(jù)，這樣可以實現(xiàn)數(shù)據(jù)的高效處理，避免接收和發(fā)送數(shù)據(jù)時的沖突。virtqueue 還提供了一些對 vring 進行操作的函數(shù)，如 add_buf 用于將數(shù)據(jù)緩沖區(qū)添加到隊列中，get_buf 用于從隊列中獲取數(shù)據(jù)緩沖區(qū)，kick 用于通知對端有新的數(shù)據(jù)到來等。這些函數(shù)就像是倉庫管理員的工具，幫助管理員高效地管理倉庫中的貨物。

4.2核心流程解讀

以網絡設備為例，virtio 的數(shù)據(jù)收發(fā)流程是其核心功能的具體體現(xiàn)，這個流程就像是一場緊張有序的接力賽，各個環(huán)節(jié)緊密配合，確保數(shù)據(jù)的高效傳輸。

當網絡設備發(fā)送數(shù)據(jù)時，前端驅動首先會通過 start_xmit 函數(shù)開始數(shù)據(jù)傳輸?shù)穆贸獭Ｔ谶@個函數(shù)中，會調用 xmit_skb 函數(shù)來具體處理數(shù)據(jù)的發(fā)送。xmit_skb 函數(shù)會先使用 sg_init_table 初始化 sg 列表，這個 sg 列表就像是一個貨物清單，記錄了要發(fā)送的數(shù)據(jù)的相關信息。然后，sg_set_buf 將 sg 指向特定的 buffer，skb_to_sgvec 將 socket buffer 中的數(shù)據(jù)填充到 sg 中，就像是將貨物裝載到運輸工具上。

接著，通過 virtqueue_add_outbuf 將 sg 添加到 Virtqueue 中，并更新 Avail 隊列中描述符的索引值，這一步就像是將裝滿貨物的運輸工具放入倉庫的待發(fā)貨區(qū)域，并記錄下貨物的位置信息。最后，virtqueue_notify 通知 Device，可以過來取數(shù)據(jù)了，就像是通知快遞員來取貨。

在數(shù)據(jù)接收方面，當 Qemu 收到 tap 發(fā)送過來的數(shù)據(jù)包后，會在 virtio_net_receive 函數(shù)中把數(shù)據(jù)拷貝到虛擬機的 virtio 網卡接收隊列 。這個過程就像是快遞員將包裹送到倉庫的接收區(qū)域。然后，會向虛擬機注入一個中斷，這樣虛擬機便感知到有網絡數(shù)據(jù)報文的到來。在虛擬機內部，數(shù)據(jù)接收流程從 napi_gro_receive 函數(shù)開始，它會將接收到的數(shù)據(jù)傳輸給網絡層。接著，netif_receive_skb 函數(shù)會將 skb（套接字緩沖區(qū)）傳遞給網絡層進行處理。在驅動的 poll 方法中，會調用 napi_poll 函數(shù)，具體到 virtio_net.c 中就是 virtnet_poll 函數(shù)。

在這個函數(shù)中，會調用 receive_buf 函數(shù)將接收到的數(shù)據(jù)轉換成 skb，然后根據(jù)接收類型（如 XDP_PASS、XDP_TX 等）對 virtqueue 中的數(shù)據(jù)進行不同的處理。如果檢測到本次中斷接收數(shù)據(jù)完成，則會重新開啟中斷，等待下一次中斷接收數(shù)據(jù)。在整個過程中，還會涉及到一些其他的函數(shù)和操作，如 skb_recv_done 函數(shù)用于數(shù)據(jù)接收完成后的回調，virtqueue_napi_schedule 函數(shù)用于調度 NAPI（網絡接口輪詢）等。這些函數(shù)和操作相互配合，確保了數(shù)據(jù)接收的高效和穩(wěn)定。