[profile] Support for GCDA profiling in Fuchsia

[phosek]

Summary

We already support instrumentation based profiling, but some clients
like Rust still use GCDA so we need to support it as well.

[davidxl]

compiler-rt/lib/profile/GCDAProfiling.c

258

slightly prefer

#if defined(Fuchia)
// for now empty
#else /* other platforms */

Original code

#endif

420

This big chunk of platform specific code reduces readability. Perhaps wrap it into a helper function. You can even add new file and put all platform specific code in there (starting from Fuchia -- other platforms can follow later).

[davidxl]

The refactoring part looks ok. +vsk to double check.

[vsk]

This looks ok to me. In the longer term, I think compiler-rt would benefit from borrowing/extending llvm's generic file interface to abstract over platform differences. It doesn't seem ideal to me that libprofile/xray etc. have lots of platform-specific file I/O code.

[phosek]

I'd like to split the platform specific aspects to separate files, e.g. GCDAProfilingPlatformUnix.c, GCDAProfilingPlatformWindows.c and GCDAProfilingPlatformFuchsia.c as suggested by @davidxl, but I'd rather do it in a follow up change.

[vsk]

Thanks!

compiler-rt/lib/profile/GCDAProfiling.c

 |* are only close enough that LCOV will happily parse them. Anything that lcov
 |* ignores is missing.
 |*
 |* TODO: gcov is multi-process safe by having each exit open the existing file
 |* and append to it. We'd like to achieve that and be thread-safe too.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#if !defined(__Fuchsia__)
-
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #if defined(_WIN32)
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include "WindowsMMap.h"
+#elif defined(__Fuchsia__)
+#include <zircon/process.h>
+#include <zircon/sanitizer.h>
+#include <zircon/status.h>
+#include <zircon/syscalls.h>
 #else
 #include <sys/mman.h>
 #include <sys/file.h>
 #endif
 
 #if defined(__FreeBSD__) && defined(__i386__)
 #define I386_FREEBSD 1
 #else

 /*
  * The current file name we're outputting. Used primarily for error logging.
  */
 static char *filename = NULL;
 
 /*
  * The current file we're outputting.
  */ 
+#ifdef __Fuchsia__
+static zx_handle_t output_file = ZX_HANDLE_INVALID;
+#else
 static FILE *output_file = NULL;
+#endif
 
 /*
  * Buffer that we write things into.
  */
 #define WRITE_BUFFER_SIZE (128 * 1024)
 static unsigned char *write_buffer = NULL;
 static uint64_t cur_buffer_size = 0;
 static uint64_t cur_pos = 0;
-static uint64_t file_size = 0;
 static int new_file = 0;
 #if defined(_WIN32)
 static HANDLE mmap_handle = NULL;
 #endif
+#ifdef __Fuchsia__
+static const size_t file_size = sizeof(void *) << 32;
+static const char sink_name[] = "llvmgcda";
+#else
+static uint64_t file_size = 0;
 static int fd = -1;
+#endif
 
 typedef void (*fn_ptr)();
 
 typedef void* dynamic_object_id;
 // The address of this variable identifies a given dynamic object.
 static dynamic_object_id current_id;
 #define CURRENT_ID (&current_id)
 

 }
 
 static void resize_write_buffer(uint64_t size) {
   if (!new_file) return;
   size += cur_pos;
   if (size <= cur_buffer_size) return;
   size = (size - 1) / WRITE_BUFFER_SIZE + 1;
   size *= WRITE_BUFFER_SIZE;
+#ifdef __Fuchsia__
+  zx_status_t status = _zx_vmo_set_size(output_file, size);
+  if (status != ZX_OK) {
+    fprintf(stderr, "profiling: failed to resize VMO: %s\n",
+            _zx_status_get_string(status));
+    return;
+  }
+#else
   write_buffer = realloc(write_buffer, size);
+#endif
   cur_buffer_size = size;
 }
 
 static void write_bytes(const char *s, size_t len) {
   resize_write_buffer(len);
   memcpy(&write_buffer[cur_pos], s, len);
   cur_pos += len;
 }

 static uint64_t read_64bit_value() {
   // GCOV uses a lo-/hi-word format even on big-endian systems.
   // See also GCOVBuffer::readInt64 in LLVM.
   uint32_t lo = read_32bit_value();
   uint32_t hi = read_32bit_value();
   return ((uint64_t)hi << 32) | ((uint64_t)lo);
 }
 
