在實現外部中斷的機制以後，我們已經在先前的 Lab 中加入了 UART 的 ISR，為了讓作業系統能夠讀取磁碟資料，我們必須加入 VirtIO 的 ISR :
void external_handler()
{
int irq = plic_claim();
if (irq == UART0_IRQ)
{
lib_isr();
}
else if (irq == VIRTIO_IRQ)
{
virtio_disk_isr();
}
else if (irq)
{
lib_printf("unexpected interrupt irq = %d\n", irq);
}
if (irq)
{
plic_complete(irq);
}
}當然，在開始之前我們仍需要認識一下 VirtIO 協定。
Descriptor 包含這些訊息: 地址，地址長度，某些 flag 和其他信息。 使用 Descriptor，我們可以將設備指向 RAM 中任何緩衝區的內存位址。
struct virtq_desc
{
uint64 addr;
uint32 len;
uint16 flags;
uint16 next;
};- addr: 我們可以在 64-bit 內存地址內的任何位置告訴設備存儲位置。
- len: 讓 Device 知道有多少內存可用。
- flags: 用於控制 descriptor。
- next: 告訴 Device 下一個描述符的 Index。如果指定了 VIRTQ_DESC_F_NEXT，Device 僅讀取該字段。否則無效。
用來存放 Descriptor 的索引，當 Device 收到通知時，它會檢查 AvailableRing 確認需要讀取哪些 Descriptor。
需要注意的是: Descriptor 和 AvailableRing 都存儲在 RAM 中。
struct virtq_avail
{
uint16 flags; // always zero
uint16 idx; // driver will write ring[idx] next
uint16 ring[NUM]; // descriptor numbers of chain heads
uint16 unused;
};UsedRing 讓 Device 能夠向 OS 發送訊息，因此，Device 通常使用它來告知 OS 它已完成先前通知的請求。 AvailableRing 與 UsedRing 非常相似，差別在於: OS 需要查看 UsedRing 得知哪個 Descriptor 已經被服務。
struct virtq_used_elem
{
uint32 id; // index of start of completed descriptor chain
uint32 len;
};
struct virtq_used
{
uint16 flags; // always zero
uint16 idx; // device increments when it adds a ring[] entry
struct virtq_used_elem ring[NUM];
};為了節省閱讀 VirtIO Spec 的時間，本次的 Block Device Driver 參考了 xv6-riscv 的實作，不過在 xv6 的檔案系統實作中有非常多層:
+------------------+
| File descriptor |
+------------------+
| Pathname |
+------------------+
| Directory |
+------------------+
| Inode |
+------------------+
| Logging |
+------------------+
| Buffer cache |
+------------------+
| Disk |
+------------------+
完成 Device Driver 會讓我們在日後實現檔案系統更為方便，此外，參考 xv6-riscv 的設計，我們還會需要實現一層 Buffer cache 用來同步硬碟上的資料。
uint64_t sector = b->blockno * (BSIZE / 512);因為 qemu-virt 會一次讀取 3 個 descriptor，所以在發送請求之前我們要先分配好這些空間。
static int
alloc3_desc(int *idx)
{
for (int i = 0; i < 3; i++)
{
idx[i] = alloc_desc();
if (idx[i] < 0)
{
for (int j = 0; j < i; j++)
free_desc(idx[j]);
return -1;
}
}
return 0;
}宣告 req 的結構:
struct virtio_blk_req *buf0 = &disk.ops[idx[0]];因為磁碟有讀寫操作之分，為了讓 qemu 知道要讀還是要寫，我們要在請求中的 type 成員中寫入 flag :
if(write)
buf0->type = VIRTIO_BLK_T_OUT; // write the disk
else
buf0->type = VIRTIO_BLK_T_IN; // read the disk
buf0->reserved = 0; // The reserved portion is used to pad the header to 16 bytes and move the 32-bit sector field to the correct place.
buf0->sector = sector; // specify the sector that we wanna modified.到了這一步，我們已經分配好 Descriptor 與 req 的基本資料了，接著我們可以對這三個 Descriptor 做資料填充:
disk.desc[idx[0]].addr = buf0;
disk.desc[idx[0]].len = sizeof(struct virtio_blk_req);
disk.desc[idx[0]].flags = VRING_DESC_F_NEXT;
disk.desc[idx[0]].next = idx[1];
disk.desc[idx[1]].addr = ((uint32)b->data) & 0xffffffff;
disk.desc[idx[1]].len = BSIZE;
if (write)
disk.desc[idx[1]].flags = 0; // device reads b->data
else
disk.desc[idx[1]].flags = VRING_DESC_F_WRITE; // device writes b->data
disk.desc[idx[1]].flags |= VRING_DESC_F_NEXT;
disk.desc[idx[1]].next = idx[2];
disk.info[idx[0]].status = 0xff; // device writes 0 on success
disk.desc[idx[2]].addr = (uint32)&disk.info[idx[0]].status;
disk.desc[idx[2]].len = 1;
disk.desc[idx[2]].flags = VRING_DESC_F_WRITE; // device writes the status
disk.desc[idx[2]].next = 0;
// record struct buf for virtio_disk_intr().
b->disk = 1;
disk.info[idx[0]].b = b;
// tell the device the first index in our chain of descriptors.
disk.avail->ring[disk.avail->idx % NUM] = idx[0];
__sync_synchronize();
// tell the device another avail ring entry is available.
disk.avail->idx += 1; // not % NUM ...
__sync_synchronize();
*R(VIRTIO_MMIO_QUEUE_NOTIFY) = 0; // value is queue number
// Wait for virtio_disk_intr() to say request has finished.
while (b->disk == 1)
{
}
disk.info[idx[0]].b = 0;
free_chain(idx[0]);
當 Descriptor 被填充完畢，*R(VIRTIO_MMIO_QUEUE_NOTIFY) = 0; 會提醒 VIRTIO 接收我們的 Block request。
此外，while (b->disk == 1) 可以確保作業系統收到 Virtio 發出的外部中斷後再繼續執行下面的程式碼。
當系統程式接收到外部中斷，會根據 IRQ Number 判斷中斷是由哪一個外部設備發起的 (VirtIO, UART...)。
void external_handler()
{
int irq = plic_claim();
if (irq == UART0_IRQ)
{
lib_isr();
}
else if (irq == VIRTIO_IRQ)
{
lib_puts("Virtio IRQ\n");
virtio_disk_isr();
}
else if (irq)
{
lib_printf("unexpected interrupt irq = %d\n", irq);
}
if (irq)
{
plic_complete(irq);
}
}如果是 VirtIO 發起的中斷，便會轉派給 virtio_disk_isr() 進行處理。
void virtio_disk_isr()
{
// the device won't raise another interrupt until we tell it
// we've seen this interrupt, which the following line does.
// this may race with the device writing new entries to
// the "used" ring, in which case we may process the new
// completion entries in this interrupt, and have nothing to do
// in the next interrupt, which is harmless.
*R(VIRTIO_MMIO_INTERRUPT_ACK) = *R(VIRTIO_MMIO_INTERRUPT_STATUS) & 0x3;
__sync_synchronize();
// the device increments disk.used->idx when it
// adds an entry to the used ring.
while (disk.used_idx != disk.used->idx)
{
__sync_synchronize();
int id = disk.used->ring[disk.used_idx % NUM].id;
if (disk.info[id].status != 0)
panic("virtio_disk_intr status");
struct blk *b = disk.info[id].b;
b->disk = 0; // disk is done with buf
disk.used_idx += 1;
}
}virtio_disk_isr() 主要工作會將 disk 的狀態改下，告訴系統先前發出的讀寫操作已經被順利執行了。
其中 b->disk = 0;，可以讓先前提到的 while (b->disk == 1) 順利跳出，釋放 disk 中的自旋鎖。
int os_main(void)
{
os_start();
disk_read();
int current_task = 0;
while (1)
{
lib_puts("OS: Activate next task\n");
task_go(current_task);
lib_puts("OS: Back to OS\n");
current_task = (current_task + 1) % taskTop; // Round Robin Scheduling
lib_puts("\n");
}
return 0;
}由於 mini-riscv-os 並沒有實作能夠休眠的鎖，所以筆者將 disk_read() 這個測試函式在開機時執行一次，若要向上實現更高層的檔案系統，就會需要使用 sleep lock，以避免當有多個任務嘗試取用硬碟資源時造成 deadlock 的情況發生。