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

93.55

/alioth/src/virtio/queue/packed_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::packed::{DescEvent, EventFlag, PackedQueue, WrappedIndex};
use crate::virtio::queue::tests::{GuestQueue, UsedDesc, VirtQueueGuest};
use crate::virtio::queue::{DescFlag, QueueReg, VirtQueue};
use crate::virtio::tests::{DATA_ADDR, QUEUE_SIZE, fixture_queue, fixture_ram_bus};

const WRAP_COUNTER: u16 = 1 << 15;

#[rstest]
#[case(3, 0, 1, 1)]
#[case(5, 4, 4, WRAP_COUNTER | 3)]
#[case(3, WRAP_COUNTER | 0, 1, WRAP_COUNTER | 1)]
#[case(5, WRAP_COUNTER | 4, 1, 0)]
fn index_wrapping_add(
    #[case] size: u16,
    #[case] index: u16,
    #[case] delta: u16,
    #[case] expected: u16,
) {
    assert_eq!(
        WrappedIndex(index).wrapping_add(delta, size),
        WrappedIndex(expected)
    );
}

#[rstest]
#[case(3, 1, 1, 0)]
#[case(5, WRAP_COUNTER | 3, 4, 4)]
#[case(3, WRAP_COUNTER | 1, 1, WRAP_COUNTER | 0)]
#[case(5, 0, 1, WRAP_COUNTER | 4)]
fn index_wrapping_sub(
    #[case] size: u16,
    #[case] index: u16,
    #[case] delta: u16,
    #[case] expected: u16,
) {
    assert_eq!(
        WrappedIndex(index).wrapping_sub(delta, size),
        WrappedIndex(expected)
    );
}

impl<'m> PackedQueue<'m> {
    fn flag_is_used(&self, flag: DescFlag, wrap_counter: bool) -> bool {
        flag.contains(DescFlag::AVAIL) == wrap_counter
            && flag.contains(DescFlag::USED) == wrap_counter
    }
}

impl<'m> VirtQueueGuest<'m> for PackedQueue<'m> {
    fn add_desc(
        &mut self,
        index: WrappedIndex,
        ids: &[u16],
        readable: &[(u64, u32)],
        writable: &[(u64, u32)],
    ) -> u16 {
        let writable_count = writable.len();
        let total_count = readable.len() + writable.len();
        let id = ids[0];
        for (i, (addr, len)) in readable.iter().chain(writable).rev().enumerate() {
            let index = index.wrapping_add((total_count - 1 - i) as u16, self.size);
            let mut flag = if index.wrap_counter() {
                DescFlag::AVAIL
            } else {
                DescFlag::USED
            };
            if i > 0 {
                flag |= DescFlag::NEXT;
            }
            if i < writable_count {
                flag |= DescFlag::WRITE;
            }
            let desc = unsafe { &mut *self.desc.offset(index.offset() as isize) };
            desc.addr = *addr;
            desc.len = *len;
            desc.id = id;
            desc.flag = flag.bits();
        }
        ids.len() as u16
    }

    fn get_used(
        &mut self,
        index: Self::Index,
        chains: &HashMap<u16, Vec<u16>>,
    ) -> Option<UsedDesc> {
        let desc = unsafe { &mut *self.desc.offset(index.offset() as isize) };
        let flag = DescFlag::from_bits_retain(desc.flag);
        if !self.flag_is_used(flag, index.wrap_counter()) {
            return None;
        }
        Some(UsedDesc {
            id: desc.id,
            len: desc.len,
            delta: chains[&desc.id].len() as u16,
        })
    }
}

#[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 = PackedQueue::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 = PackedQueue::new(&fixture_queue, &*ram, false)
        .unwrap()
        .unwrap();
    let mut guest_q = GuestQueue::new(
        PackedQueue::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 mut avail_index = WrappedIndex::INIT;
    let mut used_index = WrappedIndex::INIT;

    let id = guest_q.add_desc(
        &[(addr_0, str_0.len() as u32), (addr_1, str_1.len() as u32)],
        &[],
    );
    assert!(q.desc_avail(avail_index));
    let chain = q.get_avail(avail_index, &ram).unwrap().unwrap();
    avail_index = q.index_add(avail_index, chain.delta);
    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(used_index, chain.id, 0);
    used_index = q.index_add(used_index, chain.delta);

    assert_eq!(avail_index, WrappedIndex(WRAP_COUNTER | 2));
    assert_matches!(q.get_avail(avail_index, &ram), Ok(None));
    let used = guest_q.get_used().unwrap();
    assert_eq!(used.id, id);
    assert_eq!(used.delta, 2);
    assert_eq!(used.len, 0);

    let id = guest_q.add_desc(&[], &[(addr_2, str_2.len() as u32)]);
    let mut chain = q.get_avail(avail_index, &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(used_index, chain.id, str_2.len() as u32);

    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);

    let mut b = vec![0u8; str_2.len()];
    ram.read(addr_2, b.as_mut()).unwrap();
    assert_eq!(&b, str_2.as_bytes());
}