+#ifndef __Fuchsia__
 static char *mangle_filename(const char *orig_filename) {
   char *new_filename;
   size_t prefix_len;
   int prefix_strip;
   const char *prefix = lprofGetPathPrefix(&prefix_strip, &prefix_len);
 
   if (prefix == NULL)
     return strdup(orig_filename);
#if defined(_WIN32)
 
   write_buffer = MapViewOfFile(mmap_handle, FILE_MAP_WRITE, 0, 0, file_size);
   if (write_buffer == NULL) {
     fprintf(stderr, "profiling: %s: cannot map: %lu\n", filename,
             GetLastError());
     CloseHandle(mmap_handle);
     return -1;
   }
-#else
+#else /* _WIN32 */
   write_buffer = mmap(0, file_size, PROT_READ | PROT_WRITE,
                       MAP_FILE | MAP_SHARED, fd, 0);
   if (write_buffer == (void *)-1) {
     int errnum = errno;
     fprintf(stderr, "profiling: %s: cannot map: %s\n", filename,
             strerror(errnum));
     return -1;
   }
-#endif
+#endif /* _WIN32 */
 
   return 0;
 }
 
 static void unmap_file() {
 #if defined(_WIN32)
   if (!FlushViewOfFile(write_buffer, file_size)) {
     fprintf(stderr, "profiling: %s: cannot flush mapped view: %lu\n", filename,
             GetLastError());
   }
 
   if (!UnmapViewOfFile(write_buffer)) {
     fprintf(stderr, "profiling: %s: cannot unmap mapped view: %lu\n", filename,
             GetLastError());
   }
 
   if (!CloseHandle(mmap_handle)) {
     fprintf(stderr, "profiling: %s: cannot close file mapping handle: %lu\n",
             filename, GetLastError());
   }
 
   mmap_handle = NULL;
-#else
+#else /* _WIN32 */
   if (msync(write_buffer, file_size, MS_SYNC) == -1) {
     int errnum = errno;
     fprintf(stderr, "profiling: %s: cannot msync: %s\n", filename,
             strerror(errnum));
   }
 
   /* We explicitly ignore errors from unmapping because at this point the data
    * is written and we don't care.
    */
   (void)munmap(write_buffer, file_size);
-#endif
+#endif /* _WIN32 */
 
   write_buffer = NULL;
   file_size = 0;
 }
+#endif /* __Fuchsia__ */
 
 /*
  * --- LLVM line counter API ---
  */
 
 /* A file in this case is a translation unit. Each .o file built with line
  * profiling enabled will emit to a different file. Only one file may be
  * started at a time.
  */
 COMPILER_RT_VISIBILITY
 void llvm_gcda_start_file(const char *orig_filename, const char version[4],
                           uint32_t checksum) {
+#ifndef __Fuchsia__
   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) {
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);
     }
   }
