Merge pull request #88 from elast0ny/fix/windows_raw_mappings

Fix logging feature & Windows bug #82

Author: elast0ny

Cargo.toml

@@ -35,9 +35,9 @@ nix = "0.23"
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
-win-sys = "0"
+win-sys = "0.2"
 
 [dev-dependencies]
 raw_sync = "0.1"
-clap = "2.33"
+clap = {version = "3", features = ["derive"]}
 env_logger = "0"

examples/basic.rs

@@ -1,39 +1,37 @@
 use std::thread;
 
-use clap::{App, Arg};
+use clap::Parser;
 use shared_memory::*;
 
+/// Spawns N threads that increment a value to 100
+#[derive(Parser)]
+#[clap(author, version, about)]
+struct Args {
+    /// Number of threads to spawn
+    num_threads: usize,
+
+    /// Count to this value
+    #[clap(long, short, default_value_t = 50)]
+    count_to: u8,
+}
+
 fn main() {
     env_logger::init();
+    let args = Args::parse();
 
-    // Get number of thread argument
-    let matches = App::new("Basic Example")
-        .about("Spawns N threads that increment a value to 100")
-        .arg(
-            Arg::with_name("num_threads")
-                .help("Number of threads to spawn")
-                .required(true)
-                .takes_value(true),
-        )
-        .get_matches();
-    let num_threads: usize = matches
-        .value_of("num_threads")
-        .unwrap()
-        .parse()
-        .expect("Invalid number passed for num_threads");
-    if num_threads < 1 {
+    if args.num_threads < 1 {
         eprintln!("Invalid number of threads");
         return;
     }
 
-    let mut threads = Vec::with_capacity(num_threads);
+    let mut threads = Vec::with_capacity(args.num_threads);
     let _ = std::fs::remove_file("basic_mapping");
-
+    let max = args.count_to;
     // Spawn N threads
-    for i in 0..num_threads {
+    for i in 0..args.num_threads {
         let thread_id = i + 1;
         threads.push(thread::spawn(move || {
-            increment_value("basic_mapping", thread_id);
+            increment_value("basic_mapping", thread_id, max);
         }));
     }
 
@@ -44,7 +42,7 @@ fn main() {
 }
 
 /// Increments a value that lives in shared memory
-fn increment_value(shmem_flink: &str, thread_num: usize) {
+fn increment_value(shmem_flink: &str, thread_num: usize, max: u8) {
     // Create or open the shared memory mapping
     let shmem = match ShmemConf::new().size(4096).flink(shmem_flink).create() {
         Ok(m) => m,
@@ -63,7 +61,7 @@ fn increment_value(shmem_flink: &str, thread_num: usize) {
 
     // WARNING: This is prone to race conditions as no sync/locking is used
     unsafe {
-        while std::ptr::read_volatile(raw_ptr) < 100 {
+        while std::ptr::read_volatile(raw_ptr) < max {
             // Increment shared value by one
             *raw_ptr += 1;
 

examples/mutex.rs

@@ -1,36 +1,35 @@
 use std::sync::atomic::{AtomicU8, Ordering};
 use std::thread;
 
-use clap::{App, Arg};
+use clap::Parser;
 use raw_sync::locks::*;
 use shared_memory::*;
 
+/// Spawns N threads that increment a value to 10 using a mutex
+#[derive(Parser)]
+#[clap(author, version, about)]
+struct Args {
+    /// Number of threads to spawn
+    num_threads: usize,
+
+    /// Count to this value
+    #[clap(long, short, default_value_t = 50)]
+    count_to: u8,
+}
+
 fn main() {
     env_logger::init();
-    let matches = App::new("Mutex Example")
-        .about("Spawns N threads that increment a value to 10 using a mutex")
-        .arg(
-            Arg::with_name("num_threads")
-                .help("Number of threads to spawn")
-                .required(true)
-                .takes_value(true),
-        )
-        .get_matches();
+    let args = Args::parse();
 
-    let num_threads: usize = matches
-        .value_of("num_threads")
-        .unwrap()
-        .parse()
-        .expect("Invalid number passed for num_threads");
-    if num_threads < 1 {
+    if args.num_threads < 1 {
         eprintln!("num_threads should be 2 or more");
         return;
     }
-    let mut threads = Vec::with_capacity(num_threads);
+    let mut threads = Vec::with_capacity(args.num_threads);
     let _ = std::fs::remove_file("mutex_mapping");
 
     // Spawn N threads
-    for i in 0..num_threads {
+    for i in 0..args.num_threads {
         let thread_id = i + 1;
         threads.push(thread::spawn(move || {
             increment_value("mutex_mapping", thread_id);

src/lib.rs

@@ -10,17 +10,20 @@ use std::path::{Path, PathBuf};
 
 use cfg_if::cfg_if;
 
-#[cfg(feature = "logging")]
-pub use log;
-#[cfg(not(feature = "logging"))]
-#[allow(unused_macros)]
-mod log {
-    macro_rules! trace (($($tt:tt)*) => {{}});
-    macro_rules! debug (($($tt:tt)*) => {{}});
-    macro_rules! info (($($tt:tt)*) => {{}});
-    macro_rules! warn (($($tt:tt)*) => {{}});
-    macro_rules! error (($($tt:tt)*) => {{}});
-    pub(crate) use {debug, trace};
+cfg_if! {
+    if #[cfg(feature = "logging")] {
+        pub use log;
+    } else {
+        #[allow(unused_macros)]
+        mod log {
+            macro_rules! trace (($($tt:tt)*) => {{}});
+            macro_rules! debug (($($tt:tt)*) => {{}});
+            macro_rules! info (($($tt:tt)*) => {{}});
+            macro_rules! warn (($($tt:tt)*) => {{}});
+            macro_rules! error (($($tt:tt)*) => {{}});
+            pub(crate) use {debug, trace};
+        }
+    }
 }
 
 use crate::log::*;
@@ -102,6 +105,12 @@ impl ShmemConf {
             return Err(ShmemError::MapSizeZero);
         }
 
+        if let Some(ref flink_path) = self.flink_path {
+            if !self.overwrite_flink && flink_path.is_file() {
+                return Err(ShmemError::LinkExists);
+            }
+        }
+
         // Create the mapping
         let mapping = match self.os_id {
             None => {
@@ -250,7 +259,7 @@ impl Shmem {
     }
     /// Returns a raw pointer to the mapping
     pub fn as_ptr(&self) -> *mut u8 {
-        self.mapping.map_ptr
+        self.mapping.as_mut_ptr()
     }
     /// Returns mapping as a byte slice
     /// # Safety

src/unix.rs

@@ -24,6 +24,12 @@ pub struct MapData {
     pub map_ptr: *mut u8,
 }
 
+impl MapData {
+    pub fn as_mut_ptr(&self) -> *mut u8 {
+        self.map_ptr
+    }
+}
+
 /// Shared memory teardown for linux
 impl Drop for MapData {
     ///Takes care of properly closing the SharedMem (munmap(), shmem_unlink(), close())