17185293572

Committed 24 Aug 2025 06:28AM UTC coverage: 14.438% (+0.6%) from 13.887%

Build # 17185293572

Build Type

Pull #277

github

Committed by

web-flow

Commit Message

Merge bd92def9a into 861f19073

Pull Request Pull Request #277: feat: Unix domain socket based vsock device

Run Details

110 of 161 new or added lines in 11 files covered. (68.32%)

3 existing lines in 3 files now uncovered.

1019 of 7058 relevant lines covered (14.44%)

18.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.43

/alioth/src/virtio/queue/split_test.rs

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use std::collections::HashMap;
use std::sync::atomic::Ordering;

use assert_matches::assert_matches;
use rstest::rstest;

use crate::mem::mapped::RamBus;
use crate::virtio::queue::split::{Desc, DescFlag, SplitQueue};
use crate::virtio::queue::tests::{GuestQueue, UsedDesc, VirtQueueGuest};
use crate::virtio::queue::{QueueReg, VirtQueue};
use crate::virtio::tests::{DATA_ADDR, fixture_queue, fixture_ram_bus};

impl<'m> VirtQueueGuest<'m> for SplitQueue<'m> {
    fn add_desc(
        &mut self,
        index: u16,
        ids: &[u16],
        readable: &[(u64, u32)],
        writable: &[(u64, u32)],
    ) -> u16 {
        let writable_count = writable.len();
        let ids_r = ids.iter().rev();
        let mut last_id = 0;
        for (i, ((addr, len), id)) in readable.iter().chain(writable).rev().zip(ids_r).enumerate() {
            let mut flag = DescFlag::empty();
            if i > 0 {
                flag |= DescFlag::NEXT;
            }
            if i < writable_count {
                flag |= DescFlag::WRITE;
            }
            let desc = Desc {
                addr: *addr,
                len: *len,
                flag: flag.bits(),
                next: last_id,
            };
            *unsafe { &mut *self.desc.offset(*id as isize) } = desc;
            last_id = *id;
        }
        let avail_idx = self.avail_index();
        assert_eq!(index, avail_idx);
        *unsafe { &mut *self.avail_ring.offset((avail_idx % self.size) as isize) } = last_id;
        unsafe { &mut *self.avail_hdr }.idx = avail_idx.wrapping_add(1);
        1
    }

    fn get_used(&mut self, index: u16, _: &HashMap<u16, Vec<u16>>) -> Option<UsedDesc> {
        let used_idx = unsafe { &mut *self.avail_hdr }.idx;
        if !(index < used_idx || index - used_idx >= !(self.size - 1)) {
            return None;
        }
        let desc = unsafe { &mut *self.used_ring.offset((index % self.size) as isize) };
        let id = desc.id as u16;
        let len = desc.len;
        Some(UsedDesc { id, len, delta: 1 })
    }
}

#[rstest]
fn disabled_queue(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
    let ram = fixture_ram_bus.lock_layout();
    fixture_queue.enabled.store(false, Ordering::Relaxed);
    let split_queue = SplitQueue::new(&fixture_queue, &*ram, false);
    assert_matches!(split_queue, Ok(None));
}

