std: move locks to sys on µITRON

library/std/src/sys/locks/condvar/itron.rs

@@ -1,5 +1,7 @@
 //! POSIX conditional variable implementation based on user-space wait queues.
-use super::{abi, error::expect_success_aborting, spin::SpinMutex, task, time::with_tmos_strong};
+use crate::sys::pal::itron::{
+    abi, error::expect_success_aborting, spin::SpinMutex, task, time::with_tmos_strong,
+};
 use crate::{mem::replace, ptr::NonNull, sys::locks::Mutex, time::Duration};
 
 // The implementation is inspired by the queue-based implementation shown in

library/std/src/sys/locks/condvar/mod.rs

@@ -0,0 +1,6 @@
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "solid_asp3")] {
+        mod itron;
+        pub use itron::Condvar;
+    }
+}

library/std/src/sys/locks/mod.rs

@@ -0,0 +1,7 @@
+mod condvar;
+mod mutex;
+mod rwlock;
+
+pub use condvar::Condvar;
+pub use mutex::Mutex;
+pub use rwlock::RwLock;

library/std/src/sys/locks/mutex/itron.rs

@@ -1,6 +1,6 @@
 //! Mutex implementation backed by μITRON mutexes. Assumes `acre_mtx` and
 //! `TA_INHERIT` are available.
-use super::{
+use crate::sys::pal::itron::{
     abi,
     error::{expect_success, expect_success_aborting, fail, ItronError},
     spin::SpinIdOnceCell,
@@ -66,20 +66,3 @@ impl Drop for Mutex {
         }
     }
 }
-
-pub(super) struct MutexGuard<'a>(&'a Mutex);
-
-impl<'a> MutexGuard<'a> {
-    #[inline]
-    pub(super) fn lock(x: &'a Mutex) -> Self {
-        x.lock();
-        Self(x)
-    }
-}
-
-impl Drop for MutexGuard<'_> {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe { self.0.unlock() };
-    }
-}

library/std/src/sys/locks/mutex/mod.rs

@@ -0,0 +1,6 @@
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "solid_asp3")] {
+        mod itron;
+        pub use itron::Mutex;
+    }
+}

library/std/src/sys/locks/rwlock/mod.rs

@@ -0,0 +1,6 @@
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "solid_asp3")] {
+        mod solid;
+        pub use solid::RwLock;
+    }
+}

library/std/src/sys/locks/rwlock/solid.rs

@@ -1,5 +1,5 @@
 //! A readers-writer lock implementation backed by the SOLID kernel extension.
-use super::{
+use crate::sys::pal::{
     abi,
     itron::{
         error::{expect_success, expect_success_aborting, fail, ItronError},

library/std/src/sys/mod.rs

@@ -6,6 +6,7 @@ mod pal;
 mod personality;
 
 pub mod cmath;
+pub mod locks;
 pub mod os_str;
 pub mod path;
 

library/std/src/sys/pal/solid/abi/fs.rs

@@ -1,9 +1,8 @@
 //! `solid_fs.h`
 use crate::os::raw::{c_char, c_int, c_uchar};
 pub use libc::{
-    blksize_t, dev_t, ino_t, off_t, stat, time_t, O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR,
+    ino_t, off_t, stat, time_t, O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY,
-    O_TRUNC, O_WRONLY, SEEK_CUR, SEEK_END, SEEK_SET, S_IEXEC, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO,
+    SEEK_CUR, SEEK_END, SEEK_SET, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFMT, S_IFREG, S_IWRITE,
-    S_IFMT, S_IFREG, S_IREAD, S_IWRITE,
 };
 
 pub const O_ACCMODE: c_int = 0x3;

library/std/src/sys/pal/solid/abi/sockets.rs

@@ -1,5 +1,5 @@
 use crate::os::raw::{c_char, c_uint, c_void};
-pub use libc::{c_int, c_long, size_t, ssize_t, suseconds_t, time_t, timeval};
+pub use libc::{c_int, c_long, size_t, ssize_t, timeval};
 
 pub const SOLID_NET_ERR_BASE: c_int = -2000;
 pub const EINPROGRESS: c_int = SOLID_NET_ERR_BASE - libc::EINPROGRESS;

library/std/src/sys/pal/solid/mod.rs

@@ -2,19 +2,17 @@
 #![allow(missing_docs, nonstandard_style)]
 #![deny(unsafe_op_in_unsafe_fn)]
 
-mod abi;
+pub mod abi;
 
 #[path = "../itron"]
-mod itron {
+pub mod itron {
-    pub(super) mod abi;
+    pub mod abi;
-    pub mod condvar;
+    pub mod error;
-    pub(super) mod error;
+    pub mod spin;
-    pub mod mutex;
+    pub mod task;
-    pub(super) mod spin;
-    pub(super) mod task;
     pub mod thread;
     pub mod thread_parking;
-    pub(super) mod time;
+    pub mod time;
     use super::unsupported;
 }
 
@@ -41,14 +39,6 @@ pub mod thread_local_key;
 pub use self::itron::thread_parking;
 pub mod time;
 
-mod rwlock;
-
-pub mod locks {
-    pub use super::itron::condvar::*;
-    pub use super::itron::mutex::*;
-    pub use super::rwlock::*;
-}
-
 // SAFETY: must be called only once during runtime initialization.
 // NOTE: this is not guaranteed to run, for example when Rust code is called externally.
 pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {}