Merge pull request rust-lang#5073 from RalfJung/flock-tests

flock tests: cover the case of asking for both locks on the same file handle

Author: RalfJung

src/tools/miri/tests/pass-dep/libc/libc-fs-flock.rs

@@ -3,6 +3,10 @@
 //@ignore-target: android # Does not (always?) have flock
 //@compile-flags: -Zmiri-disable-isolation
 
+//@revisions: windows_host unix_host
+//@[unix_host] ignore-host: windows
+//@[windows_host] only-host: windows
+
 use std::fs::File;
 use std::os::fd::AsRawFd;
 
@@ -18,31 +22,31 @@ fn main() {
 
     let files: Vec<File> = (0..3).map(|_| File::open(&path).unwrap()).collect();
 
-    // Test that we can apply many shared locks
+    // Test that we can apply many shared locks.
     for file in files.iter() {
         errno_check(unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_SH) });
     }
 
-    // Test that shared lock prevents exclusive lock
+    // Test that shared lock prevents exclusive lock.
     {
         let fd = files[0].as_raw_fd();
         let err =
             errno_result(unsafe { libc::flock(fd, libc::LOCK_EX | libc::LOCK_NB) }).unwrap_err();
         assert_eq!(err.raw_os_error().unwrap(), libc::EWOULDBLOCK);
     }
 
-    // Unlock shared lock
+    // Unlock shared lock.
     for file in files.iter() {
         errno_check(unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_UN) });
     }
 
-    // Take exclusive lock
+    // Take exclusive lock.
     {
         let fd = files[0].as_raw_fd();
         errno_check(unsafe { libc::flock(fd, libc::LOCK_EX) });
     }
 
-    // Test that shared lock prevents exclusive and shared locks
+    // Test that exclusive lock prevents exclusive and shared locks.
     {
         let fd = files[1].as_raw_fd();
         let err =
@@ -55,9 +59,39 @@ fn main() {
         assert_eq!(err.raw_os_error().unwrap(), libc::EWOULDBLOCK);
     }
 
-    // Unlock exclusive lock
+    // Unlock exclusive lock.
     {
         let fd = files[0].as_raw_fd();
         errno_check(unsafe { libc::flock(fd, libc::LOCK_UN) });
+        // Redundant unlock also works.
+        // FIXME(#miri/5074): except on Windows hosts...
+        if !cfg!(windows_host) {
+            errno_check(unsafe { libc::flock(fd, libc::LOCK_UN) });
+        }
+    }
+
+    // Test behavior when we acquire multiple locks on the same FD.
+    // FIXME(#miri/5074): this does not behave correctly on Windows hosts.
+    if !cfg!(windows_host) {
+        let fd1 = files[1].as_raw_fd();
+        let fd2 = files[2].as_raw_fd();
+
+        errno_check(unsafe { libc::flock(fd1, libc::LOCK_EX | libc::LOCK_NB) });
+        // This converts the exclusive lock to a shared lock.
+        errno_check(unsafe { libc::flock(fd1, libc::LOCK_SH | libc::LOCK_NB) });
+        // Now the other fd can have the shared lock as well.
+        errno_check(unsafe { libc::flock(fd2, libc::LOCK_SH | libc::LOCK_NB) });
+
+        // Reset.
+        errno_check(unsafe { libc::flock(fd1, libc::LOCK_UN) });
+        errno_check(unsafe { libc::flock(fd2, libc::LOCK_UN) });
+
+        // Getting first a shared lock and then upgrading to exclusive should also work.
+        errno_check(unsafe { libc::flock(fd1, libc::LOCK_SH | libc::LOCK_NB) });
+        errno_check(unsafe { libc::flock(fd1, libc::LOCK_EX | libc::LOCK_NB) });
+        // This is truly exclusive: fd2 is locked out.
+        let err =
+            errno_result(unsafe { libc::flock(fd2, libc::LOCK_SH | libc::LOCK_NB) }).unwrap_err();
+        assert_eq!(err.raw_os_error().unwrap(), libc::EWOULDBLOCK);
     }
 }

src/tools/miri/tests/pass/shims/fs.rs

@@ -417,20 +417,21 @@ fn test_flock() {
     let file1 = OpenOptions::new().read(true).write(true).open(&path).unwrap();
     let file2 = OpenOptions::new().read(true).write(true).open(&path).unwrap();
 
-    // Test that we can apply many shared locks
+    // Test that we can apply many shared locks.
     file1.lock_shared().unwrap();
     file2.lock_shared().unwrap();
-    // Test that shared lock prevents exclusive lock
+    // Test that shared lock prevents exclusive lock.
     assert!(matches!(file1.try_lock().unwrap_err(), fs::TryLockError::WouldBlock));
-    // Unlock shared lock
+    // Unlock both files.
     file1.unlock().unwrap();
     file2.unlock().unwrap();
-    // Take exclusive lock
+
+    // Take exclusive lock.
     file1.lock().unwrap();
-    // Test that shared lock prevents exclusive and shared locks
+    // Test that shared lock prevents exclusive and shared locks.
     assert!(matches!(file2.try_lock().unwrap_err(), fs::TryLockError::WouldBlock));
     assert!(matches!(file2.try_lock_shared().unwrap_err(), fs::TryLockError::WouldBlock));
-    // Unlock exclusive lock
+    // Unlock exclusive lock.
     file1.unlock().unwrap();
 }