+#else /* __Fuchsia__ */
+  /* Create VMO to hold the profile data. */
+  zx_status_t status = _zx_vmo_create(WRITE_BUFFER_SIZE, 0, &output_file);
+  if (status != ZX_OK) {
+    lprofReport("profiling: cannot create VMO: %s\n",
+                _zx_status_get_string(status));
+    return;
+  }
+
+  /* Get information about the current process. */
+  zx_info_handle_basic_t info;
+  status = _zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC, &info,
+                               sizeof(info), NULL, NULL);
+  if (status != ZX_OK) {
+    lprofReport("profiling: cannot get basic info about current process: %s\n",
+                _zx_status_get_string(status));
+    return;
+  }
+
+  /* Give the VMO a name including our process KOID so it's easy to spot. */
+  char name[ZX_MAX_NAME_LEN];
+  snprintf(name, sizeof(name), "%s.%" PRIu64, sink_name, info.koid);
+  _zx_object_set_property(output_file, ZX_PROP_NAME, name, strlen(name));
+  filename = strdup(name);
+
+  /* We map in the largest possible view into the VMO: one word
+   * for every possible 32-bit index value.  This avoids the need
+   * to change the mapping when increasing the size of the VMO.
+   * We can always spare the 32G of address space.
+   */
+  uintptr_t mapping;
+  status = _zx_vmar_map(_zx_vmar_root_self(), 0, output_file, 0, file_size,
+                        ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE, &mapping);
+  if (status != ZX_OK) {
+    lprofReport("profiling: cannot map VMAR: %s\n",
+                _zx_status_get_string(status));
+    return;
+  }
+
+  /* Initialize the write buffer. */
+  write_buffer = (unsigned char *)mapping;
+  cur_buffer_size = WRITE_BUFFER_SIZE;
+  cur_pos = 0;
+
+  /* Duplicate the handle since __sanitizer_publish_data consumes it. */
+  zx_handle_t handle;
+  status = _zx_handle_duplicate(output_file, ZX_RIGHT_SAME_RIGHTS, &handle);
+  if (status != ZX_OK) {
+    lprofReport("profiling: cannot duplicate VMO handle: %s\n",
+                _zx_status_get_string(status));
+    return;
+  }
+
+  /* Publish the VMO which contains profile data to the system. */
+  __sanitizer_publish_data(sink_name, handle);
+
+  /* Use the dumpfile symbolizer markup element to write the name of VMO. */
+  lprofReport("profile: {{{dumpfile:%s:%s}}}\n", sink_name, name);
+#endif /* __Fuchsia__ */
 
   /* 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_VISIBILITY
 void llvm_gcda_end_file() {
   /* Write out EOF record. */
   if (output_file) {
     write_bytes("\0\0\0\0\0\0\0\0", 8);
 
+#ifndef __Fuchsia__
     if (new_file) {
       fwrite(write_buffer, cur_pos, 1, output_file);
       free(write_buffer);
     } else {
       unmap_file();
     }
 
     fflush(output_file);
     lprofUnlockFd(fd);
     fclose(output_file);
     output_file = NULL;
     write_buffer = NULL;
+#else /* __Fuchsia__ */
+    zx_status_t status;
+    uintptr_t mapping = (uintptr_t)write_buffer;
+    status = _zx_vmar_unmap(_zx_vmar_root_self(), mapping, cur_buffer_size);
+    if (status != ZX_OK) {
+      lprofReport("profiling: failed to unmap VMAR: %s\n",
+                  _zx_status_get_string(status));
+      return;
+    }
+
+    status = _zx_handle_close(output_file);
+    if (status != ZX_OK) {
+      lprofReport("profiling: failed to close VMO: %s\n",
+                  _zx_status_get_string(status));
+      return;
+    }
+    output_file = ZX_HANDLE_INVALID;
+    write_buffer = NULL;
+#endif /* __Fuchsia__ */
   }
   free(filename);
 
 #ifdef DEBUG_GCDAPROFILING
   fprintf(stderr, "llvmgcda: -----\n");
 #endif
 }
 
if (atexit_ran == 0) {
     atexit_ran = 1;
 
     /* Make sure we write out the data and delete the data structures. */
     atexit(llvm_delete_flush_function_list);
     atexit(llvm_delete_writeout_function_list);
     atexit(llvm_writeout_files);
   }
 }
-
-#endif

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

 /* Current offset within the VMO where data should be written next. This symbol
  * has default visibility and is exported in each module (executable or DSO)
  * that statically links in the profiling runtime.
  */
 uint64_t __llvm_profile_offset;
 
 static const char ProfileSinkName[] = "llvm-profile";
 
