mirrors/crosvm
1
0
Fork 0
mirror of https://chromium.googlesource.com/crosvm/crosvm synced 2025-02-09 20:04:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

base: rename platform specific event types to PlatformEvent

Browse source 
This isn't necessary, but it does aid readbility in my opinion.

BUG=b:231344063
TEST=cargo build && ./tools/dev_container ./tools/run_tests --target=host --build-target=mingw64 --build-only

Change-Id: Id486d66773a15f1a544f717aab508d5006be3553
Reviewed-on: https://chromium-review.googlesource.com/c/crosvm/crosvm/+/3864026
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>
Reviewed-by: Alexandre Courbot <acourbot@chromium.org>
Commit-Queue: Frederick Mayle <fmayle@google.com>
This commit is contained in:
Frederick Mayle 2022-08-29 22:11:46 +00:00 committed by crosvm LUCI
parent 50181346e6
commit d5f37f2982
11 changed files with 103 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
base/src/event.rs
View file

@ -11,7 +11,7 @@ use crate::descriptor::AsRawDescriptor;
use crate::descriptor::FromRawDescriptor;
use crate::descriptor::IntoRawDescriptor;
use crate::descriptor::SafeDescriptor;
use crate::platform::Event as PlatformEvent;
use crate::platform::PlatformEvent;
use crate::RawDescriptor;
use crate::Result;

38
base/src/sys/unix/eventfd.rs → base/src/sys/unix/event.rs
View file

