From 195a95a31c453d76bcd881d549aa6fae7331221d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Onur=20=C3=96zkan?= <onurozkan.dev@outlook.com>
Date: Fri, 29 Dec 2023 19:52:32 +0300
Subject: [PATCH] Target support: solaris (#48)

* support new target(solaris) with conditional compilation

Signed-off-by: onur-ozkan <work@onurozkan.dev>

* create compatible_unix_lock

Signed-off-by: onur-ozkan <work@onurozkan.dev>

---------

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/sys/unix/mod.rs         | 13 +++++++++++++
 src/sys/unix/read_guard.rs  |  6 +++---
 src/sys/unix/rw_lock.rs     | 23 ++++++++++-------------
 src/sys/unix/write_guard.rs |  6 +++---
 4 files changed, 29 insertions(+), 19 deletions(-)

diff --git a/src/sys/unix/mod.rs b/src/sys/unix/mod.rs
index 023e691..12544dd 100644
--- a/src/sys/unix/mod.rs
+++ b/src/sys/unix/mod.rs
@@ -5,3 +5,16 @@ mod write_guard;
 pub use read_guard::RwLockReadGuard;
 pub use rw_lock::RwLock;
 pub use write_guard::RwLockWriteGuard;
+
+use rustix::{fd::AsFd, fs};
+
+pub(crate) fn compatible_unix_lock<Fd: AsFd>(
+    fd: Fd,
+    operation: fs::FlockOperation,
+) -> rustix::io::Result<()> {
+    #[cfg(not(target_os = "solaris"))]
+    return fs::flock(fd, operation);
+
+    #[cfg(target_os = "solaris")]
+    return fs::fcntl_lock(fd, operation);
+}
diff --git a/src/sys/unix/read_guard.rs b/src/sys/unix/read_guard.rs
index 972bb56..2e58366 100644
--- a/src/sys/unix/read_guard.rs
+++ b/src/sys/unix/read_guard.rs
@@ -1,8 +1,8 @@
 use rustix::fd::AsFd;
-use rustix::fs::{flock, FlockOperation};
+use rustix::fs::FlockOperation;
 use std::ops;
 
-use super::RwLock;
+use super::{compatible_unix_lock, RwLock};
 
 #[derive(Debug)]
 pub struct RwLockReadGuard<'lock, T: AsFd> {
@@ -27,6 +27,6 @@ impl<T: AsFd> ops::Deref for RwLockReadGuard<'_, T> {
 impl<T: AsFd> Drop for RwLockReadGuard<'_, T> {
     #[inline]
     fn drop(&mut self) {
-        let _ = flock(&self.lock.inner.as_fd(), FlockOperation::Unlock).ok();
+        let _ = compatible_unix_lock(self.lock.inner.as_fd(), FlockOperation::Unlock).ok();
     }
 }
diff --git a/src/sys/unix/rw_lock.rs b/src/sys/unix/rw_lock.rs
index 992925e..e10b55c 100644
--- a/src/sys/unix/rw_lock.rs
+++ b/src/sys/unix/rw_lock.rs
@@ -1,8 +1,8 @@
 use rustix::fd::AsFd;
-use rustix::fs::{flock, FlockOperation};
+use rustix::fs::FlockOperation;
 use std::io::{self, Error, ErrorKind};
 
-use super::{RwLockReadGuard, RwLockWriteGuard};
+use super::{compatible_unix_lock, RwLockReadGuard, RwLockWriteGuard};
 
 #[derive(Debug)]
 pub struct RwLock<T: AsFd> {
@@ -17,32 +17,29 @@ impl<T: AsFd> RwLock<T> {
 
     #[inline]
     pub fn write(&mut self) -> io::Result<RwLockWriteGuard<'_, T>> {
-        flock(&self.inner.as_fd(), FlockOperation::LockExclusive)?;
+        compatible_unix_lock(self.inner.as_fd(), FlockOperation::LockExclusive)?;
         Ok(RwLockWriteGuard::new(self))
     }
 
     #[inline]
     pub fn try_write(&mut self) -> Result<RwLockWriteGuard<'_, T>, Error> {
-        flock(
-            &self.inner.as_fd(),
-            FlockOperation::NonBlockingLockExclusive,
-        )
-        .map_err(|err| match err.kind() {
-            ErrorKind::AlreadyExists => ErrorKind::WouldBlock.into(),
-            _ => Error::from(err),
-        })?;
+        compatible_unix_lock(self.inner.as_fd(), FlockOperation::NonBlockingLockExclusive)
+            .map_err(|err| match err.kind() {
+                ErrorKind::AlreadyExists => ErrorKind::WouldBlock.into(),
+                _ => Error::from(err),
+            })?;
         Ok(RwLockWriteGuard::new(self))
     }
 
     #[inline]
     pub fn read(&self) -> io::Result<RwLockReadGuard<'_, T>> {
-        flock(&self.inner.as_fd(), FlockOperation::LockShared)?;
+        compatible_unix_lock(self.inner.as_fd(), FlockOperation::LockShared)?;
         Ok(RwLockReadGuard::new(self))
     }
 
     #[inline]
     pub fn try_read(&self) -> Result<RwLockReadGuard<'_, T>, Error> {
-        flock(&self.inner.as_fd(), FlockOperation::NonBlockingLockShared).map_err(
+        compatible_unix_lock(self.inner.as_fd(), FlockOperation::NonBlockingLockShared).map_err(
             |err| match err.kind() {
                 ErrorKind::AlreadyExists => ErrorKind::WouldBlock.into(),
                 _ => Error::from(err),
diff --git a/src/sys/unix/write_guard.rs b/src/sys/unix/write_guard.rs
index 1bdc1a4..7e61034 100644
--- a/src/sys/unix/write_guard.rs
+++ b/src/sys/unix/write_guard.rs
@@ -1,8 +1,8 @@
 use rustix::fd::AsFd;
-use rustix::fs::{flock, FlockOperation};
+use rustix::fs::FlockOperation;
 use std::ops;
 
-use super::RwLock;
+use super::{compatible_unix_lock, RwLock};
 
 #[derive(Debug)]
 pub struct RwLockWriteGuard<'lock, T: AsFd> {
@@ -34,6 +34,6 @@ impl<T: AsFd> ops::DerefMut for RwLockWriteGuard<'_, T> {
 impl<T: AsFd> Drop for RwLockWriteGuard<'_, T> {
     #[inline]
     fn drop(&mut self) {
-        let _ = flock(&self.lock.inner.as_fd(), FlockOperation::Unlock).ok();
+        let _ = compatible_unix_lock(self.lock.inner.as_fd(), FlockOperation::Unlock).ok();
     }
 }