[sanitizer_common] Add facility to get the full report path

[tejohnson]

Summary

Add a new interface sanitizer_get_report_path which will return the
full path to the report file if sanitizer_set_report_path was
previously called (otherwise it returns null). This is useful in
particular for memory profiling handlers to access the path which
was specified at compile time (and passed down via
__memprof_profile_filename), including the pid added to the path when
the file is opened.

There wasn't a test for __sanitizer_set_report_path, so I added one
which additionally tests the new interface.

[vitalybuka]

It mentions the test, but it's not here

compiler-rt/lib/sanitizer_common/sanitizer_file.cpp

100

why reopen is needed?

[tejohnson]

Add the test

[tejohnson]

In D91765#2404679, @vitalybuka wrote:

It mentions the test, but it's not here

Woops, forgot to git add it. It's there now.

compiler-rt/lib/sanitizer_common/sanitizer_file.cpp

100

Because the actual full_path (with pid suffix) is populated only on open.

[vitalybuka]

LGTM with /tmp/ fix

compiler-rt/test/sanitizer_common/TestCases/Posix/sanitizer_set_report_path_test.cpp

12

it should not work on android

maybe this without FileCHeck?
sprintf(buff, "%s.report_path", arg[0]);
sanitizer_set_report_path(buff);
assert(strncmp(buff, sanitizer_get_report_path(), strlen(buff)) == 0)

[vitalybuka]

BTW mktemp should work, but build dir from arg[0] looks better

[tejohnson]

compiler-rt/test/sanitizer_common/TestCases/Posix/sanitizer_set_report_path_test.cpp

12

Good idea. But the assert won't work, because a ".${pid}" suffix will get added. But I can do a partial match using FileCheck.

[tejohnson]

Fix test to avoid using /tmp

[vitalybuka]

compiler-rt/test/sanitizer_common/TestCases/Posix/sanitizer_set_report_path_test.cpp

12

Hm, here we suppose to match only strlen(buff) first byte
assert(strncmp(buff, sanitizer_get_report_path(), strlen(buff)) == 0)

either ways is fine

[tejohnson]

compiler-rt/test/sanitizer_common/TestCases/Posix/sanitizer_set_report_path_test.cpp

12

Ah yeah, you're right. I'll add the assert in as well before I submit tomorrow.

[tejohnson]

Beef up test as suggested to check the full path via an assert

compiler-rt/include/sanitizer/common_interface_defs.h

typedef struct {
   unsigned int coverage_max_block_size;
 } __sanitizer_sandbox_arguments;
 
 // Tell the tools to write their reports to "path.<pid>" instead of stderr.
 void __sanitizer_set_report_path(const char *path);
 // Tell the tools to write their reports to the provided file descriptor
 // (casted to void *).
 void __sanitizer_set_report_fd(void *fd);
+// Get the current full report file path, if a path was specified by
+// an earlier call to __sanitizer_set_report_path. Returns null otherwise.
+const char *__sanitizer_get_report_path();
 
 // Notify the tools that the sandbox is going to be turned on. The reserved
 // parameter will be used in the future to hold a structure with functions
 // that the tools may call to bypass the sandbox.
 void __sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args);
 
 // This function is called by the tool when it has just finished reporting
 // an error. 'error_summary' is a one-line string that summarizes

compiler-rt/lib/sanitizer_common/sanitizer_common_interface.inc

 //===-- sanitizer_common_interface.inc ------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 // Sanitizer Common interface list.
 //===----------------------------------------------------------------------===//
 INTERFACE_FUNCTION(__sanitizer_acquire_crash_state)
 INTERFACE_FUNCTION(__sanitizer_annotate_contiguous_container)
 INTERFACE_FUNCTION(__sanitizer_contiguous_container_find_bad_address)
 INTERFACE_FUNCTION(__sanitizer_set_death_callback)
 INTERFACE_FUNCTION(__sanitizer_set_report_path)
 INTERFACE_FUNCTION(__sanitizer_set_report_fd)
+INTERFACE_FUNCTION(__sanitizer_get_report_path)
 INTERFACE_FUNCTION(__sanitizer_verify_contiguous_container)
 INTERFACE_WEAK_FUNCTION(__sanitizer_on_print)
 INTERFACE_WEAK_FUNCTION(__sanitizer_report_error_summary)
 INTERFACE_WEAK_FUNCTION(__sanitizer_sandbox_on_notify)
 // Sanitizer weak hooks
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_memcmp)
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_strcmp)
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_strncmp)

