Implement Wait, Signal, and Reset opcodes for event synchronization

Author: IsaacWoods

src/aml/mod.rs

@@ -37,7 +37,12 @@ use alloc::{
     vec::Vec,
 };
 use bit_field::BitField;
-use core::{mem, slice, str::FromStr, sync::atomic::Ordering};
+use core::{
+    mem,
+    slice,
+    str::FromStr,
+    sync::atomic::{AtomicU64, Ordering},
+};
 use log::{info, trace, warn};
 use namespace::{AmlName, Namespace, NamespaceLevelKind};
 use object::{
@@ -464,6 +469,91 @@ where
                         context.contribute_arg(Argument::Object(result));
                         context.retire_op(op);
                     }
+                    Opcode::Reset => {
+                        let [Argument::Object(sync_object)] = &op.arguments[..] else {
+                            panic!();
+                        };
+                        let sync_object = sync_object.clone().unwrap_reference();
+
+                        if let Object::Event(ref counter) = *sync_object {
+                            counter.store(0, Ordering::Release);
+                        } else {
+                            return Err(AmlError::InvalidOperationOnObject {
+                                op: Operation::ResetEvent,
+                                typ: sync_object.typ(),
+                            });
+                        }
+                    }
+                    Opcode::Signal => {
+                        let [Argument::Object(sync_object)] = &op.arguments[..] else {
+                            panic!();
+                        };
+                        let sync_object = sync_object.clone().unwrap_reference();
+
+                        if let Object::Event(ref counter) = *sync_object {
+                            counter.fetch_add(1, Ordering::AcqRel);
+                        } else {
+                            return Err(AmlError::InvalidOperationOnObject {
+                                op: Operation::SignalEvent,
+                                typ: sync_object.typ(),
+                            });
+                        }
+                    }
+                    Opcode::Wait => {
+                        let [Argument::Object(sync_object), Argument::Object(timeout)] = &op.arguments[..] else {
+                            panic!();
+                        };
+                        let sync_object = sync_object.clone().unwrap_reference();
+                        let timeout = u64::min(timeout.as_integer()?, 0xffff);
+
+                        if let Object::Event(ref counter) = *sync_object {
+                            /*
+                             * `Wait` returns a non-zero value if a timeout occurs and the event
+                             * was not signaled, and zero if it was. Timeout is specified in
+                             * milliseconds, should relinquish processor control (we use
+                             * `Handler::sleep` to do so) and a value of `0xffff` specifies that
+                             * the operation should wait indefinitely.
+                             */
+                            let mut remaining_sleep = timeout;
+                            let mut timed_out = true;
+
+                            'signaled: while remaining_sleep > 0 {
+                                loop {
+                                    /*
+                                     * Try to decrement the counter. If it's zero after a load, we
+                                     * haven't been signalled and should wait for a bit. If it's
+                                     * non-zero, we were signalled and should stop waiting.
+                                     */
+                                    let value = counter.load(Ordering::Acquire);
+                                    if value == 0 {
+                                        break;
+                                    }
+                                    if counter
+                                        .compare_exchange(value, value - 1, Ordering::AcqRel, Ordering::Acquire)
+                                        .is_ok()
+                                    {
+                                        timed_out = false;
+                                        break 'signaled;
+                                    }
+                                }
+
+                                let to_sleep = u64::min(timeout, 10);
+                                if timeout < 0xffff {
+                                    remaining_sleep -= to_sleep
+                                }
+                                self.handler.sleep(to_sleep);
+                            }
+
+                            context.contribute_arg(Argument::Object(
+                                Object::Integer(if timed_out { u64::MAX } else { 0 }).wrap(),
+                            ));
+                        } else {
+                            return Err(AmlError::InvalidOperationOnObject {
+                                op: Operation::WaitEvent,
+                                typ: sync_object.typ(),
+                            });
+                        }
+                    }
                     Opcode::FromBCD => self.do_from_bcd(&mut context, op)?,
                     Opcode::ToBCD => self.do_to_bcd(&mut context, op)?,
                     Opcode::Name => {
@@ -1150,17 +1240,17 @@ where
                     let name = context.namestring()?;
 
                     let name = name.resolve(&context.current_scope)?;
-                    self.namespace.lock().insert(name, Object::Event.wrap())?;
+                    self.namespace.lock().insert(name, Object::Event(Arc::new(AtomicU64::new(0))).wrap())?;
                 }
                 Opcode::LoadTable => todo!(),
                 Opcode::Load => todo!(),
                 Opcode::Stall => context.start_in_flight_op(OpInFlight::new(Opcode::Stall, 1)),
                 Opcode::Sleep => context.start_in_flight_op(OpInFlight::new(Opcode::Sleep, 1)),
                 Opcode::Acquire => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
                 Opcode::Release => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