@ -32,13 +32,13 @@ use crate::EventReadResult;
/// and out of the KVM API. They can also be polled like any other file descriptor.
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub(crate) struct EventFd {
pub(crate) struct PlatformEvent {
event_handle: SafeDescriptor,
}
impl EventFd {
/// Creates a new blocking EventFd with an initial value of 0.
pub fn new() -> Result<EventFd> {
impl PlatformEvent {
/// Creates a new blocking eventfd with an initial value of 0.
pub fn new() -> Result<PlatformEvent> {
// This is safe because eventfd merely allocated an eventfd for our process and we handle
// the error case.
let ret = unsafe { eventfd(0, 0) };
@ -47,7 +47,7 @@ impl EventFd {
}
// This is safe because we checked ret for success and know the kernel gave us an fd that we
// own.
Ok(EventFd {
Ok(PlatformEvent {
event_handle: unsafe { SafeDescriptor::from_raw_descriptor(ret) },
})
}
@ -132,43 +132,43 @@ impl EventFd {
Ok(EventReadResult::Count(buf))
}
/// Clones this EventFd, internally creating a new file descriptor. The new EventFd will share
/// Clones this eventfd, internally creating a new file descriptor. The new eventfd will share
/// the same underlying count within the kernel.
pub fn try_clone(&self) -> Result<EventFd> {
pub fn try_clone(&self) -> Result<PlatformEvent> {
self.event_handle
.try_clone()
.map(|event_handle| EventFd { event_handle })
.map(|event_handle| PlatformEvent { event_handle })
}
}
impl AsRawFd for EventFd {
impl AsRawFd for PlatformEvent {
fn as_raw_fd(&self) -> RawFd {
self.event_handle.as_raw_fd()
}
}
impl AsRawDescriptor for EventFd {
impl AsRawDescriptor for PlatformEvent {
fn as_raw_descriptor(&self) -> RawDescriptor {
self.event_handle.as_raw_descriptor()
}
}
impl FromRawDescriptor for EventFd {
impl FromRawDescriptor for PlatformEvent {
unsafe fn from_raw_descriptor(descriptor: RawDescriptor) -> Self {
EventFd {
PlatformEvent {
event_handle: SafeDescriptor::from_raw_descriptor(descriptor),
}
}
}
impl IntoRawDescriptor for EventFd {
impl IntoRawDescriptor for PlatformEvent {
fn into_raw_descriptor(self) -> RawDescriptor {
self.event_handle.into_raw_descriptor()
}
}
impl From<EventFd> for SafeDescriptor {
fn from(evt: EventFd) -> Self {
impl From<PlatformEvent> for SafeDescriptor {
fn from(evt: PlatformEvent) -> Self {
evt.event_handle
}
}
@ -179,19 +179,19 @@ mod tests {
#[test]
fn new() {
EventFd::new().unwrap();
PlatformEvent::new().unwrap();
}
#[test]
fn read_write() {
let evt = EventFd::new().unwrap();
let evt = PlatformEvent::new().unwrap();
evt.write(55).unwrap();
assert_eq!(evt.read(), Ok(55));
}
#[test]
fn clone() {
let evt = EventFd::new().unwrap();
let evt = PlatformEvent::new().unwrap();
let evt_clone = evt.try_clone().unwrap();
evt.write(923).unwrap();
assert_eq!(evt_clone.read(), Ok(923));
@ -199,7 +199,7 @@ mod tests {
#[test]
fn timeout() {
let evt = EventFd::new().expect("failed to create eventfd");
let evt = PlatformEvent::new().expect("failed to create eventfd");
assert_eq!(
evt.read_timeout(Duration::from_millis(1))
.expect("failed to read from eventfd with timeout"),

4
base/src/sys/unix/file_flags.rs
View file

@ -44,7 +44,7 @@ impl FileFlags {
#[cfg(test)]
mod tests {
use super::super::pipe;
use super::super::Event;
use super::super::PlatformEvent;
use super::*;
#[test]
@ -56,7 +56,7 @@ mod tests {
#[test]
fn event() {
let evt = Event::new().unwrap();
let evt = PlatformEvent::new().unwrap();
assert_eq!(FileFlags::from_file(&evt).unwrap(), FileFlags::ReadWrite);
}
}

4
base/src/sys/unix/mod.rs
View file

@ -22,7 +22,7 @@ pub mod syslog;
mod acpi_event;
mod capabilities;
mod descriptor;
mod eventfd;
mod event;
mod file_flags;
pub mod file_traits;
mod get_filesystem_type;
@ -66,7 +66,7 @@ use std::time::Duration;
pub use acpi_event::*;
pub use capabilities::drop_capabilities;
pub use descriptor::*;
pub(crate) use eventfd::EventFd as Event;
pub(crate) use event::PlatformEvent;
pub use file_flags::*;
pub use file_traits::AsRawFds;
pub use file_traits::FileAllocate;

8
base/src/sys/unix/poll.rs
View file

@ -271,13 +271,13 @@ mod tests {
use base_event_token_derive::EventToken;
use super::super::Event;
use super::super::PlatformEvent;
use super::*;
#[test]
fn event_context() {
let evt1 = Event::new().unwrap();
let evt2 = Event::new().unwrap();
let evt1 = PlatformEvent::new().unwrap();
let evt2 = PlatformEvent::new().unwrap();
evt1.write(1).unwrap();
evt2.write(1).unwrap();
let ctx: EventContext<u32> = EventContext::build_with(&[(&evt1, 1), (&evt2, 2)]).unwrap();
@ -308,7 +308,7 @@ mod tests {
let ctx: EventContext<usize> = EventContext::new().unwrap();
let mut evts = Vec::with_capacity(EVT_COUNT);
for i in 0..EVT_COUNT {
let evt = Event::new().unwrap();
let evt = PlatformEvent::new().unwrap();
evt.write(1).unwrap();
ctx.add(&evt, i).unwrap();
evts.push(evt);

6
base/src/sys/unix/sock_ctrl_msg.rs
View file

@ -439,7 +439,7 @@ mod tests {
use libc::cmsghdr;
use super::super::Event;
use super::super::PlatformEvent;
use super::*;
// Doing this as a macro makes it easier to see the line if it fails
@ -502,7 +502,7 @@ mod tests {
fn send_recv_only_fd() {
let (s1, s2) = UnixDatagram::pair().expect("failed to create socket pair");
let evt = Event::new().expect("failed to create event");
let evt = PlatformEvent::new().expect("failed to create event");
let ioslice = IoSlice::new([].as_ref());
let write_count = s1
.send_with_fd(&[ioslice], evt.as_raw_fd())
@ -533,7 +533,7 @@ mod tests {
fn send_recv_with_fd() {
let (s1, s2) = UnixDatagram::pair().expect("failed to create socket pair");
let evt = Event::new().expect("failed to create event");
let evt = PlatformEvent::new().expect("failed to create event");
let ioslice = IoSlice::new([237].as_ref());
let write_count = s1
.send_with_fds(&[ioslice], &[evt.as_raw_fd()])

6
base/src/sys/windows/descriptor.rs
View file

@ -167,10 +167,10 @@ AsRawDescriptor!(Stderr);
#[test]
#[allow(clippy::eq_op)]
fn clone_equality() {
use super::Event;
use super::PlatformEvent;
use crate::descriptor::IntoRawDescriptor;
let evt = Event::new().unwrap();
let evt = PlatformEvent::new().unwrap();
let descriptor = unsafe { SafeDescriptor::from_raw_descriptor(evt.into_raw_descriptor()) };
assert_eq!(descriptor, descriptor);
@ -180,7 +180,7 @@ fn clone_equality() {
descriptor.try_clone().expect("failed to clone event")
);
let evt2 = Event::new().unwrap();
let evt2 = PlatformEvent::new().unwrap();
let another = unsafe { SafeDescriptor::from_raw_descriptor(evt2.into_raw_descriptor()) };
assert_ne!(descriptor, another);

90
base/src/sys/windows/event.rs
View file

@ -37,7 +37,7 @@ use crate::descriptor::AsRawDescriptor;
use crate::descriptor::FromRawDescriptor;
use crate::descriptor::IntoRawDescriptor;
use crate::descriptor::SafeDescriptor;
use crate::Event as CrateEvent;
use crate::Event;
use crate::EventReadResult;
/// A safe wrapper around Windows synchapi methods used to mimic Linux eventfd (man 2 eventfd).
@ -45,42 +45,42 @@ use crate::EventReadResult;
/// events.
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub(crate) struct Event {
pub(crate) struct PlatformEvent {
event_handle: SafeDescriptor,
}
pub trait EventExt {
fn reset(&self) -> Result<()>;
fn new_with_manual_reset(manual_reset: bool) -> Result<CrateEvent>;
fn new_auto_reset() -> Result<CrateEvent>;
fn open(name: &str) -> Result<CrateEvent>;
fn create_event_with_name(name: &str) -> Result<CrateEvent>;
fn new_with_manual_reset(manual_reset: bool) -> Result<Event>;
fn new_auto_reset() -> Result<Event>;
fn open(name: &str) -> Result<Event>;
fn create_event_with_name(name: &str) -> Result<Event>;
}
impl EventExt for CrateEvent {
impl EventExt for Event {
fn reset(&self) -> Result<()> {
self.0.reset()
}
fn new_with_manual_reset(manual_reset: bool) -> Result<CrateEvent> {
Event::new_with_manual_reset(manual_reset).map(CrateEvent)
fn new_with_manual_reset(manual_reset: bool) -> Result<Event> {
PlatformEvent::new_with_manual_reset(manual_reset).map(Event)
}
fn new_auto_reset() -> Result<CrateEvent> {
CrateEvent::new_with_manual_reset(false)
fn new_auto_reset() -> Result<Event> {
Event::new_with_manual_reset(false)
}
fn open(name: &str) -> Result<CrateEvent> {
Event::open(name).map(CrateEvent)
fn open(name: &str) -> Result<Event> {
PlatformEvent::open(name).map(Event)
}
fn create_event_with_name(name: &str) -> Result<CrateEvent> {
Event::create_event_with_name(name).map(CrateEvent)
fn create_event_with_name(name: &str) -> Result<Event> {
PlatformEvent::create_event_with_name(name).map(Event)
}
}
impl Event {
pub fn new_with_manual_reset(manual_reset: bool) -> Result<Event> {
impl PlatformEvent {
pub fn new_with_manual_reset(manual_reset: bool) -> Result<PlatformEvent> {
let handle = unsafe {
CreateEventA(
SecurityAttributes::new_with_security_descriptor(
@ -96,12 +96,12 @@ impl Event {
if handle.is_null() {
return errno_result();
}
Ok(Event {
Ok(PlatformEvent {
event_handle: unsafe { SafeDescriptor::from_raw_descriptor(handle) },
})
}
pub fn create_event_with_name(name: &str) -> Result<Event> {
pub fn create_event_with_name(name: &str) -> Result<PlatformEvent> {
let event_str = CString::new(String::from(name)).unwrap();
let handle = unsafe {
CreateEventA(
@ -118,29 +118,29 @@ impl Event {
if handle.is_null() {
return errno_result();
}
Ok(Event {
Ok(PlatformEvent {
event_handle: unsafe { SafeDescriptor::from_raw_descriptor(handle) },
})
}
pub fn new() -> Result<Event> {
pub fn new() -> Result<PlatformEvent> {
// Require manual reset
Event::new_with_manual_reset(true)
PlatformEvent::new_with_manual_reset(true)
}
pub fn open(name: &str) -> Result<Event> {
pub fn open(name: &str) -> Result<PlatformEvent> {
let event_str = CString::new(String::from(name)).unwrap();
let handle = unsafe { OpenEventA(EVENT_MODIFY_STATE, FALSE, event_str.as_ptr()) };
if handle.is_null() {
return errno_result();
}
Ok(Event {
Ok(PlatformEvent {
event_handle: unsafe { SafeDescriptor::from_raw_descriptor(handle) },
})
}
pub fn new_auto_reset() -> Result<Event> {
Event::new_with_manual_reset(false)
pub fn new_auto_reset() -> Result<PlatformEvent> {
PlatformEvent::new_with_manual_reset(false)
}
pub fn write(&self, _v: u64) -> Result<()> {
@ -196,7 +196,7 @@ impl Event {
}
}
pub fn try_clone(&self) -> Result<Event> {
pub fn try_clone(&self) -> Result<PlatformEvent> {
let mut event_clone: HANDLE = MaybeUninit::uninit().as_mut_ptr();
let duplicate_result = unsafe {
DuplicateHandle(
@ -212,47 +212,47 @@ impl Event {
if duplicate_result == 0 {
return errno_result();
}
Ok(unsafe { Event::from_raw_descriptor(event_clone) })
Ok(unsafe { PlatformEvent::from_raw_descriptor(event_clone) })
}
}
impl AsRawDescriptor for Event {
impl AsRawDescriptor for PlatformEvent {
fn as_raw_descriptor(&self) -> RawDescriptor {
self.event_handle.as_raw_descriptor()
}
}
impl FromRawDescriptor for Event {
impl FromRawDescriptor for PlatformEvent {
unsafe fn from_raw_descriptor(descriptor: RawDescriptor) -> Self {
Event {
PlatformEvent {
event_handle: SafeDescriptor::from_raw_descriptor(descriptor),
}
}
}
impl AsRawHandle for Event {
impl AsRawHandle for PlatformEvent {
fn as_raw_handle(&self) -> RawHandle {
self.as_raw_descriptor()
}
}
impl IntoRawDescriptor for Event {
impl IntoRawDescriptor for PlatformEvent {
fn into_raw_descriptor(self) -> RawDescriptor {
self.event_handle.into_raw_descriptor()
}
}
impl From<Event> for SafeDescriptor {
fn from(evt: Event) -> Self {
impl From<PlatformEvent> for SafeDescriptor {
fn from(evt: PlatformEvent) -> Self {
evt.event_handle
}
}
// Event is safe for send & Sync despite containing a raw handle to its
// file mapping object. As long as the instance to Event stays alive, this
// PlatformEvent is safe for send & Sync despite containing a raw handle to its
// file mapping object. As long as the instance to PlatformEvent stays alive, this
// pointer will be a valid handle.
unsafe impl Send for Event {}
unsafe impl Sync for Event {}
unsafe impl Send for PlatformEvent {}
unsafe impl Sync for PlatformEvent {}
#[cfg(test)]
mod tests {
@ -264,19 +264,19 @@ mod tests {
#[test]
fn new() {
Event::new().unwrap();
PlatformEvent::new().unwrap();
}
#[test]
fn read_write() {
let evt = Event::new().unwrap();
let evt = PlatformEvent::new().unwrap();
evt.write(55).unwrap();
assert_eq!(evt.read(), Ok(1));
}
#[test]
fn read_write_auto_reset() {
let evt = Event::new_auto_reset().unwrap();
let evt = PlatformEvent::new_auto_reset().unwrap();
evt.write(55).unwrap();
// Wait for the notification.
@ -290,7 +290,7 @@ mod tests {
#[test]
fn read_write_notifies_until_read() {
let evt = Event::new().unwrap();
let evt = PlatformEvent::new().unwrap();
evt.write(55).unwrap();
// Wait for the notification.
@ -309,7 +309,7 @@ mod tests {
#[test]
fn clone() {
let evt = Event::new().unwrap();
let evt = PlatformEvent::new().unwrap();
let evt_clone = evt.try_clone().unwrap();
evt.write(923).unwrap();
assert_eq!(evt_clone.read(), Ok(1));
@ -317,7 +317,7 @@ mod tests {
#[test]
fn timeout() {
let evt = Event::new().expect("failed to create event");
let evt = PlatformEvent::new().expect("failed to create event");
assert_eq!(
evt.read_timeout(Duration::from_millis(1))
.expect("failed to read from event with timeout"),

30
base/src/sys/windows/events.rs
View file

@ -37,13 +37,13 @@ impl<T: EventToken> Clone for EventTrigger<T> {
mod tests {
use std::time::Duration;
use super::super::Event;
use super::super::PlatformEvent;
use super::*;
#[test]
fn event_context() {
let evt1 = Event::new().unwrap();
let evt2 = Event::new().unwrap();
let evt1 = PlatformEvent::new().unwrap();
let evt2 = PlatformEvent::new().unwrap();
evt1.write(1).unwrap();
evt2.write(1).unwrap();
let ctx: EventContext<u32> =
@ -78,7 +78,7 @@ mod tests {
// let ctx: EventContext<usize> = EventContext::new().unwrap();
// let mut evts = Vec::with_capacity(EVT_COUNT);
// for i in 0..EVT_COUNT {
// let evt = Event::new().unwrap();
// let evt = PlatformEvent::new().unwrap();
// evt.write(1).unwrap();
// ctx.add(&evt, i).unwrap();
// evts.push(evt);
@ -95,7 +95,7 @@ mod tests {
#[test]
fn poll_context_timeout() {
let ctx: EventContext<u32> = EventContext::new().unwrap();
let evt = Event::new().unwrap();
let evt = PlatformEvent::new().unwrap();
ctx.add(EventTrigger::from(&evt, 1))
.expect("Failed to add event.");
let dur = Duration::from_millis(100);
@ -105,9 +105,9 @@ mod tests {
#[test]
fn wait_returns_mulitple_signal_events() {
let evt1 = Event::new().unwrap();
let evt2 = Event::new().unwrap();
let evt3 = Event::new().unwrap();
let evt1 = PlatformEvent::new().unwrap();
let evt2 = PlatformEvent::new().unwrap();
let evt3 = PlatformEvent::new().unwrap();
evt1.write(1).expect("Failed to write to event.");
evt2.write(1).expect("Failed to write to event.");
evt3.write(1).expect("Failed to write to event.");
@ -126,13 +126,13 @@ mod tests {
#[test]
fn wait_returns_mulitple_signal_and_unsignaled_events() {
let evt1 = Event::new().unwrap();
let evt2 = Event::new().unwrap();
let evt3 = Event::new().unwrap();
let evt4 = Event::new().unwrap();
let evt5 = Event::new().unwrap();
let evt6 = Event::new().unwrap();
let evt7 = Event::new().unwrap();
let evt1 = PlatformEvent::new().unwrap();
let evt2 = PlatformEvent::new().unwrap();
let evt3 = PlatformEvent::new().unwrap();
let evt4 = PlatformEvent::new().unwrap();
let evt5 = PlatformEvent::new().unwrap();
let evt6 = PlatformEvent::new().unwrap();
let evt7 = PlatformEvent::new().unwrap();
evt1.write(1).unwrap();
evt2.write(1).unwrap();
evt4.write(1).unwrap();

12
base/src/sys/windows/stream_channel_platform.rs
View file

@ -18,8 +18,8 @@ use super::named_pipes;
use super::named_pipes::PipeConnection;
use super::stream_channel::BlockingMode;
use super::stream_channel::FramingMode;
use super::Event;
use super::MultiProcessMutex;
use super::PlatformEvent;
use super::RawDescriptor;
use super::Result;
use crate::descriptor::AsRawDescriptor;
@ -59,9 +59,9 @@ pub const DEFAULT_BUFFER_SIZE: usize = 50 * 1024;
#[derive(Deserialize, Debug)]
pub struct StreamChannel {
pipe_conn: named_pipes::PipeConnection,
write_notify: Event,
read_notify: Event,
pipe_closed: Event,
write_notify: PlatformEvent,
read_notify: PlatformEvent,
pipe_closed: PlatformEvent,
// Held when reading on this end, to prevent additional writes from corrupting notification
// state.
@ -305,8 +305,8 @@ impl StreamChannel {
pipe_b: PipeConnection,
send_buffer_size: usize,
) -> Result<(StreamChannel, StreamChannel)> {
let (notify_a_write, notify_b_write) = (Event::new()?, Event::new()?);
let pipe_closed = Event::new()?;
let (notify_a_write, notify_b_write) = (PlatformEvent::new()?, PlatformEvent::new()?);
let pipe_closed = PlatformEvent::new()?;
let write_lock_a = MultiProcessMutex::new()?;
let write_lock_b = MultiProcessMutex::new()?;

6
base/src/sys/windows/wait.rs
View file

@ -19,8 +19,8 @@ use winapi::um::winbase::WAIT_OBJECT_0;
use super::errno_result;
use super::Error;
use super::Event;
use super::EventTrigger;
use super::PlatformEvent;
use super::Result;
use crate::descriptor::AsRawDescriptor;
use crate::descriptor::Descriptor;
@ -59,7 +59,7 @@ pub struct EventContext<T: EventToken> {
// mid-wait. This is to solve for instances where Thread A has started waiting and
// Thread B adds an event trigger, which needs to notify Thread A a change has been
// made.
handles_modified_event: Event,
handles_modified_event: PlatformEvent,
}
impl<T: EventToken> EventContext<T> {
@ -69,7 +69,7 @@ impl<T: EventToken> EventContext<T> {
triggers: HashMap::new(),
raw_handles: Vec::new(),
})),
handles_modified_event: Event::new().unwrap(),
handles_modified_event: PlatformEvent::new().unwrap(),
};
// The handles-modified event will be everpresent on the raw_handles to be waited
// upon to ensure the wait stops and we update it any time the handles list is