Map Windows ERROR_LOCK_VIOLATION to ErrorKind::WouldBlock

This changes decode_error_kind() on Windows to map ERROR_LOCK_VIOLATION
to ErrorKind::WouldBlock instead of ErrorKind::Uncategorized

Author: cberner

library/std/src/fs/tests.rs

@@ -358,6 +358,28 @@ fn file_lock_blocking_async() {
     t.join().unwrap();
 }
 
+#[test]
+#[cfg(windows)]
+fn file_try_lock_async() {
+    const FILE_FLAG_OVERLAPPED: u32 = 0x40000000;
+
+    let tmpdir = tmpdir();
+    let filename = &tmpdir.join("file_try_lock_async.txt");
+    let f1 = check!(File::create(filename));
+    let f2 =
+        check!(OpenOptions::new().custom_flags(FILE_FLAG_OVERLAPPED).write(true).open(filename));
+
+    // Check that shared locks block exclusive locks
+    check!(f1.lock_shared());
+    assert_matches!(f2.try_lock().unwrap_err().kind(), ErrorKind::WouldBlock);
+    check!(f1.unlock());
+
+    // Check that exclusive locks block all locks
+    check!(f1.lock());
+    assert_matches!(f2.try_lock().unwrap_err().kind(), ErrorKind::WouldBlock);
+    assert_matches!(f2.try_lock_shared().unwrap_err().kind(), ErrorKind::WouldBlock);
+}
+
 #[test]
 fn file_test_io_seek_shakedown() {
     //                   01234567890123

library/std/src/sys/fs/windows.rs

@@ -400,7 +400,7 @@ impl File {
     }
 
     pub fn try_lock(&self) -> io::Result<()> {
-        let result = cvt(unsafe {
+        cvt(unsafe {
             let mut overlapped = mem::zeroed();
             c::LockFileEx(
                 self.handle.as_raw_handle(),
@@ -410,22 +410,13 @@ impl File {
                 u32::MAX,
                 &mut overlapped,
             )
-        });
+        })?;
 
-        match result {
-            Ok(_) => Ok(()),
-            Err(err)
-                if err.raw_os_error() == Some(c::ERROR_IO_PENDING as i32)
-                    || err.raw_os_error() == Some(c::ERROR_LOCK_VIOLATION as i32) =>
-            {
-                Err(io::ErrorKind::WouldBlock.into())
-            }
-            Err(err) => Err(err),
-        }
+        Ok(())
     }
 
     pub fn try_lock_shared(&self) -> io::Result<()> {
-        let result = cvt(unsafe {
+        cvt(unsafe {
             let mut overlapped = mem::zeroed();
             c::LockFileEx(
                 self.handle.as_raw_handle(),
@@ -435,18 +426,9 @@ impl File {
                 u32::MAX,
                 &mut overlapped,
             )
-        });
+        })?;
 
-        match result {
-            Ok(_) => Ok(()),
-            Err(err)
-                if err.raw_os_error() == Some(c::ERROR_IO_PENDING as i32)
-                    || err.raw_os_error() == Some(c::ERROR_LOCK_VIOLATION as i32) =>
-            {
-                Err(io::ErrorKind::WouldBlock.into())
-            }
-            Err(err) => Err(err),
-        }
+        Ok(())
     }
 
     pub fn unlock(&self) -> io::Result<()> {

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

@@ -114,6 +114,7 @@ pub fn decode_error_kind(errno: i32) -> ErrorKind {
         c::ERROR_TOO_MANY_LINKS => return TooManyLinks,
         c::ERROR_FILENAME_EXCED_RANGE => return InvalidFilename,
         c::ERROR_CANT_RESOLVE_FILENAME => return FilesystemLoop,
+        c::ERROR_LOCK_VIOLATION => return WouldBlock,
         _ => {}
     }