Merge #267 267: Add the `CommandReturn` type. r=hudson-ayers a=jrvanwhy The `command` system call will return a `CommandReturn`. `CommandReturn` is practically free to construct and contains methods that allow drivers to interpret the register values it contains. Co-authored-by: Johnathan Van Why <jrvanwhy@google.com>
diff --git a/core/platform/src/command_return.rs b/core/platform/src/command_return.rs new file mode 100644 index 0000000..7fa7302 --- /dev/null +++ b/core/platform/src/command_return.rs
@@ -0,0 +1,163 @@ +use crate::{return_variant, ErrorCode, ReturnVariant}; + +/// The response type from `command`. Can represent a successful value or a +/// failure. +#[derive(Clone, Copy)] +pub struct CommandReturn { + pub(crate) return_variant: ReturnVariant, + // r1, r2, and r3 should only contain 32-bit values. However, these are + // converted directly from usizes returned by RawSyscalls::four_arg_syscall. + // To avoid casting twice (both when converting to a Command Return and when + // calling a get_*() function), we store the usizes directly. Then using the + // CommandReturn only involves one conversion for each of r1, r2, and r3, + // performed in the get_*() functions. + pub(crate) r1: usize, + pub(crate) r2: usize, + pub(crate) r3: usize, +} + +impl CommandReturn { + // I generally expect CommandReturn to be used with pattern matching, e.g.: + // + // let command_return = Syscalls::command(314, 1, 1, 2); + // if let Some((val1, val2)) = command_return.get_success_2_u32() { + // // ... + // } else if let Some(error_code) = command_return.get_failure() { + // // ... + // } else { + // // Incorrect return variant + // } + + /// Returns true if this CommandReturn is of type Failure. Note that this + /// does not return true for other failure types, such as Failure with u32. + pub fn is_failure(&self) -> bool { + self.return_variant == return_variant::FAILURE + } + + /// Returns true if this CommandReturn is of type Failure with u32. + pub fn is_failure_u32(&self) -> bool { + self.return_variant == return_variant::FAILURE_U32 + } + + /// Returns true if this CommandReturn is of type Failure with 2 u32. + pub fn is_failure_2_u32(&self) -> bool { + self.return_variant == return_variant::FAILURE_2_U32 + } + + /// Returns true if this CommandReturn is of type Failure with u64. + pub fn is_failure_u64(&self) -> bool { + self.return_variant == return_variant::FAILURE_U64 + } + + /// Returns true if this CommandReturn is of type Success. Note that this + /// does not return true for other success types, such as Success with u32. + pub fn is_success(&self) -> bool { + self.return_variant == return_variant::SUCCESS + } + + /// Returns true if this CommandReturn is of type Success with u32. + pub fn is_success_u32(&self) -> bool { + self.return_variant == return_variant::SUCCESS_U32 + } + + /// Returns true if this CommandReturn is of type Success with 2 u32. + pub fn is_success_2_u32(&self) -> bool { + self.return_variant == return_variant::SUCCESS_2_U32 + } + + /// Returns true if this CommandReturn is of type Success with u64. + pub fn is_success_u64(&self) -> bool { + self.return_variant == return_variant::SUCCESS_U64 + } + + /// Returns true if this CommandReturn is of type Success with 3 u32. + pub fn is_success_3_u32(&self) -> bool { + self.return_variant == return_variant::SUCCESS_3_U32 + } + + /// Returns true if this CommandReturn is of type Success with u32 and u64. + pub fn is_success_u32_u64(&self) -> bool { + self.return_variant == return_variant::SUCCESS_U32_U64 + } + + /// Returns the error code if this CommandReturn is of type Failure. + pub fn get_failure(&self) -> Option<ErrorCode> { + if !self.is_failure() { + return None; + } + Some(self.r1.into()) + } + + /// Returns the error code and value if this CommandReturn is of type + /// Failure with u32. + pub fn get_failure_u32(&self) -> Option<(ErrorCode, u32)> { + if !self.is_failure_u32() { + return None; + } + Some((self.r1.into(), self.r2 as u32)) + } + + /// Returns the error code and return values if this CommandReturn is of + /// type Failure with 2 u32. + pub fn get_failure_2_u32(&self) -> Option<(ErrorCode, u32, u32)> { + if !self.is_failure_2_u32() { + return None; + } + Some((self.r1.into(), self.r2 as u32, self.r3 as u32)) + } + + /// Returns the error code and return value if this CommandReturn is of type + /// Failure with u64. + pub fn get_failure_u64(&self) -> Option<(ErrorCode, u64)> { + if !self.is_failure_u64() { + return None; + } + Some((self.r1.into(), self.r2 as u64 + ((self.r3 as u64) << 32))) + } + + /// Returns the value if this CommandReturn is of type Success with u32. + pub fn get_success_u32(&self) -> Option<u32> { + if !self.is_success_u32() { + return None; + } + Some(self.r1 as u32) + } + + /// Returns the values if this CommandReturn is of type Success with 2 u32. + pub fn get_success_2_u32(&self) -> Option<(u32, u32)> { + if !self.is_success_2_u32() { + return None; + } + Some((self.r1 as u32, self.r2 as u32)) + } + + /// Returns the value if this CommandReturn is of type Success with u64. + pub fn get_success_u64(&self) -> Option<u64> { + if !self.is_success_u64() { + return None; + } + Some(self.r1 as u64 + ((self.r2 as u64) << 32)) + } + + /// Returns the values if this CommandReturn is of type Success with 3 u32. + pub fn get_success_3_u32(&self) -> Option<(u32, u32, u32)> { + if !self.is_success_3_u32() { + return None; + } + Some((self.r1 as u32, self.r2 as u32, self.r3 as u32)) + } + + /// Returns the values if this CommandReturn is of type Success with u32 and + /// u64. + pub fn get_success_u32_u64(&self) -> Option<(u32, u64)> { + if !self.is_success_u32_u64() { + return None; + } + Some((self.r1 as u32, self.r2 as u64 + ((self.r3 as u64) << 32))) + } + + /// Returns the return variant of this command. + pub fn return_variant(&self) -> ReturnVariant { + self.return_variant + } +}
diff --git a/core/platform/src/command_return_tests.rs b/core/platform/src/command_return_tests.rs new file mode 100644 index 0000000..1712f71 --- /dev/null +++ b/core/platform/src/command_return_tests.rs
@@ -0,0 +1,325 @@ +use crate::{error_code, return_variant, CommandReturn}; + +#[test] +fn failure() { + let command_return = CommandReturn { + return_variant: return_variant::FAILURE, + r1: error_code::RESERVE.into(), + r2: 1002, + r3: 1003, + }; + assert_eq!(command_return.is_failure(), true); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), Some(error_code::RESERVE)); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!(command_return.return_variant(), return_variant::FAILURE); +} + +#[test] +fn failure_u32() { + let command_return = CommandReturn { + return_variant: return_variant::FAILURE_U32, + r1: error_code::OFF.into(), + r2: 1002, + r3: 1003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), true); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), None); + assert_eq!( + command_return.get_failure_u32(), + Some((error_code::OFF, 1002)) + ); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!(command_return.return_variant(), return_variant::FAILURE_U32); +} + +#[test] +fn failure_2_u32() { + let command_return = CommandReturn { + return_variant: return_variant::FAILURE_2_U32, + r1: error_code::ALREADY.into(), + r2: 1002, + r3: 1003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), true); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), None); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!( + command_return.get_failure_2_u32(), + Some((error_code::ALREADY, 1002, 1003)) + ); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!( + command_return.return_variant(), + return_variant::FAILURE_2_U32 + ); +} + +#[test] +fn failure_u64() { + let command_return = CommandReturn { + return_variant: return_variant::FAILURE_U64, + r1: error_code::BUSY.into(), + r2: 0x00001002, + r3: 0x00001003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), true); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), None); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!( + command_return.get_failure_u64(), + Some((error_code::BUSY, 0x00001003_00001002)) + ); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!(command_return.return_variant(), return_variant::FAILURE_U64); +} + +#[test] +fn success() { + let command_return = CommandReturn { + return_variant: return_variant::SUCCESS, + r1: 1001, + r2: 1002, + r3: 1003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), true); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), None); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!(command_return.return_variant(), return_variant::SUCCESS); +} + +#[test] +fn success_u32() { + let command_return = CommandReturn { + return_variant: return_variant::SUCCESS_U32, + r1: 1001, + r2: 1002, + r3: 1003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), true); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), None); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), Some(1001)); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!(command_return.return_variant(), return_variant::SUCCESS_U32); +} + +#[test] +fn success_2_u32() { + let command_return = CommandReturn { + return_variant: return_variant::SUCCESS_2_U32, + r1: 1001, + r2: 1002, + r3: 1003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), true); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), None); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), Some((1001, 1002))); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!( + command_return.return_variant(), + return_variant::SUCCESS_2_U32 + ); +} + +#[test] +fn success_u64() { + let command_return = CommandReturn { + return_variant: return_variant::SUCCESS_U64, + r1: 0x00001001, + r2: 0x00001002, + r3: 1003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), true); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), None); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), Some(0x00001002_00001001)); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!(command_return.return_variant(), return_variant::SUCCESS_U64); +} + +#[test] +fn success_3_u32() { + let command_return = CommandReturn { + return_variant: return_variant::SUCCESS_3_U32, + r1: 1001, + r2: 1002, + r3: 1003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), true); + assert_eq!(command_return.is_success_u32_u64(), false); + assert_eq!(command_return.get_failure(), None); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), Some((1001, 1002, 1003))); + assert_eq!(command_return.get_success_u32_u64(), None); + assert_eq!( + command_return.return_variant(), + return_variant::SUCCESS_3_U32 + ); +} + +#[test] +fn success_u32_u64() { + let command_return = CommandReturn { + return_variant: return_variant::SUCCESS_U32_U64, + r1: 1001, + r2: 0x00001002, + r3: 0x00001003, + }; + assert_eq!(command_return.is_failure(), false); + assert_eq!(command_return.is_failure_u32(), false); + assert_eq!(command_return.is_failure_2_u32(), false); + assert_eq!(command_return.is_failure_u64(), false); + assert_eq!(command_return.is_success(), false); + assert_eq!(command_return.is_success_u32(), false); + assert_eq!(command_return.is_success_2_u32(), false); + assert_eq!(command_return.is_success_u64(), false); + assert_eq!(command_return.is_success_3_u32(), false); + assert_eq!(command_return.is_success_u32_u64(), true); + assert_eq!(command_return.get_failure(), None); + assert_eq!(command_return.get_failure_u32(), None); + assert_eq!(command_return.get_failure_2_u32(), None); + assert_eq!(command_return.get_failure_u64(), None); + assert_eq!(command_return.get_success_u32(), None); + assert_eq!(command_return.get_success_2_u32(), None); + assert_eq!(command_return.get_success_u64(), None); + assert_eq!(command_return.get_success_3_u32(), None); + assert_eq!( + command_return.get_success_u32_u64(), + Some((1001, 0x00001003_00001002)) + ); + assert_eq!( + command_return.return_variant(), + return_variant::SUCCESS_U32_U64 + ); +}
diff --git a/core/platform/src/error_code.rs b/core/platform/src/error_code.rs index bd083e0..63cc34e 100644 --- a/core/platform/src/error_code.rs +++ b/core/platform/src/error_code.rs
@@ -3,6 +3,11 @@ /// response to a system call. // ErrorCode is not an enum so that conversion from the kernel's return value (a // `usize` in a register) is free. +// TODO: derive(Debug) is currently only enabled for test builds, which is +// necessary so it can be used in assert_eq!. We should develop a lighter-weight +// Debug implementation and see if it is small enough to enable on non-Debug +// builds. +#[cfg_attr(test, derive(Debug))] #[derive(Clone, Copy, PartialEq, Eq)] pub struct ErrorCode(usize);
diff --git a/core/platform/src/lib.rs b/core/platform/src/lib.rs index 9343145..45021ca 100644 --- a/core/platform/src/lib.rs +++ b/core/platform/src/lib.rs
@@ -1,14 +1,19 @@ #![no_std] mod async_traits; +mod command_return; pub mod error_code; mod raw_syscalls; -pub mod return_type; +pub mod return_variant; mod syscalls; mod syscalls_impl; pub use async_traits::{CallbackContext, FreeCallback, Locator, MethodCallback}; +pub use command_return::CommandReturn; pub use error_code::ErrorCode; pub use raw_syscalls::{OneArgMemop, RawSyscalls, YieldType, ZeroArgMemop}; -pub use return_type::ReturnType; +pub use return_variant::ReturnVariant; pub use syscalls::Syscalls; + +#[cfg(test)] +mod command_return_tests;
diff --git a/core/platform/src/return_type.rs b/core/platform/src/return_type.rs deleted file mode 100644 index da19e87..0000000 --- a/core/platform/src/return_type.rs +++ /dev/null
@@ -1,27 +0,0 @@ -/// `ReturnType` describes what value type the kernel has returned. -// ReturnType is not an enum so that it can be converted from a u32 for free. -#[derive(Clone, Copy, PartialEq, Eq)] -pub struct ReturnType(u32); - -impl From<u32> for ReturnType { - fn from(value: u32) -> ReturnType { - ReturnType(value) - } -} - -impl From<ReturnType> for u32 { - fn from(return_type: ReturnType) -> u32 { - return_type.0 - } -} - -pub const FAILURE: ReturnType = ReturnType(0); -pub const FAILURE_U32: ReturnType = ReturnType(1); -pub const FAILURE_2_U32: ReturnType = ReturnType(2); -pub const FAILURE_U64: ReturnType = ReturnType(3); -pub const SUCCESS: ReturnType = ReturnType(128); -pub const SUCCESS_U32: ReturnType = ReturnType(129); -pub const SUCCESS_2_U32: ReturnType = ReturnType(130); -pub const SUCCESS_U64: ReturnType = ReturnType(131); -pub const SUCCESS_3_U32: ReturnType = ReturnType(132); -pub const SUCCESS_U32_U64: ReturnType = ReturnType(133);
diff --git a/core/platform/src/return_variant.rs b/core/platform/src/return_variant.rs new file mode 100644 index 0000000..e0d6fbf --- /dev/null +++ b/core/platform/src/return_variant.rs
@@ -0,0 +1,32 @@ +/// `ReturnVariant` describes what value type the kernel has returned. +// ReturnVariant is not an enum so that it can be converted from a u32 for free. +// TODO: derive(Debug) is currently only enabled for test builds, which is +// necessary so it can be used in assert_eq!. We should develop a lighter-weight +// Debug implementation and see if it is small enough to enable on non-Debug +// builds. +#[cfg_attr(test, derive(Debug))] +#[derive(Clone, Copy, PartialEq, Eq)] +pub struct ReturnVariant(u32); + +impl From<u32> for ReturnVariant { + fn from(value: u32) -> ReturnVariant { + ReturnVariant(value) + } +} + +impl From<ReturnVariant> for u32 { + fn from(return_variant: ReturnVariant) -> u32 { + return_variant.0 + } +} + +pub const FAILURE: ReturnVariant = ReturnVariant(0); +pub const FAILURE_U32: ReturnVariant = ReturnVariant(1); +pub const FAILURE_2_U32: ReturnVariant = ReturnVariant(2); +pub const FAILURE_U64: ReturnVariant = ReturnVariant(3); +pub const SUCCESS: ReturnVariant = ReturnVariant(128); +pub const SUCCESS_U32: ReturnVariant = ReturnVariant(129); +pub const SUCCESS_2_U32: ReturnVariant = ReturnVariant(130); +pub const SUCCESS_U64: ReturnVariant = ReturnVariant(131); +pub const SUCCESS_3_U32: ReturnVariant = ReturnVariant(132); +pub const SUCCESS_U32_U64: ReturnVariant = ReturnVariant(133);
diff --git a/core/platform/src/syscalls_impl.rs b/core/platform/src/syscalls_impl.rs index 8f24467..506ad64 100644 --- a/core/platform/src/syscalls_impl.rs +++ b/core/platform/src/syscalls_impl.rs
@@ -1,6 +1,6 @@ //! Implements `Syscalls` for all types that implement `RawSyscalls`. -use crate::{return_type, RawSyscalls, Syscalls, YieldType}; +use crate::{return_variant, RawSyscalls, Syscalls, YieldType}; impl<S: RawSyscalls> Syscalls for S { // ------------------------------------------------------------------------- @@ -12,6 +12,6 @@ } fn yield_no_wait() -> bool { - Self::raw_yield(YieldType::NoWait) != return_type::FAILURE.into() + Self::raw_yield(YieldType::NoWait) != return_variant::FAILURE.into() } }