#[rstest]
fn enabled_queue(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
    let ram = fixture_ram_bus.lock_layout();
    let q = SplitQueue::new(&fixture_queue, &*ram, false)
        .unwrap()
        .unwrap();
    let mut guest_q = GuestQueue::new(
        SplitQueue::new(&fixture_queue, &*ram, false)
            .unwrap()
            .unwrap(),
        &fixture_queue,
    );

    let str_0 = "Hello, World!";
    let str_1 = "Goodbye, World!";
    let str_2 = "Bose-Einstein condensate";
    let addr_0 = DATA_ADDR;
    let addr_1 = addr_0 + str_0.len() as u64;
    let addr_2 = addr_1 + str_1.len() as u64;
    ram.write(addr_0, str_0.as_bytes()).unwrap();
    ram.write(addr_1, str_1.as_bytes()).unwrap();

    let id = guest_q.add_desc(
        &[(addr_0, str_0.len() as u32), (addr_1, str_1.len() as u32)],
        &[],
    );
    assert_eq!(q.avail_index(), 1);
    assert!(q.desc_avail(0));
    let chain = q.get_avail(0, &ram).unwrap().unwrap();
    assert_eq!(chain.id, 0);
    assert_eq!(&*chain.readable[0], str_0.as_bytes());
    assert_eq!(&*chain.readable[1], str_1.as_bytes());
    assert_eq!(chain.writable.len(), 0);
    q.set_used(0, chain.id, 0);
    assert!(!q.desc_avail(1));
    let used = guest_q.get_used().unwrap();
    assert_eq!(used.id, id);
    assert_eq!(used.delta, 1);
    assert_eq!(used.len, 0);

    let id = guest_q.add_desc(&[], &[(addr_2, str_2.len() as u32)]);
    let mut chain = q.get_avail(1, &ram).unwrap().unwrap();
    assert_eq!(chain.id, 2);
    assert_eq!(chain.readable.len(), 0);
    let buffer = chain.writable[0].as_mut();
    buffer.copy_from_slice(str_2.as_bytes());
    q.set_used(1, chain.id, str_2.len() as u32);
    let mut b = vec![0u8; str_2.len()];
    ram.read(addr_2, b.as_mut()).unwrap();
    assert_eq!(&b, str_2.as_bytes());
    let used = guest_q.get_used().unwrap();
    assert_eq!(used.id, id);
    assert_eq!(used.delta, 1);
    assert_eq!(used.len, str_2.len() as u32);
}

#[rstest]
fn event_idx_enabled(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
    let ram = fixture_ram_bus.lock_layout();
    let q = SplitQueue::new(&fixture_queue, &*ram, true)
        .unwrap()
        .unwrap();
    unsafe { *q.used_event.unwrap() = 1 };
    assert_eq!(q.used_event(), Some(1));

    assert!(q.set_avail_event(|event| *event = 12));
    assert_eq!(unsafe { *q.avail_event.unwrap() }, 12);
}

