blob: 1e8768274dbc16da663f8c31099d876e60ae5ea1 [file] [log] [blame]
Andrew Walbran8217d062022-11-22 16:56:18 +00001// Copyright 2022, The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
Andrew Walbran0a8dac72022-12-21 13:49:06 +000015//! Functions to scan the PCI bus for VirtIO device.
Andrew Walbran8217d062022-11-22 16:56:18 +000016
Andrew Walbrancf9333e2023-05-16 16:00:35 +000017use alloc::alloc::{alloc_zeroed, dealloc, handle_alloc_error, Layout};
Andrew Walbran336d0cb2023-01-06 16:33:15 +000018use core::{mem::size_of, ptr::NonNull};
Andrew Walbran8217d062022-11-22 16:56:18 +000019use log::{debug, info};
20use virtio_drivers::{
Alice Wang7c55c7d2023-07-05 14:51:40 +000021 device::console::VirtIOConsole,
Andrew Walbran336d0cb2023-01-06 16:33:15 +000022 transport::{
Andrew Walbraneb75fb92024-12-13 15:37:30 +000023 pci::{
24 bus::{ConfigurationAccess, PciRoot},
25 PciTransport,
26 },
Andrew Walbran336d0cb2023-01-06 16:33:15 +000027 DeviceType, Transport,
28 },
Andrew Walbran6ac174e2023-06-23 14:58:51 +000029 BufferDirection, Error, Hal, PhysAddr, PAGE_SIZE,
Andrew Walbran8217d062022-11-22 16:56:18 +000030};
Pierre-Clément Tosid2c54722024-11-02 12:54:40 +000031use vmbase::virtio::pci::{self, PciTransportIterator};
Andrew Walbran8217d062022-11-22 16:56:18 +000032
33/// The standard sector size of a VirtIO block device, in bytes.
Andrew Walbranb713baa2022-12-07 14:34:49 +000034const SECTOR_SIZE_BYTES: usize = 512;
35
36/// The size in sectors of the test block device we expect.
37const EXPECTED_SECTOR_COUNT: usize = 4;
Andrew Walbran8217d062022-11-22 16:56:18 +000038
Andrew Walbraneb75fb92024-12-13 15:37:30 +000039pub fn check_pci(pci_root: &mut PciRoot<impl ConfigurationAccess>) {
Andrew Walbranb713baa2022-12-07 14:34:49 +000040 let mut checked_virtio_device_count = 0;
Andrew Walbran6ac174e2023-06-23 14:58:51 +000041 let mut block_device_count = 0;
Alice Wang16e7c3f2023-07-06 08:06:00 +000042 let mut socket_device_count = 0;
Andrew Walbraneb75fb92024-12-13 15:37:30 +000043 for mut transport in PciTransportIterator::<HalImpl, _>::new(pci_root) {
Alice Wang7c55c7d2023-07-05 14:51:40 +000044 info!(
45 "Detected virtio PCI device with device type {:?}, features {:#018x}",
46 transport.device_type(),
47 transport.read_device_features(),
48 );
49 match transport.device_type() {
50 DeviceType::Block => {
51 check_virtio_block_device(transport, block_device_count);
52 block_device_count += 1;
53 checked_virtio_device_count += 1;
Andrew Walbranb713baa2022-12-07 14:34:49 +000054 }
Alice Wang7c55c7d2023-07-05 14:51:40 +000055 DeviceType::Console => {
56 check_virtio_console_device(transport);
57 checked_virtio_device_count += 1;
58 }
Alice Wang16e7c3f2023-07-06 08:06:00 +000059 DeviceType::Socket => {
60 check_virtio_socket_device(transport);
61 socket_device_count += 1;
62 checked_virtio_device_count += 1;
63 }
Alice Wang7c55c7d2023-07-05 14:51:40 +000064 _ => {}
Andrew Walbran8217d062022-11-22 16:56:18 +000065 }
66 }
Andrew Walbranb713baa2022-12-07 14:34:49 +000067
Alice Wang16e7c3f2023-07-06 08:06:00 +000068 assert_eq!(checked_virtio_device_count, 6);
Andrew Walbran6ac174e2023-06-23 14:58:51 +000069 assert_eq!(block_device_count, 2);
Alice Wang16e7c3f2023-07-06 08:06:00 +000070 assert_eq!(socket_device_count, 1);
Andrew Walbran8217d062022-11-22 16:56:18 +000071}
72
Andrew Walbran6ac174e2023-06-23 14:58:51 +000073/// Checks the given VirtIO block device.
Alice Wang7c55c7d2023-07-05 14:51:40 +000074fn check_virtio_block_device(transport: PciTransport, index: usize) {
75 let mut blk = pci::VirtIOBlk::<HalImpl>::new(transport).expect("failed to create blk driver");
Andrew Walbran6ac174e2023-06-23 14:58:51 +000076 info!("Found {} KiB block device.", blk.capacity() * SECTOR_SIZE_BYTES as u64 / 1024);
77 match index {
78 0 => {
Andrew Walbran8d05dae2023-03-22 16:42:55 +000079 assert_eq!(blk.capacity(), EXPECTED_SECTOR_COUNT as u64);
80 let mut data = [0; SECTOR_SIZE_BYTES * EXPECTED_SECTOR_COUNT];
81 for i in 0..EXPECTED_SECTOR_COUNT {
Alice Wangb27ec8f2023-07-27 13:19:26 +000082 blk.read_blocks(i, &mut data[i * SECTOR_SIZE_BYTES..(i + 1) * SECTOR_SIZE_BYTES])
Andrew Walbran8d05dae2023-03-22 16:42:55 +000083 .expect("Failed to read block device.");
84 }
85 for (i, chunk) in data.chunks(size_of::<u32>()).enumerate() {
86 assert_eq!(chunk, &(i as u32).to_le_bytes());
87 }
88 info!("Read expected data from block device.");
Andrew Walbranb713baa2022-12-07 14:34:49 +000089 }
Andrew Walbran6ac174e2023-06-23 14:58:51 +000090 1 => {
91 assert_eq!(blk.capacity(), 0);
92 let mut data = [0; SECTOR_SIZE_BYTES];
Alice Wangb27ec8f2023-07-27 13:19:26 +000093 assert_eq!(blk.read_blocks(0, &mut data), Err(Error::IoError));
Andrew Walbranb713baa2022-12-07 14:34:49 +000094 }
Andrew Walbran6ac174e2023-06-23 14:58:51 +000095 _ => panic!("Unexpected VirtIO block device index {}.", index),
Andrew Walbran8217d062022-11-22 16:56:18 +000096 }
97}
98
Alice Wang16e7c3f2023-07-06 08:06:00 +000099/// Checks the given VirtIO socket device.
100fn check_virtio_socket_device(transport: PciTransport) {
101 let socket = pci::VirtIOSocket::<HalImpl>::new(transport)
102 .expect("Failed to create VirtIO socket driver");
103 info!("Found socket device: guest_cid={}", socket.guest_cid());
104}
105
Andrew Walbran6ac174e2023-06-23 14:58:51 +0000106/// Checks the given VirtIO console device.
Alice Wang7c55c7d2023-07-05 14:51:40 +0000107fn check_virtio_console_device(transport: PciTransport) {
108 let mut console = VirtIOConsole::<HalImpl, PciTransport>::new(transport)
Andrew Walbran6ac174e2023-06-23 14:58:51 +0000109 .expect("Failed to create VirtIO console driver");
Andrew Walbraneb75fb92024-12-13 15:37:30 +0000110 info!(
111 "Found console device with size {:?}",
112 console.size().expect("Failed to get size of VirtIO console device")
113 );
Andrew Walbran6ac174e2023-06-23 14:58:51 +0000114 for &c in b"Hello VirtIO console\n" {
115 console.send(c).expect("Failed to send character to VirtIO console device");
116 }
117 info!("Wrote to VirtIO console.");
118}
119
Andrew Walbran8217d062022-11-22 16:56:18 +0000120struct HalImpl;
121
Andrew Walbran47842802023-07-05 16:56:08 +0000122/// SAFETY: See the 'Implementation Safety' comments on methods below for how they fulfill the
123/// safety requirements of the unsafe `Hal` trait.
Alice Wang63e0d0d2023-04-20 14:15:32 +0000124unsafe impl Hal for HalImpl {
Andrew Walbran47842802023-07-05 16:56:08 +0000125 /// # Implementation Safety
126 ///
127 /// `dma_alloc` ensures the returned DMA buffer is not aliased with any other allocation or
128 /// reference in the program until it is deallocated by `dma_dealloc` by allocating a unique
129 /// block of memory using `alloc_zeroed`, which is guaranteed to allocate valid, unique and
130 /// zeroed memory. We request an alignment of at least `PAGE_SIZE` from `alloc_zeroed`.
Andrew Walbran272bd7a2023-01-24 14:02:36 +0000131 fn dma_alloc(pages: usize, _direction: BufferDirection) -> (PhysAddr, NonNull<u8>) {
Andrew Walbran8217d062022-11-22 16:56:18 +0000132 debug!("dma_alloc: pages={}", pages);
Andrew Walbran47842802023-07-05 16:56:08 +0000133 let layout =
134 Layout::from_size_align(pages.checked_mul(PAGE_SIZE).unwrap(), PAGE_SIZE).unwrap();
135 assert_ne!(layout.size(), 0);
136 // SAFETY: We just checked that the layout has a non-zero size.
Andrew Walbrancf9333e2023-05-16 16:00:35 +0000137 let vaddr = unsafe { alloc_zeroed(layout) };
Andrew Walbran272bd7a2023-01-24 14:02:36 +0000138 let vaddr =
139 if let Some(vaddr) = NonNull::new(vaddr) { vaddr } else { handle_alloc_error(layout) };
140 let paddr = virt_to_phys(vaddr);
141 (paddr, vaddr)
Andrew Walbran8217d062022-11-22 16:56:18 +0000142 }
143
Alice Wang63e0d0d2023-04-20 14:15:32 +0000144 unsafe fn dma_dealloc(paddr: PhysAddr, vaddr: NonNull<u8>, pages: usize) -> i32 {
Andrew Walbran8217d062022-11-22 16:56:18 +0000145 debug!("dma_dealloc: paddr={:#x}, pages={}", paddr, pages);
Andrew Walbran8217d062022-11-22 16:56:18 +0000146 let layout = Layout::from_size_align(pages * PAGE_SIZE, PAGE_SIZE).unwrap();
Andrew Walbran47842802023-07-05 16:56:08 +0000147 // SAFETY: The memory was allocated by `dma_alloc` above using the same allocator, and the
148 // layout is the same as was used then.
Andrew Walbran8217d062022-11-22 16:56:18 +0000149 unsafe {
Andrew Walbran272bd7a2023-01-24 14:02:36 +0000150 dealloc(vaddr.as_ptr(), layout);
Andrew Walbran8217d062022-11-22 16:56:18 +0000151 }
152 0
153 }
154
Andrew Walbran47842802023-07-05 16:56:08 +0000155 /// # Implementation Safety
156 ///
157 /// The returned pointer must be valid because the `paddr` describes a valid MMIO region, and we
158 /// previously mapped the entire PCI MMIO range. It can't alias any other allocations because
159 /// the PCI MMIO range doesn't overlap with any other memory ranges.
Alice Wang63e0d0d2023-04-20 14:15:32 +0000160 unsafe fn mmio_phys_to_virt(paddr: PhysAddr, _size: usize) -> NonNull<u8> {
Andrew Walbran272bd7a2023-01-24 14:02:36 +0000161 NonNull::new(paddr as _).unwrap()
Andrew Walbran8217d062022-11-22 16:56:18 +0000162 }
163
Alice Wang63e0d0d2023-04-20 14:15:32 +0000164 unsafe fn share(buffer: NonNull<[u8]>, _direction: BufferDirection) -> PhysAddr {
Andrew Walbran272bd7a2023-01-24 14:02:36 +0000165 let vaddr = buffer.cast();
Andrew Walbran336d0cb2023-01-06 16:33:15 +0000166 // Nothing to do, as the host already has access to all memory.
167 virt_to_phys(vaddr)
Andrew Walbran8217d062022-11-22 16:56:18 +0000168 }
Andrew Walbran336d0cb2023-01-06 16:33:15 +0000169
Alice Wang63e0d0d2023-04-20 14:15:32 +0000170 unsafe fn unshare(_paddr: PhysAddr, _buffer: NonNull<[u8]>, _direction: BufferDirection) {
Andrew Walbran336d0cb2023-01-06 16:33:15 +0000171 // Nothing to do, as the host already has access to all memory and we didn't copy the buffer
172 // anywhere else.
173 }
174}
175
Andrew Walbran272bd7a2023-01-24 14:02:36 +0000176fn virt_to_phys(vaddr: NonNull<u8>) -> PhysAddr {
177 vaddr.as_ptr() as _
Andrew Walbran8217d062022-11-22 16:56:18 +0000178}