#[rstest]
fn enable_notification(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
    let ram = fixture_ram_bus.lock_layout();
    let q = PackedQueue::new(&fixture_queue, &*ram, false)
        .unwrap()
        .unwrap();

    q.enable_notification(false);
    assert_eq!(unsafe { &*q.notification }.flag, EventFlag::DISABLE);
    q.enable_notification(true);
    assert_eq!(unsafe { &*q.notification }.flag, EventFlag::ENABLE);
}

#[rstest]
#[case(false, EventFlag::DISABLE, 0, 1, 1, false)]
#[case(false, EventFlag::ENABLE, 0, 1, 1, true)]
#[case(false, EventFlag::DESC, 0, 1, 1, false)]
#[case(true, EventFlag::ENABLE, 0, 1, 1, true)]
#[case(true, EventFlag::DISABLE, 0, 1, 1, false)]
#[case(true, EventFlag::DESC, 0, 2, 1, false)]
#[case(true, EventFlag::DESC, 0, 2, 2, true)]
#[case(true, EventFlag::DESC, 0, 2, 3, true)]
#[case(true, EventFlag::DESC, WRAP_COUNTER | 0, 2, 3, false)]
#[case(true, EventFlag::DESC, WRAP_COUNTER | (QUEUE_SIZE - 1), 2, 2, false)]
#[case(true, EventFlag::DESC, WRAP_COUNTER | (QUEUE_SIZE - 1), 2, 3, true)]
#[case(true, EventFlag::DESC, QUEUE_SIZE - 1, WRAP_COUNTER | 1, 1, false)]
#[case(true, EventFlag::DESC, QUEUE_SIZE - 1, WRAP_COUNTER | 1, 2, true)]
fn is_interrupt_enabled(
    fixture_ram_bus: RamBus,
    fixture_queue: QueueReg,
    #[case] enable_event_idx: bool,
    #[case] event_flag: EventFlag,
    #[case] event_index: u16,
    #[case] used_index: u16,
    #[case] delta: u16,
    #[case] expected: bool,
) {
    let ram = fixture_ram_bus.lock_layout();
    let q = PackedQueue::new(&fixture_queue, &*ram, enable_event_idx)
        .unwrap()
        .unwrap();

    *unsafe { &mut *q.interrupt } = DescEvent {
        index: WrappedIndex(event_index),
        flag: event_flag,
    };

    assert_eq!(
        q.interrupt_enabled(WrappedIndex(used_index), delta),
        expected
    );
}

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::packed::{DescEvent, EventFlag, PackedQueue, WrappedIndex};
23	use crate::virtio::queue::tests::{GuestQueue, UsedDesc, VirtQueueGuest};
24	use crate::virtio::queue::{DescFlag, QueueReg, VirtQueue};
25	use crate::virtio::tests::{DATA_ADDR, QUEUE_SIZE, fixture_queue, fixture_ram_bus};
26
27	const WRAP_COUNTER: u16 = 1 << 15;
28
29	#[rstest]
30	#[case(3, 0, 1, 1)]
31	#[case(5, 4, 4, WRAP_COUNTER \| 3)]
32	#[case(3, WRAP_COUNTER \| 0, 1, WRAP_COUNTER \| 1)]
33	#[case(5, WRAP_COUNTER \| 4, 1, 0)]
34	fn index_wrapping_add(
35	#[case] size: u16,
36	#[case] index: u16,
37	#[case] delta: u16,
38	#[case] expected: u16,
39	) {
40	assert_eq!(
41	WrappedIndex(index).wrapping_add(delta, size),
42	WrappedIndex(expected)
43	);
44	}
45
46	#[rstest]
47	#[case(3, 1, 1, 0)]
48	#[case(5, WRAP_COUNTER \| 3, 4, 4)]
49	#[case(3, WRAP_COUNTER \| 1, 1, WRAP_COUNTER \| 0)]
50	#[case(5, 0, 1, WRAP_COUNTER \| 4)]
51	fn index_wrapping_sub(
52	#[case] size: u16,
53	#[case] index: u16,
54	#[case] delta: u16,
55	#[case] expected: u16,
56	) {
57	assert_eq!(
58	WrappedIndex(index).wrapping_sub(delta, size),
59	WrappedIndex(expected)
60	);
61	}
62
63	impl<'m> PackedQueue<'m> {
64	fn flag_is_used(&self, flag: DescFlag, wrap_counter: bool) -> bool {	5✔
65	flag.contains(DescFlag::AVAIL) == wrap_counter	9✔
66	&& flag.contains(DescFlag::USED) == wrap_counter	9✔
67	}
68	}
69
70	impl<'m> VirtQueueGuest<'m> for PackedQueue<'m> {
71	fn add_desc(	5✔
72	&mut self,
73	index: WrappedIndex,
74	ids: &[u16],
75	readable: &[(u64, u32)],
76	writable: &[(u64, u32)],
77	) -> u16 {
78	let writable_count = writable.len();	12✔
79	let total_count = readable.len() + writable.len();	17✔
80	let id = ids[0];	10✔
81	for (i, (addr, len)) in readable.iter().chain(writable).rev().enumerate() {	33✔
NEW 82	let index = index.wrapping_add((total_count - 1 - i) as u16, self.size);	2✔
UNCOV 83	let mut flag = if index.wrap_counter() {	1✔
84	DescFlag::AVAIL	7✔
85	} else {
86	DescFlag::USED	×
87	};
88	if i > 0 {	3✔
89	flag \|= DescFlag::NEXT;	3✔
90	}
91	if i < writable_count {	3✔
92	flag \|= DescFlag::WRITE;	3✔
93	}
NEW 94	let desc = unsafe { &mut *self.desc.offset(index.offset() as isize) };	3✔
NEW 95	desc.addr = *addr;	1✔
NEW 96	desc.len = *len;	1✔
NEW 97	desc.id = id;	1✔
NEW 98	desc.flag = flag.bits();	1✔
99	}
100	ids.len() as u16	4✔
101	}
102
103	fn get_used(	5✔
104	&mut self,
105	index: Self::Index,
106	chains: &HashMap<u16, Vec<u16>>,
107	) -> Option<UsedDesc> {
108	let desc = unsafe { &mut *self.desc.offset(index.offset() as isize) };	18✔
109	let flag = DescFlag::from_bits_retain(desc.flag);	13✔
110	if !self.flag_is_used(flag, index.wrap_counter()) {	17✔
NEW 111	return None;	×
112	}
113	Some(UsedDesc {	5✔
114	id: desc.id,	9✔
115	len: desc.len,	9✔
116	delta: chains[&desc.id].len() as u16,	5✔
117	})
118	}
119	}
120
121	#[rstest]
122	fn disabled_queue(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
123	let ram = fixture_ram_bus.lock_layout();
124	fixture_queue.enabled.store(false, Ordering::Relaxed);
125	let split_queue = PackedQueue::new(&fixture_queue, &*ram, false);
126	assert_matches!(split_queue, Ok(None));
127	}
128
129	#[rstest]
130	fn enabled_queue(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
131	let ram = fixture_ram_bus.lock_layout();
132	let q = PackedQueue::new(&fixture_queue, &*ram, false)
133	.unwrap()
134	.unwrap();
135	let mut guest_q = GuestQueue::new(
136	PackedQueue::new(&fixture_queue, &*ram, false)
137	.unwrap()
138	.unwrap(),
139	&fixture_queue,
140	);
141
142	let str_0 = "Hello, World!";
143	let str_1 = "Goodbye, World!";
144	let str_2 = "Bose-Einstein condensate";
145	let addr_0 = DATA_ADDR;
146	let addr_1 = addr_0 + str_0.len() as u64;
147	let addr_2 = addr_1 + str_1.len() as u64;
148	ram.write(addr_0, str_0.as_bytes()).unwrap();
149	ram.write(addr_1, str_1.as_bytes()).unwrap();
150
151	let mut avail_index = WrappedIndex::INIT;
152	let mut used_index = WrappedIndex::INIT;
153
154	let id = guest_q.add_desc(
155	&[(addr_0, str_0.len() as u32), (addr_1, str_1.len() as u32)],
156	&[],
157	);
158	assert!(q.desc_avail(avail_index));
159	let chain = q.get_avail(avail_index, &ram).unwrap().unwrap();
160	avail_index = q.index_add(avail_index, chain.delta);
161	assert_eq!(chain.id, 0);
162	assert_eq!(&*chain.readable[0], str_0.as_bytes());
163	assert_eq!(&*chain.readable[1], str_1.as_bytes());
164	assert_eq!(chain.writable.len(), 0);
165
166	q.set_used(used_index, chain.id, 0);
167	used_index = q.index_add(used_index, chain.delta);
168
169	assert_eq!(avail_index, WrappedIndex(WRAP_COUNTER \| 2));
170	assert_matches!(q.get_avail(avail_index, &ram), Ok(None));
171	let used = guest_q.get_used().unwrap();
172	assert_eq!(used.id, id);
173	assert_eq!(used.delta, 2);
174	assert_eq!(used.len, 0);
175
176	let id = guest_q.add_desc(&[], &[(addr_2, str_2.len() as u32)]);
177	let mut chain = q.get_avail(avail_index, &ram).unwrap().unwrap();
178	assert_eq!(chain.id, 2);
179	assert_eq!(chain.readable.len(), 0);
180	let buffer = chain.writable[0].as_mut();
181	buffer.copy_from_slice(str_2.as_bytes());
182	q.set_used(used_index, chain.id, str_2.len() as u32);
183
184	let used = guest_q.get_used().unwrap();
185	assert_eq!(used.id, id);
186	assert_eq!(used.delta, 1);
187	assert_eq!(used.len, str_2.len() as u32);
188
189	let mut b = vec![0u8; str_2.len()];
190	ram.read(addr_2, b.as_mut()).unwrap();
191	assert_eq!(&b, str_2.as_bytes());
192	}
193
194	#[rstest]
195	fn enable_notification(fixture_ram_bus: RamBus, fixture_queue: QueueReg) {
196	let ram = fixture_ram_bus.lock_layout();
197	let q = PackedQueue::new(&fixture_queue, &*ram, false)
198	.unwrap()
199	.unwrap();
200
201	q.enable_notification(false);
202	assert_eq!(unsafe { &*q.notification }.flag, EventFlag::DISABLE);
203	q.enable_notification(true);
204	assert_eq!(unsafe { &*q.notification }.flag, EventFlag::ENABLE);
205	}
206
207	#[rstest]
208	#[case(false, EventFlag::DISABLE, 0, 1, 1, false)]
209	#[case(false, EventFlag::ENABLE, 0, 1, 1, true)]
210	#[case(false, EventFlag::DESC, 0, 1, 1, false)]
211	#[case(true, EventFlag::ENABLE, 0, 1, 1, true)]
212	#[case(true, EventFlag::DISABLE, 0, 1, 1, false)]
213	#[case(true, EventFlag::DESC, 0, 2, 1, false)]
214	#[case(true, EventFlag::DESC, 0, 2, 2, true)]
215	#[case(true, EventFlag::DESC, 0, 2, 3, true)]
216	#[case(true, EventFlag::DESC, WRAP_COUNTER \| 0, 2, 3, false)]
217	#[case(true, EventFlag::DESC, WRAP_COUNTER \| (QUEUE_SIZE - 1), 2, 2, false)]
218	#[case(true, EventFlag::DESC, WRAP_COUNTER \| (QUEUE_SIZE - 1), 2, 3, true)]
219	#[case(true, EventFlag::DESC, QUEUE_SIZE - 1, WRAP_COUNTER \| 1, 1, false)]
220	#[case(true, EventFlag::DESC, QUEUE_SIZE - 1, WRAP_COUNTER \| 1, 2, true)]
221	fn is_interrupt_enabled(
222	fixture_ram_bus: RamBus,
223	fixture_queue: QueueReg,
224	#[case] enable_event_idx: bool,
225	#[case] event_flag: EventFlag,
226	#[case] event_index: u16,
227	#[case] used_index: u16,
228	#[case] delta: u16,
229	#[case] expected: bool,
230	) {
231	let ram = fixture_ram_bus.lock_layout();
232	let q = PackedQueue::new(&fixture_queue, &*ram, enable_event_idx)
233	.unwrap()
234	.unwrap();
235
236	unsafe { &mut q.interrupt } = DescEvent {
237	index: WrappedIndex(event_index),
238	flag: event_flag,
239	};
240
241	assert_eq!(
242	q.interrupt_enabled(WrappedIndex(used_index), delta),
243	expected
244	);
245	}

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