-static inline void lprofWrite(const char *fmt, ...) {
-  char s[256];
-
-  va_list ap;
-  va_start(ap, fmt);
-  int ret = vsnprintf(s, sizeof(s), fmt, ap);
-  va_end(ap);
-
-  __sanitizer_log_write(s, ret + 1);
-}
-
 static uint32_t lprofVMOWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
                                uint32_t NumIOVecs) {
   /* Allocate VMO if it hasn't been created yet. */
   if (__llvm_profile_vmo == ZX_HANDLE_INVALID) {
     /* Get information about the current process. */
     zx_info_handle_basic_t Info;
     zx_status_t Status =
         _zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC, &Info,
Status =
         _zx_handle_duplicate(__llvm_profile_vmo, ZX_RIGHT_SAME_RIGHTS, &Handle);
     if (Status != ZX_OK)
       return -1;
 
     /* Publish the VMO which contains profile data to the system. */
     __sanitizer_publish_data(ProfileSinkName, Handle);
 
     /* Use the dumpfile symbolizer markup element to write the name of VMO. */
-    lprofWrite("LLVM Profile: {{{dumpfile:%s:%s}}}\n",
+    lproReport("LLVM Profile: {{{dumpfile:%s:%s}}}\n",
                ProfileSinkName, VmoName);
   }
 
   /* Compute the total length of data to be written. */
   size_t Length = 0;
   for (uint32_t I = 0; I < NumIOVecs; I++)
     Length += IOVecs[I].ElmSize * IOVecs[I].NumElm;
 

 
 static void initVMOWriter(ProfDataWriter *This) {
   This->Write = lprofVMOWriter;
   This->WriterCtx = NULL;
 }
 
 static int dump(void) {
   if (lprofProfileDumped()) {
-    lprofWrite("Profile data not published: already written.\n");
+    lprofReport("Profile data not published: already written.\n");
     return 0;
   }
 
   /* Check if there is llvm/runtime version mismatch. */
   if (GET_VERSION(__llvm_profile_get_version()) != INSTR_PROF_RAW_VERSION) {
-    lprofWrite("Runtime and instrumentation version mismatch : "
+    lprofReport("Runtime and instrumentation version mismatch : "
                 "expected %d, but got %d\n",
                 INSTR_PROF_RAW_VERSION,
                 (int)GET_VERSION(__llvm_profile_get_version()));
     return -1;
   }
 
   /* Write the profile data into the mapped region. */
   ProfDataWriter VMOWriter;
   initVMOWriter(&VMOWriter);
   if (lprofWriteData(&VMOWriter, lprofGetVPDataReader(), 0) != 0)
     return -1;

compiler-rt/lib/profile/InstrProfilingUtil.h

 /*===- InstrProfilingUtil.h - Support library for PGO instrumentation -----===*\
 |*
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 |* See https://llvm.org/LICENSE.txt for license information.
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 |*
 \*===----------------------------------------------------------------------===*/
 
 #ifndef PROFILE_INSTRPROFILINGUTIL_H
 #define PROFILE_INSTRPROFILINGUTIL_H
 
+#include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 
 /*! \brief Create a directory tree. */
 void __llvm_profile_recursive_mkdir(char *Pathname);
 
 /*! Set the mode used when creating profile directories. */
 void __llvm_profile_set_dir_mode(unsigned Mode);

 /* Temporarily suspend SIGKILL. Return value of 1 means a restore is needed.
  * Other return values mean no restore is needed.
  */
 int lprofSuspendSigKill();
 
 /* Restore previously suspended SIGKILL. */
 void lprofRestoreSigKill();
 
+#ifdef __Fuchsia__
+/* Write a formatted message to the system log. */
+void lprofReport(const char *fmt, ...);
+#endif
+
 #endif /* PROFILE_INSTRPROFILINGUTIL_H */

compiler-rt/lib/profile/InstrProfilingUtil.c

 #include <stdlib.h>
 #include <string.h>
 
 #if defined(__linux__)
 #include <signal.h>
 #include <sys/prctl.h>
 #endif
 
+#if defined(__Fuchsia__)
+#include <zircon/sanitizer.h>
+#endif
+
 #include "InstrProfiling.h"
 #include "InstrProfilingUtil.h"
 
 COMPILER_RT_WEAK unsigned lprofDirMode = 0755;
 
 COMPILER_RT_VISIBILITY
 void __llvm_profile_recursive_mkdir(char *path) {
   int i;

 #endif
 }
 
 COMPILER_RT_VISIBILITY void lprofRestoreSigKill() {
 #if defined(__linux__)
   prctl(PR_SET_PDEATHSIG, SIGKILL);
 #endif
 }
+
+#if defined(__Fuchsia__)
+COMPILER_RT_VISIBILITY void lprofReport(const char *fmt, ...) {
+  char s[256];
+
+  va_list ap;
+  va_start(ap, fmt);
+  int ret = vsnprintf(s, sizeof(s), fmt, ap);
+  va_end(ap);
+
+  __sanitizer_log_write(s, ret + 1);
+}
+#endif