-                Opcode::Signal => todo!(),
-                Opcode::Wait => todo!(),
-                Opcode::Reset => todo!(),
+                Opcode::Signal => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
+                Opcode::Wait => context.start_in_flight_op(OpInFlight::new(opcode, 2)),
+                Opcode::Reset => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
                 Opcode::Notify => todo!(),
                 Opcode::FromBCD | Opcode::ToBCD => context.start_in_flight_op(OpInFlight::new(opcode, 2)),
                 Opcode::Revision => {
@@ -1944,7 +2034,7 @@ where
                 Object::Buffer(bytes) => String::from_utf8_lossy(bytes).into_owned(),
                 Object::BufferField { .. } => "[Buffer Field]".to_string(),
                 Object::Device => "[Device]".to_string(),
-                Object::Event => "[Event]".to_string(),
+                Object::Event(_) => "[Event]".to_string(),
                 Object::FieldUnit(_) => "[Field]".to_string(),
                 Object::Integer(value) => value.to_string(),
                 Object::Method { .. } | Object::NativeMethod { .. } => "[Control Method]".to_string(),
@@ -3033,6 +3123,10 @@ pub enum Operation {
     LogicalOp,
     DecodePrt,
     ParseResource,
+
+    ResetEvent,
+    SignalEvent,
+    WaitEvent,
 }
 
 #[derive(Clone, PartialEq, Debug)]

src/aml/object.rs

@@ -1,7 +1,7 @@
 use crate::aml::{AmlError, Handle, Operation, op_region::OpRegion};
 use alloc::{borrow::Cow, string::String, sync::Arc, vec::Vec};
 use bit_field::BitField;
-use core::{cell::UnsafeCell, fmt, ops};
+use core::{cell::UnsafeCell, fmt, ops, sync::atomic::AtomicU64};
 
 type NativeMethod = dyn Fn(&[WrappedObject]) -> Result<WrappedObject, AmlError>;
 
@@ -11,7 +11,7 @@ pub enum Object {
     Buffer(Vec<u8>),
     BufferField { buffer: WrappedObject, offset: usize, length: usize },
     Device,
-    Event,
+    Event(Arc<AtomicU64>),
     FieldUnit(FieldUnit),
     Integer(u64),
     Method { code: Vec<u8>, flags: MethodFlags },
@@ -48,7 +48,7 @@ impl fmt::Display for Object {
                 write!(f, "BufferField {{ offset: {offset}, length: {length} }}")
             }
             Object::Device => write!(f, "Device"),
-            Object::Event => write!(f, "Event"),
+            Object::Event(counter) => write!(f, "Event({counter:?})"),
             // TODO: include fields
             Object::FieldUnit(_) => write!(f, "FieldUnit"),
             Object::Integer(value) => write!(f, "Integer({value})"),
@@ -263,7 +263,7 @@ impl Object {
             Object::Buffer(_) => ObjectType::Buffer,
             Object::BufferField { .. } => ObjectType::BufferField,
             Object::Device => ObjectType::Device,
-            Object::Event => ObjectType::Event,
+            Object::Event(_) => ObjectType::Event,
             Object::FieldUnit(_) => ObjectType::FieldUnit,
             Object::Integer(_) => ObjectType::Integer,
             Object::Method { .. } => ObjectType::Method,