pxcloud/vhost-device
5
0
Fork 0
mirror of https://github.com/rust-vmm/vhost-device.git synced 2025-12-26 22:48:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

sound: upgrade to 2021 edition

Browse Source 
Bump to 2021 edition, and fix new warning lints while at it to keep CI
green.

Signed-off-by: Manos Pitsidianakis <manos.pitsidianakis@linaro.org>
This commit is contained in:
Manos Pitsidianakis 2025-07-08 10:54:35 +03:00 committed by Stefano Garzarella
parent 82f5657b5b
commit e1cf2aa0e7
12 changed files with 65 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vhost-device-sound/CHANGELOG.md
View File

@ -8,6 +8,8 @@
### Changed
- [[#852]](https://github.com/rust-vmm/vhost-device/pull/852) Changed to 2021 Rust edition
### Fixed
- [[#808]](https://github.com/rust-vmm/vhost-device/pull/808) pipewire: Fix rand module imports

2
vhost-device-sound/Cargo.toml
View File

@ -8,7 +8,7 @@ readme = "README.md"
keywords = ["vhost", "sound", "virtio-sound", "virtio-snd", "virtio"]
categories = ["multimedia::audio", "virtualization"]
license = "Apache-2.0 OR BSD-3-Clause"
edition = "2018"
edition = "2021"
[features]
xen = ["vm-memory/xen", "vhost/xen", "vhost-user-backend/xen"]

2
vhost-device-sound/rustfmt.toml
View File

@ -1,4 +1,4 @@
edition = "2018"
edition = "2021"
format_generated_files = false
format_code_in_doc_comments = true
format_strings = true

2
vhost-device-sound/src/audio_backends.rs
View File

@ -50,7 +50,7 @@ pub fn alloc_audio_backend(
backend: BackendType,
streams: Arc<RwLock<Vec<Stream>>>,
) -> Result<Box<dyn AudioBackend + Send + Sync>> {
log::trace!("allocating audio backend {:?}", backend);
log::trace!("allocating audio backend {backend:?}");
match backend {
BackendType::Null => Ok(Box::new(NullBackend::new(streams))),
#[cfg(all(feature = "pw-backend", target_env = "gnu"))]

61
vhost-device-sound/src/audio_backends/alsa.rs
View File

@ -207,10 +207,7 @@ fn write_samples_direct(
let mut buf = vec![0; n_bytes];
let read_bytes = match request.read_output(&mut buf) {
Err(err) => {
log::error!(
"Could not read TX request from guest, dropping it immediately: {}",
err
);
log::error!("Could not read TX request from guest, dropping it immediately: {err}");
stream.requests.pop_front();
continue;
}
@ -230,7 +227,7 @@ fn write_samples_direct(
match mmap.status().state() {
State::Suspended | State::Running | State::Prepared => Ok(false),
State::XRun => Ok(true), // Recover from this in next round
n => panic!("Unexpected pcm state {:?}", n),
n => panic!("Unexpected pcm state {n:?}"),
}
}
@ -276,7 +273,7 @@ fn read_samples_direct(
match mmap.status().state() {
State::Suspended | State::Running | State::Prepared => Ok(false),
State::XRun => Ok(true), // Recover from this in next round
n => panic!("Unexpected pcm state {:?}", n),
n => panic!("Unexpected pcm state {n:?}"),
}
}
@ -291,14 +288,10 @@ fn write_samples_io(
let avail = match p.avail_update() {
Ok(n) => n,
Err(err) => {
log::trace!("Recovering from {}", err);
log::trace!("Recovering from {err}");
p.recover(err.errno() as std::os::raw::c_int, true)?;
if let Err(err) = p.start() {
log::error!(
"Could not restart stream {}; ALSA returned: {}",
stream_id,
err
);
log::error!("Could not restart stream {stream_id}; ALSA returned: {err}");
return Err(err);
}
p.avail_update()?
@ -320,10 +313,7 @@ fn write_samples_io(
let read_bytes = match request.read_output(&mut buf[0..n_bytes]) {
Ok(v) => v,
Err(err) => {
log::error!(
"Could not read TX request, dropping it immediately: {}",
err
);
log::error!("Could not read TX request, dropping it immediately: {err}");
stream.requests.pop_front();
return 0;
}
@ -344,7 +334,7 @@ fn write_samples_io(
match p.state() {
State::Suspended | State::Running | State::Prepared => Ok(false),
State::XRun => Ok(true), // Recover from this in next round
n => panic!("Unexpected pcm state {:?}", n),
n => panic!("Unexpected pcm state {n:?}"),
}
}
@ -359,14 +349,10 @@ fn read_samples_io(
let avail = match p.avail_update() {
Ok(n) => n,
Err(err) => {
log::trace!("Recovering from {}", err);
log::trace!("Recovering from {err}");
p.recover(err.errno() as std::os::raw::c_int, true)?;
if let Err(err) = p.start() {
log::error!(
"Could not restart stream {}; ALSA returned: {}",
stream_id,
err
);
log::error!("Could not restart stream {stream_id}; ALSA returned: {err}");
return Err(err);
}
p.avail_update()?
@ -415,7 +401,7 @@ fn read_samples_io(
match p.state() {
State::Suspended | State::Running | State::Prepared => Ok(false),
State::XRun => Ok(true), // Recover from this in next round
n => panic!("Unexpected pcm state {:?}", n),
n => panic!("Unexpected pcm state {n:?}"),
}
}
@ -513,10 +499,7 @@ impl AlsaBackend {
// create worker
thread::spawn(move || {
while let Err(err) = alsa_worker(mtx.clone(), streams.clone(), &receiver, i) {
log::error!(
"Worker thread exited with error: {}, sleeping for 500ms",
err
);
log::error!("Worker thread exited with error: {err}, sleeping for 500ms");
sleep(Duration::from_millis(500));
}
});
@ -604,11 +587,7 @@ impl AudioBackend for AlsaBackend {
if !matches!(lck.state(), State::Running) {
// Fail gracefully if Start does not succeed.
if let Err(err) = lck.start() {
log::error!(
"Could not start stream {}; ALSA returned: {}",
stream_id,
err
);
log::error!("Could not start stream {stream_id}; ALSA returned: {err}");
return Err(Error::UnexpectedAudioBackendError(err.into()));
}
}
@ -629,7 +608,7 @@ impl AudioBackend for AlsaBackend {
.state
.prepare()
{
log::error!("Stream {}: {}", stream_id, err);
log::error!("Stream {stream_id}: {err}");
return Err(Error::Stream(err));
}
let pcm = &self.pcms[stream_id as usize];
@ -637,11 +616,7 @@ impl AudioBackend for AlsaBackend {
if !matches!(lck.state(), State::Running) {
// Fail gracefully if Prepare does not succeed.
if let Err(err) = lck.prepare() {
log::error!(
"Could not prepare stream {}; ALSA returned: {}",
stream_id,
err
);
log::error!("Could not prepare stream {stream_id}; ALSA returned: {err}");
return Err(Error::UnexpectedAudioBackendError(err.into()));
}
}
@ -658,7 +633,7 @@ impl AudioBackend for AlsaBackend {
.state
.stop()
{
log::error!("Stream {} stop {}", id, err);
log::error!("Stream {id} stop {err}");
}
Ok(())
}
@ -676,7 +651,7 @@ impl AudioBackend for AlsaBackend {
let mut streams = self.streams.write().unwrap();
let st = &mut streams[stream_id as usize];
if let Err(err) = st.state.set_parameters() {
log::error!("Stream {} set_parameters {}", stream_id, err);
log::error!("Stream {stream_id} set_parameters {err}");
return Err(Error::Stream(err));
} else if !st.supports_format(request.format) || !st.supports_rate(request.rate) {
return Err(Error::UnexpectedAudioBackendConfiguration);
@ -709,7 +684,7 @@ impl AudioBackend for AlsaBackend {
}
let mut streams = self.streams.write().unwrap();
if let Err(err) = streams[stream_id as usize].state.release() {
log::error!("Stream {}: {}", stream_id, err);
log::error!("Stream {stream_id}: {err}");
return Err(Error::Stream(err));
}
// Stop worker thread
@ -802,7 +777,7 @@ mod tests {
#[allow(clippy::redundant_clone)]
let _ = backend.clone();
_ = format!("{:?}", backend);
_ = format!("{backend:?}");
}
}

4
vhost-device-sound/src/audio_backends/null.rs
View File

@ -17,13 +17,13 @@ impl NullBackend {
impl AudioBackend for NullBackend {
fn write(&self, stream_id: u32) -> Result<()> {
log::trace!("NullBackend write stream_id {}", stream_id);
log::trace!("NullBackend write stream_id {stream_id}");
_ = std::mem::take(&mut self.streams.write().unwrap()[stream_id as usize].requests);
Ok(())
}
fn read(&self, _id: u32) -> Result<()> {
log::trace!("NullBackend read stream_id {}", _id);
log::trace!("NullBackend read stream_id {_id}");
Ok(())
}

16
vhost-device-sound/src/audio_backends/pipewire.rs
View File

@ -163,7 +163,7 @@ impl AudioBackend for PwBackend {
}
fn read(&self, stream_id: u32) -> Result<()> {
log::trace!("PipewireBackend read stream_id {}", stream_id);
log::trace!("PipewireBackend read stream_id {stream_id}");
if !matches!(
self.stream_params.read().unwrap()[stream_id as usize].state,
PCMState::Start | PCMState::Prepare
@ -181,7 +181,7 @@ impl AudioBackend for PwBackend {
let mut stream_params = stream_clone.write().unwrap();
if let Some(st) = stream_params.get_mut(stream_id as usize) {
if let Err(err) = st.state.set_parameters() {
log::error!("Stream {} set_parameters {}", stream_id, err);
log::error!("Stream {stream_id} set_parameters {err}");
return Err(Error::Stream(err));
} else if !st.supports_format(request.format) || !st.supports_rate(request.rate) {
return Err(Error::UnexpectedAudioBackendConfiguration);
@ -211,7 +211,7 @@ impl AudioBackend for PwBackend {
.state
.prepare();
if let Err(err) = prepare_result {
log::error!("Stream {} prepare {}", stream_id, err);
log::error!("Stream {stream_id} prepare {err}");
return Err(Error::Stream(err));
} else {
let mut stream_hash = self.stream_hash.write().unwrap();
@ -224,7 +224,7 @@ impl AudioBackend for PwBackend {
if let Some(stream) = stream_hash.remove(&stream_id) {
stream_listener.remove(&stream_id);
if let Err(err) = stream.disconnect() {
log::error!("Stream {} disconnect {}", stream_id, err);
log::error!("Stream {stream_id} disconnect {err}");
return Err(Error::Stream(StreamError::CouldNotDisconnectStream));
}
}
@ -364,7 +364,7 @@ impl AudioBackend for PwBackend {
let listener_stream = stream
.add_local_listener()
.state_changed(|_, _, old, new| {
debug!("State changed: {:?} -> {:?}", old, new);
debug!("State changed: {old:?} -> {new:?}");
})
.param_changed(move |stream, _data, id, param| {
let Some(_param) = param else {
@ -516,7 +516,7 @@ impl AudioBackend for PwBackend {
.state
.release();
if let Err(err) = release_result {
log::error!("Stream {} release {}", stream_id, err);
log::error!("Stream {stream_id} release {err}");
return Err(Error::Stream(err));
}
let lock_guard = self.thread_loop.lock();
@ -546,7 +546,7 @@ impl AudioBackend for PwBackend {
.start();
if let Err(err) = start_result {
// log the error and continue
log::error!("Stream {} start {}", stream_id, err);
log::error!("Stream {stream_id} start {err}");
return Err(Error::Stream(err));
}
let lock_guard = self.thread_loop.lock();
@ -570,7 +570,7 @@ impl AudioBackend for PwBackend {
.state
.stop();
if let Err(err) = stop_result {
log::error!("Stream {} stop {}", stream_id, err);
log::error!("Stream {stream_id} stop {err}");
return Err(Error::Stream(err));
}
let lock_guard = self.thread_loop.lock();

2
vhost-device-sound/src/audio_backends/pipewire/test_utils.rs
View File

@ -207,7 +207,7 @@ pub fn try_backoff<T, E: std::fmt::Display>(
let distribution = match Uniform::new(0.0_f32, 1.0_f32) {
Ok(d) => d,
Err(e) => {
eprintln!("Failed to create uniform distribution: {}", e);
eprintln!("Failed to create uniform distribution: {e}");
return Err(());
}
};

9
vhost-device-sound/src/device.rs
View File

@ -75,7 +75,7 @@ impl VhostUserSoundThread {
queues_per_thread
}
fn set_event_idx(&mut self, enabled: bool) {
const fn set_event_idx(&mut self, enabled: bool) {
self.event_idx = enabled;
}
@ -282,7 +282,7 @@ impl VhostUserSoundThread {
resp.code = VIRTIO_SND_S_NOT_SUPP.into()
}
_ => {
log::error!("{}", err);
log::error!("{err}");
resp.code = VIRTIO_SND_S_IO_ERR.into()
}
}
@ -316,7 +316,7 @@ impl VhostUserSoundThread {
resp.code = VIRTIO_SND_S_BAD_MSG.into()
}
_ => {
log::error!("{}", err);
log::error!("{err}");
resp.code = VIRTIO_SND_S_IO_ERR.into()
}
}
@ -369,7 +369,7 @@ impl VhostUserSoundThread {
let used_len = match u32::try_from(used_len) {
Ok(len) => len,
Err(len) => {
log::warn!("used_len {} overflows u32", len);
log::warn!("used_len {len} overflows u32");
u32::MAX
}
};
@ -676,6 +676,7 @@ impl VhostUserBackend for VhostUserSoundBackend {
#[cfg(test)]
mod tests {
use std::path::PathBuf;
use tempfile::tempdir;
use virtio_bindings::virtio_ring::VRING_DESC_F_WRITE;
use virtio_queue::{

24
vhost-device-sound/src/lib.rs
View File

@ -43,13 +43,7 @@ pub mod device;
pub mod stream;
pub mod virtio_sound;
use std::{
convert::TryFrom,
io::{Error as IoError, ErrorKind},
mem::size_of,
path::PathBuf,
sync::Arc,
};
use std::{convert::TryFrom, io::Error as IoError, mem::size_of, path::PathBuf, sync::Arc};
pub use args::BackendType;
pub use stream::Stream;
@ -182,7 +176,7 @@ pub enum Error {
impl From<Error> for IoError {
fn from(e: Error) -> Self {
Self::new(ErrorKind::Other, e)
Self::other(e)
}
}
@ -302,14 +296,14 @@ impl Drop for IOMessage {
.into(),
};
let used_len: u32 = self.used_len.load(std::sync::atomic::Ordering::SeqCst);
log::trace!("dropping IOMessage {:?}", resp);
log::trace!("dropping IOMessage {resp:?}");
let mem = self.desc_chain.memory();
let mut writer = match self.desc_chain.clone().writer(mem) {
Ok(writer) => writer,
Err(err) => {
log::error!("Error::DescriptorReadFailed: {}", err);
log::error!("Error::DescriptorReadFailed: {err}");
return;
}
};
@ -319,23 +313,23 @@ impl Drop for IOMessage {
let mut writer_status = match writer.split_at(offset) {
Ok(writer_status) => writer_status,
Err(err) => {
log::error!("Error::DescriptorReadFailed: {}", err);
log::error!("Error::DescriptorReadFailed: {err}");
return;
}
};
if let Err(err) = writer_status.write_obj(resp) {
log::error!("Error::DescriptorWriteFailed: {}", err);
log::error!("Error::DescriptorWriteFailed: {err}");
return;
}
if let Err(err) = self.vring.add_used(
self.desc_chain.head_index(),
resp.as_slice().len() as u32 + used_len,
) {
log::error!("Couldn't add used bytes count to vring: {}", err);
log::error!("Couldn't add used bytes count to vring: {err}");
}
if let Err(err) = self.vring.signal_used_queue() {
log::error!("Couldn't signal used queue: {}", err);
log::error!("Couldn't signal used queue: {err}");
}
}
}
@ -459,7 +453,7 @@ mod tests {
fn test_display() {
crate::init_logger();
let error = InvalidControlMessage(42);
let formatted_error = format!("{}", error);
let formatted_error = format!("{error}");
assert_eq!(formatted_error, "Invalid control message code 42");
}

6
vhost-device-sound/src/stream.rs
View File

@ -120,7 +120,7 @@ pub enum PCMState {
macro_rules! set_new_state {
($new_state_fn:ident, $new_state:expr, $($valid_source_states:tt)*) => {
pub fn $new_state_fn(&mut self) -> Result<()> {
pub const fn $new_state_fn(&mut self) -> Result<()> {
if !matches!(self, $($valid_source_states)*) {
return Err(Error::InvalidStateTransition(*self, $new_state));
}
@ -343,7 +343,7 @@ impl Drop for Request {
let payload_len = match u32::try_from(self.len()) {
Ok(len) => len,
Err(len) => {
log::warn!("used_len {} overflows u32", len);
log::warn!("used_len {len} overflows u32");
u32::MAX
}
};
@ -645,7 +645,7 @@ mod tests {
let mut debug_output = String::new();
// Format the Debug representation into the String.
write!(&mut debug_output, "{:?}", request).unwrap();
write!(&mut debug_output, "{request:?}").unwrap();
let expected_debug = format!(
"Request {{ pos: {}, len: {}, direction: {:?}, message: {:?} }}",

28
vhost-device-sound/src/virtio_sound.rs
View File

@ -351,7 +351,7 @@ mod tests {
fn test_virtiosound_structs_debug() {
let val = VirtioSoundConfig::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = "VirtioSoundConfig { jacks: Le32(0), streams: Le32(0), chmaps: \
Le32(0), controls: Le32(0) }"
.to_string();
@ -359,39 +359,39 @@ mod tests {
let val = VirtioSoundHeader::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = "VirtioSoundHeader { code: Le32(0) }".to_string();
assert_eq!(debug_output, expected_debug);
let val = VirtioSoundEvent::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = format!("VirtioSoundEvent {{ hdr: {:?}, data: Le32(0) }}", val.hdr);
assert_eq!(debug_output, expected_debug);
let val = VirtioSoundQueryInfo::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug =
"VirtioSoundQueryInfo { start_id: Le32(0), count: Le32(0), size: Le32(0) }".to_string();
assert_eq!(debug_output, expected_debug);
let val = VirtioSoundInfo::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = "VirtioSoundInfo { hda_fn_nid: Le32(0) }".to_string();
assert_eq!(debug_output, expected_debug);
let val = VirtioSoundJackHeader::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = "VirtioSoundJackHeader { jack_id: Le32(0) }".to_string();
assert_eq!(debug_output, expected_debug);
let val = VirtioSoundJackInfo::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = format!(
"VirtioSoundJackInfo {{ hdr: {:?}, feature: Le32(0), hda_reg_defconf: Le32(0), \
hda_reg_caps: Le32(0), connected: 0, padding: {:?} }}",
@ -401,7 +401,7 @@ mod tests {
let val = VirtioSoundJackRemap::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = format!(
"VirtioSoundJackRemap {{ hdr: {:?}, association: Le32(0), sequence: Le32(0) }}",
val.hdr
@ -410,13 +410,13 @@ mod tests {
let val = VirtioSoundPcmHeader::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = "VirtioSoundPcmHeader { stream_id: Le32(0) }".to_string();
assert_eq!(debug_output, expected_debug);
let val = VirtioSoundPcmInfo::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = format!(
"VirtioSoundPcmInfo {{ hdr: {:?}, features: Le32(0), formats: Le64(0), rates: \
Le64(0), direction: 0, channels_min: 0, channels_max: 0, padding: {:?} }}",
@ -426,7 +426,7 @@ mod tests {
let val = VirtioSndPcmSetParams::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = format!(
"VirtioSndPcmSetParams {{ hdr: {:?}, buffer_bytes: Le32(0), period_bytes: Le32(0), \
features: Le32(0), channels: 0, format: 0, rate: 0, padding: 0 }}",
@ -436,20 +436,20 @@ mod tests {
let val = VirtioSoundPcmXfer::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = "VirtioSoundPcmXfer { stream_id: Le32(0) }".to_string();
assert_eq!(debug_output, expected_debug);
let val = VirtioSoundPcmStatus::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug =
"VirtioSoundPcmStatus { status: Le32(0), latency_bytes: Le32(0) }".to_string();
assert_eq!(debug_output, expected_debug);
let val = VirtioSoundChmapInfo::default();
let debug_output = format!("{:?}", val);
let debug_output = format!("{val:?}");
let expected_debug = format!(
"VirtioSoundChmapInfo {{ hdr: {:?}, direction: 0, channels: 0, positions: {:?} }}",
val.hdr, val.positions