compiler-rt/lib/sanitizer_common/sanitizer_file.h

 #include "sanitizer_mutex.h"
 
 namespace __sanitizer {
 
 struct ReportFile {
   void Write(const char *buffer, uptr length);
   bool SupportsColors();
   void SetReportPath(const char *path);
+  const char *GetReportPath();
 
   // Don't use fields directly. They are only declared public to allow
   // aggregate initialization.
 
   // Protects fields below.
   StaticSpinMutex *mu;
   // Opened file descriptor. Defaults to stderr. It may be equal to
   // kInvalidFd, in which case new file will be opened when necessary.
   fd_t fd;
   // Path prefix of report file, set via __sanitizer_set_report_path.
   char path_prefix[kMaxPathLength];
   // Full path to report, obtained as <path_prefix>.PID
   char full_path[kMaxPathLength];
   // PID of the process that opened fd. If a fork() occurs,
   // the PID of child will be different from fd_pid.
   uptr fd_pid;
 
  private:
   void ReopenIfNecessary();
 };
 extern ReportFile report_file;

compiler-rt/lib/sanitizer_common/sanitizer_file.cpp

if (!path || internal_strcmp(path, "stderr") == 0) {
     fd = kStderrFd;
   } else if (internal_strcmp(path, "stdout") == 0) {
     fd = kStdoutFd;
   } else {
     internal_snprintf(path_prefix, kMaxPathLength, "%s", path);
   }
 }
 
+const char *ReportFile::GetReportPath() {
+  SpinMutexLock l(mu);
+  ReopenIfNecessary();
+  return full_path;
+}
+
 bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
                       uptr *read_len, uptr max_len, error_t *errno_p) {
   *buff = nullptr;
   *buff_size = 0;
   *read_len = 0;
   if (!max_len)
     return true;
   uptr PageSize = GetPageSizeCached();

 void __sanitizer_set_report_path(const char *path) {
   report_file.SetReportPath(path);
 }
 
 void __sanitizer_set_report_fd(void *fd) {
   report_file.fd = (fd_t)reinterpret_cast<uptr>(fd);
   report_file.fd_pid = internal_getpid();
 }
+
+const char *__sanitizer_get_report_path() {
+  return report_file.GetReportPath();
+}
 } // extern "C"
 
 #endif  // !SANITIZER_FUCHSIA

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cpp

void __sanitizer_set_report_path(const char *path) {
   // Handle the initialization code in each sanitizer, but no other calls.
   // This setting is never consulted on Fuchsia.
   DCHECK_EQ(path, common_flags()->log_path);
 }
 
 void __sanitizer_set_report_fd(void *fd) {
   UNREACHABLE("not available on Fuchsia");
 }
+
+const char *__sanitizer_get_report_path() {
+  UNREACHABLE("not available on Fuchsia");
+}
 }  // extern "C"
 
 #endif  // SANITIZER_FUCHSIA

compiler-rt/lib/sanitizer_common/sanitizer_interface_internal.h

extern "C" {
   // Tell the tools to write their reports to "path.<pid>" instead of stderr.
   // The special values are "stdout" and "stderr".
   SANITIZER_INTERFACE_ATTRIBUTE
   void __sanitizer_set_report_path(const char *path);
   // Tell the tools to write their reports to the provided file descriptor
   // (casted to void *).
   SANITIZER_INTERFACE_ATTRIBUTE
   void __sanitizer_set_report_fd(void *fd);
+  // Get the current full report file path, if a path was specified by
+  // an earlier call to __sanitizer_set_report_path. Returns null otherwise.
+  SANITIZER_INTERFACE_ATTRIBUTE
+  const char *__sanitizer_get_report_path();
 
   typedef struct {
       int coverage_sandboxed;
       __sanitizer::sptr coverage_fd;
       unsigned int coverage_max_block_size;
   } __sanitizer_sandbox_arguments;
 
   // Notify the tools that the sandbox is going to be turned on.

compiler-rt/test/sanitizer_common/TestCases/Posix/sanitizer_set_report_path_test.cpp

+// Test __sanitizer_set_report_path and __sanitizer_get_report_path:
+// RUN: %clangxx -O2 %s -o %t
+// RUN: %run %t | FileCheck %s
+
+#include <assert.h>
+#include <sanitizer/common_interface_defs.h>
+#include <stdio.h>
+#include <string.h>
+
+volatile int *null = 0;
+
+int main(int argc, char **argv) {
+  char buff[1000];
+  sprintf(buff, "%s.report_path", argv[0]);
+  __sanitizer_set_report_path(buff);
+  assert(strncmp(buff, __sanitizer_get_report_path(), strlen(buff)) == 0);
+  printf("Path %s\n", __sanitizer_get_report_path());
+}
+
+// CHECK: Path {{.*}}Posix/Output/sanitizer_set_report_path_test.cpp.tmp.report_path.