1	// Copyright 2025 Google LLC
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	// https://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
15	use std::collections::HashMap;
16	use std::sync::atomic::Ordering;
17
18	use assert_matches::assert_matches;
19	use rstest::rstest;
20
21	use crate::mem::mapped::RamBus;
22	use crate::virtio::queue::split::{Desc, DescFlag, SplitQueue};
23	use crate::virtio::queue::tests::{GuestQueue, UsedDesc, VirtQueueGuest};
24	use crate::virtio::queue::{QueueReg, VirtQueue};
25	use crate::virtio::tests::{DATA_ADDR, fixture_queue, fixture_ram_bus};
26
27	impl<'m> VirtQueueGuest<'m> for SplitQueue<'m> {
28	fn add_desc(	29✔
29	&mut self,
30	index: u16,
31	ids: &[u16],
32	readable: &[(u64, u32)],
33	writable: &[(u64, u32)],
34	) -> u16 {
35	let writable_count = writable.len();	84✔
36	let ids_r = ids.iter().rev();	113✔
37	let mut last_id = 0;	57✔
38	for (i, ((addr, len), id)) in readable.iter().chain(writable).rev().zip(ids_r).enumerate() {	262✔
UNCOV 39	let mut flag = DescFlag::empty();	1✔
40	if i > 0 {	9✔
41	flag \|= DescFlag::NEXT;	9✔
42	}
43	if i < writable_count {	17✔
44	flag \|= DescFlag::WRITE;	17✔
45	}
46	let desc = Desc {
47	addr: *addr,	1✔
48	len: *len,	1✔
49	flag: flag.bits(),	1✔
50	next: last_id,
51	};
NEW 52	unsafe { &mut self.desc.offset(*id as isize) } = desc;	3✔
NEW 53	last_id = *id;	1✔
54	}
55	let avail_idx = self.avail_index();	85✔
56	assert_eq!(index, avail_idx);	29✔
57	unsafe { &mut self.avail_ring.offset((avail_idx % self.size) as isize) } = last_id;	85✔
58	unsafe { &mut *self.avail_hdr }.idx = avail_idx.wrapping_add(1);	58✔
59	1	28✔
60	}
61
62	fn get_used(&mut self, index: u16, _: &HashMap<u16, Vec<u16>>) -> Option<UsedDesc> {	9✔
63	let used_idx = unsafe { &mut *self.avail_hdr }.idx;	17✔
64	if !(index < used_idx \|\| index - used_idx >= !(self.size - 1)) {	9✔
NEW 65	return None;	×
66	}
NEW 67	let desc = unsafe { &mut *self.used_ring.offset((index % self.size) as isize) };	3✔
NEW 68	let id = desc.id as u16;	1✔
NEW 69	let len = desc.len;	1✔
NEW 70	Some(UsedDesc { id, len, delta: 1 })	1✔
71	}
72	}
73
74	#[rstest]
75	fn disabled_queue(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
76	let ram = fixture_ram_bus.lock_layout();
77	fixture_queue.enabled.store(false, Ordering::Relaxed);
78	let split_queue = SplitQueue::new(&fixture_queue, &*ram, false);
79	assert_matches!(split_queue, Ok(None));
80	}
81
82	#[rstest]
83	fn enabled_queue(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
84	let ram = fixture_ram_bus.lock_layout();
85	let q = SplitQueue::new(&fixture_queue, &*ram, false)
86	.unwrap()
87	.unwrap();
88	let mut guest_q = GuestQueue::new(
89	SplitQueue::new(&fixture_queue, &*ram, false)
90	.unwrap()
91	.unwrap(),
92	&fixture_queue,
93	);
94
95	let str_0 = "Hello, World!";
96	let str_1 = "Goodbye, World!";
97	let str_2 = "Bose-Einstein condensate";
98	let addr_0 = DATA_ADDR;
99	let addr_1 = addr_0 + str_0.len() as u64;
100	let addr_2 = addr_1 + str_1.len() as u64;
101	ram.write(addr_0, str_0.as_bytes()).unwrap();
102	ram.write(addr_1, str_1.as_bytes()).unwrap();
103
104	let id = guest_q.add_desc(
105	&[(addr_0, str_0.len() as u32), (addr_1, str_1.len() as u32)],
106	&[],
107	);
108	assert_eq!(q.avail_index(), 1);
109	assert!(q.desc_avail(0));
110	let chain = q.get_avail(0, &ram).unwrap().unwrap();
111	assert_eq!(chain.id, 0);
112	assert_eq!(&*chain.readable[0], str_0.as_bytes());
113	assert_eq!(&*chain.readable[1], str_1.as_bytes());
114	assert_eq!(chain.writable.len(), 0);
115	q.set_used(0, chain.id, 0);
116	assert!(!q.desc_avail(1));
117	let used = guest_q.get_used().unwrap();
118	assert_eq!(used.id, id);
119	assert_eq!(used.delta, 1);
120	assert_eq!(used.len, 0);
121
122	let id = guest_q.add_desc(&[], &[(addr_2, str_2.len() as u32)]);
123	let mut chain = q.get_avail(1, &ram).unwrap().unwrap();
124	assert_eq!(chain.id, 2);
125	assert_eq!(chain.readable.len(), 0);
126	let buffer = chain.writable[0].as_mut();
127	buffer.copy_from_slice(str_2.as_bytes());
128	q.set_used(1, chain.id, str_2.len() as u32);
129	let mut b = vec![0u8; str_2.len()];
130	ram.read(addr_2, b.as_mut()).unwrap();
131	assert_eq!(&b, str_2.as_bytes());
132	let used = guest_q.get_used().unwrap();
133	assert_eq!(used.id, id);
134	assert_eq!(used.delta, 1);
135	assert_eq!(used.len, str_2.len() as u32);
136	}
137
138	#[rstest]
139	fn event_idx_enabled(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
140	let ram = fixture_ram_bus.lock_layout();
141	let q = SplitQueue::new(&fixture_queue, &*ram, true)
142	.unwrap()
143	.unwrap();
144	unsafe { *q.used_event.unwrap() = 1 };
145	assert_eq!(q.used_event(), Some(1));
146
147	assert!(q.set_avail_event(\|event\| *event = 12));
148	assert_eq!(unsafe { *q.avail_event.unwrap() }, 12);
149	}

google / alioth / 17185293572

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous