Implement flock for Windows in compiler-rt

[marco-c]

Summary

This patch implements flock for Windows, needed to make gcda writing work in a multiprocessing scenario.

Fixes https://bugs.llvm.org/show_bug.cgi?id=34923.

[zturner]

lib/profile/WindowsMMap.c

131–132

There is a subtle incompatibility here. If fd was originally opened for asynchronous IO, then this function will return immediately. This is basically the same as if you had called flock with LOCK_NB, but the difference is that with flock, the caller has to opt into it, where as with LockFileEx, it's an inherent property of the file descriptor.

Actually, it's a bit more than just a semantic difference. Since the function will return immediately, the OS will be holding onto destroyed stack memory (i.e. the OVERLAPPED structure).

I don't know if you want to handle this, but you should at least be aware, and perhaps leave a comment.

146

I know you're only implementing part of the functionality, but why not all? Seems easy enough to handle LOCK_SH, just change LOCKFILE_EXCLUSIVE_LOCK to LOCKFILE_SHARED_LOCK and the code is the same.

[marco-c]

Updated patch to handle asynchronous I/O case and to implement all flock functionality as suggested.

It's better to implement it in its entirety and correctly handling all cases, otherwise problems in the future could be hard to debug, especially since we are talking about locking.

lib/profile/WindowsMMap.c

if (flags & MS_SYNC) {
      *   return -1;
      */
   }
 
   return 0;
 }
 
 COMPILER_RT_VISIBILITY
-int flock(int fd, int operation)
-{
-  return -1; /* Not supported. */
+int lock(HANDLE handle, DWORD lockType, BOOL blocking) {
+  DWORD flags = lockType;
+  if (!blocking)
+    flags |= LOCKFILE_FAIL_IMMEDIATELY;
+
+  OVERLAPPED overlapped;
+  ZeroMemory(&overlapped, sizeof(OVERLAPPED));
+  overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+  BOOL result = LockFileEx(handle, flags, 0, MAXDWORD, MAXDWORD, &overlapped);
+  if (!result) {
+    DWORD dw = GetLastError();
+
+    // In non-blocking mode, return an error if the file is locked.
+    if (!blocking && dw == ERROR_LOCK_VIOLATION)
+      return -1; // EWOULDBLOCK
+
+    // If the error is ERROR_IO_PENDING, we need to wait until the operation
+    // finishes. Otherwise, we return an error.
+    if (dw != ERROR_IO_PENDING)
+      return -1;
+
+    DWORD dwNumBytes;
+    if (!GetOverlappedResult(handle, &overlapped, &dwNumBytes, TRUE))
+      return -1;
+  }
+
+  return 0;
+}
+
+COMPILER_RT_VISIBILITY
+int flock(int fd, int operation) {
+  HANDLE handle = (HANDLE)_get_osfhandle(fd);
+  if (handle == INVALID_HANDLE_VALUE)
+    return -1;
+
+  BOOL blocking = (operation & LOCK_NB) == 0;
+  int op = operation & ~LOCK_NB;
+
+  switch (op) {
+  case LOCK_EX:
+    return lock(handle, LOCKFILE_EXCLUSIVE_LOCK, blocking);
+
+  case LOCK_SH:
+    return lock(handle, 0, blocking);
+
+  case LOCK_UN:
+    if (!UnlockFile(handle, 0, 0, MAXDWORD, MAXDWORD))
+      return -1;
+    break;
+
+  default:
+    return -1;
+  }
+
+  return 0;
 }
 
 #undef DWORD_HI
 #undef DWORD_LO
 
 #endif /* _WIN32 */