[lld] Fix elf::unlinkAsync detached thread

[vitalybuka]

Summary

So this patch just make sure that the thread is at least stated
before we return from main.

If we just detach then the thread may be actually be stated just after
the process returned from main and it's calling atexit handers. Then the thread may try to create own function static variable and it will
add new at exit handlers confusing libc.

GLIBC before 2.27 had race in that case which corrupted atexit handlers
list. Support for this use-case for other implementation is also unclear,
so we can try just avoid that.

PR40162

[ruiu]

lld/ELF/Filesystem.cpp

65–82

Flip the condition and return early.

66

Please leave a comment why we are waiting for a thread startup.

[vitalybuka]

command and early return

[vitalybuka]

moved comment

[ruiu]

lld/ELF/Filesystem.cpp

77

I don't know if I understand this comment correctly. Why don't you simply mention that there is a race condition in glibc 2.27 and earlier that crashes an entire process if the main thread calls exit(2) while other thread is starting up.

nit: please insert a blank line before a multi-line comment.

[vitalybuka]

simplify comments

[ruiu]

LGTM

lld/ELF/Filesystem.cpp

#else
   // We cannot just remove path from a different thread because we are now going
   // to create path as a new file.
   // Instead we open the file and unlink it on this thread. The unlink is fast
   // since the open fd guarantees that it is not removing the last reference.
   int FD;
   std::error_code EC = sys::fs::openFileForRead(Path, FD);
   sys::fs::remove(Path);
 
+  if (EC)
+    return;
+
   // close and therefore remove TempPath in background.
-  if (!EC)
-    std::thread([=] { ::close(FD); }).detach();
+  std::mutex M;
+  std::condition_variable CV;
+  bool Started = false;
+  std::thread([&, FD] {
+    {
+      std::lock_guard<std::mutex> L(M);
+      Started = true;
+      CV.notify_all();
+    }
+    ::close(FD);
+  }).detach();
+  std::unique_lock<std::mutex> L(M);
+  // Wait the thread to start. std::thread will touch function local variables
+  // installing atexing handlers. We want to make it happen before libc started
+  // to call handlers.
+  // Additionally GLIBC before 2.27 had race between __internal_atexit and
+  // __run_exit_handlers.
+  CV.wait(L, [&] { return Started; });
 #endif
 }
 
 // Simulate file creation to see if Path is writable.
 //
 // Determining whether a file is writable or not is amazingly hard,
 // and after all the only reliable way of doing that is to actually
 // create a file. But we don't want to do that in this function