[gcov] Fix simultaneous .gcda creation/lock

[kawashima-fj]

Summary

Fixes PR45673

The commit 9180c14fe4d (D76206) resolved only a part of the problem
of concurrent .gcda file creation. It ensured that only one process
creates the file but did not ensure that the process locks the
file first. If not, the process which created the file may clobber
the contents written by a process which locked the file first.
This is the cause of PR45673.

This commit prevents the clobbering by revising the assumption
that a process which creates the file locks the file first.
Regardless of file creation, a process which locked the file first
uses fwrite (new_file==1) and other processes use mmap (new_file==0).

I also tried to keep the creation/first-lock process same by using
mkstemp/link/unlink but the code gets long. This commit is more
simple.

Note: You may be confused with other changes which try to resolve
concurrent file access. My understanding is (may not be correct):

D76206: Resolve race of .gcda file creation (but not lock)
This one: Resolve race of .gcda file creation and lock
D54599: Same as D76206 and this but abandoned?
D70910: Resolve race of multi-threaded counter flushing
D74953: Resolve counter sharing between parent/children processes
D78477: Revision of D74953

[calixte]

Good catch.

compiler-rt/lib/profile/GCDAProfiling.c

static char *mangle_filename(const char *orig_filename) {
 
   return new_filename;
 }
 
 static int map_file() {
   fseek(output_file, 0L, SEEK_END);
   file_size = ftell(output_file);
 
-  /* A size of 0 is invalid to `mmap'. Return a fail here, but don't issue an
-   * error message because it should "just work" for the user. */
+  /* A size of 0 means the file has been created just now (possibly by another
+   * process in lock-after-open race condition). No need to mmap. */
   if (file_size == 0)
     return -1;
 
 #if defined(_WIN32)
   HANDLE mmap_fd;
   if (fd == -1)
     mmap_fd = INVALID_HANDLE_VALUE;
   else

  */
 COMPILER_RT_VISIBILITY
 void llvm_gcda_start_file(const char *orig_filename, const char version[4],
                           uint32_t checksum) {
   const char *mode = "r+b";
   filename = mangle_filename(orig_filename);
 
   /* Try just opening the file. */
-  new_file = 0;
   fd = open(filename, O_RDWR | O_BINARY);
 
   if (fd == -1) {
     /* Try creating the file. */
     fd = open(filename, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0644);
     if (fd != -1) {
-      new_file = 1;
       mode = "w+b";
     } else {
       /* Try creating the directories first then opening the file. */
       __llvm_profile_recursive_mkdir(filename);
       fd = open(filename, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0644);
       if (fd != -1) {
-        new_file = 1;
         mode = "w+b";
       } else {
         /* Another process may have created the file just now.
          * Try opening it without O_CREAT and O_EXCL. */
         fd = open(filename, O_RDWR | O_BINARY);
         if (fd == -1) {
           /* Bah! It's hopeless. */
           int errnum = errno;
           fprintf(stderr, "profiling: %s: cannot open: %s\n", filename,
                   strerror(errnum));
           return;
         }
       }
     }
   }
 
   /* Try to flock the file to serialize concurrent processes writing out to the
    * same GCDA. This can fail if the filesystem doesn't support it, but in that
    * case we'll just carry on with the old racy behaviour and hope for the best.
    */
   lprofLockFd(fd);
   output_file = fdopen(fd, mode);
 
   /* Initialize the write buffer. */
+  new_file = 0;
   write_buffer = NULL;
   cur_buffer_size = 0;
   cur_pos = 0;
 
-  if (new_file) {
-    resize_write_buffer(WRITE_BUFFER_SIZE);
-    memset(write_buffer, 0, WRITE_BUFFER_SIZE);
-  } else {
-    if (map_file() == -1) {
-      /* mmap failed, try to recover by clobbering */
-      new_file = 1;
-      write_buffer = NULL;
-      cur_buffer_size = 0;
-      resize_write_buffer(WRITE_BUFFER_SIZE);
-      memset(write_buffer, 0, WRITE_BUFFER_SIZE);
-    }
-  }
+    /* The file has been created just now (file_size == 0) or mmap failed
+     * unexpectedly. In the latter case, try to recover by clobbering. */
 
   /* gcda file, version, stamp checksum. */
   write_bytes("adcg", 4);
   write_bytes(version, 4);
   write_32bit_value(checksum);
 
 #ifdef DEBUG_GCDAPROFILING
   fprintf(stderr, "llvmgcda: [%s]\n", orig_filename);

compiler-rt/test/profile/Posix/instrprof-gcov-parallel.test

-# Work around PR45673 until the test code is fixed
-# ALLOW_RETRIES: 2
-
 RUN: mkdir -p %t.d
 RUN: cd %t.d
 
 RUN: %clang -o %t.driver %S/../Inputs/instrprof-gcov-parallel.driver.c
 RUN: %clang --coverage -o %t.target %S/../Inputs/instrprof-gcov-parallel.target.c
 RUN: test -f instrprof-gcov-parallel.target.gcno
 
 RUN: rm -f instrprof-gcov-parallel.target.gcda
 RUN: %run %t.driver %t.target
 RUN: llvm-cov gcov instrprof-gcov-parallel.target.gcda
 RUN: FileCheck --input-file instrprof-gcov-parallel.target.c.gcov %s
 
 # Test if the .gcda file is correctly created from one of child processes
 # and counters of all processes are recorded correctly.
 # 707 = CHILDREN * COUNT
 CHECK: 707: {{[0-9]+}}: aaa++;