Set up ability to use RADSAN_OPTIONS, move RADSAN_ERROR_MODE to this new variable as a test

compiler-rt/lib/radsan/CMakeLists.txt

@@ -13,6 +13,8 @@ set(RADSAN_PREINIT_SOURCES
 set(RADSAN_HEADERS
   radsan.h
   radsan_context.h
+  radsan_flags.h
+  radsdan_flags.inc
   radsan_stack.h)
 
 set(RADSAN_DEPS)

compiler-rt/lib/radsan/radsan.cpp

@@ -7,26 +7,127 @@
 */
 
 #include <radsan/radsan.h>
+
 #include <radsan/radsan_context.h>
+#include <radsan/radsan_flags.h>
 #include <radsan/radsan_interceptors.h>
-#include <unistd.h>
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_flags.h"
+
+using namespace __sanitizer;
+
+namespace radsan {
+static __sanitizer::atomic_uint8_t radsan_inited{};
+static Mutex radsan_init_mutex{};
+static Flags radsan_flags{};
+
+Flags *flags() { return &radsan_flags; }
+
+
+SANITIZER_INTERFACE_WEAK_DEF(const char *, __radsan_default_options, void) {
+  return "";
+}
+
+
+static void RegisterRadsanFlags(FlagParser *parser, Flags *f) {
+#define RADSAN_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "radsan_flags.inc"
+#undef RADSAN_FLAG
+}
+
+void Flags::SetDefaults() {
+#define RADSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "radsan_flags.inc"
+#undef RADSAN_FLAG
+}
+
+
+static void initializeFlags() {
+  SetCommonFlagsDefaults();
+  {
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.stack_trace_format = "DEFAULT";
+    cf.external_symbolizer_path = GetEnv("RADSAN_SYMBOLIZER_PATH");
+    OverrideCommonFlags(cf);
+  }
+
+  Flags *f = flags();
+  f->SetDefaults();
+
+  FlagParser parser;
+  RegisterRadsanFlags(&parser, f);
+  RegisterCommonFlags(&parser);
+
+  // Override from user-specified string.
+  parser.ParseString(__radsan_default_options());
+
+  parser.ParseStringFromEnv("RADSAN_OPTIONS");
+
+  InitializeCommonFlags();
+
+  if (Verbosity()) ReportUnrecognizedFlags();
+
+  if (common_flags()->help) 
+  {
+    parser.PrintFlagDescriptions();
+  }
+}
+
+} // namespace radsan
 
 extern "C" {
-RADSAN_EXPORT void radsan_init() { radsan::initialiseInterceptors(); }
 
-RADSAN_EXPORT void radsan_realtime_enter() {
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_ensure_initialized() {
+  // Double-checked locking.
+  // Ensure that radsan_init() is called only once by the first thread
+  // that gets here.
+
+  if (radsan_is_initialized()) 
+    return;
+
+  Lock lock(&radsan::radsan_init_mutex);
+
+  if (radsan_is_initialized()) 
+    return;
+
+  radsan_init();
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE bool radsan_is_initialized() {
+  return __sanitizer::atomic_load(&radsan::radsan_inited, memory_order_acquire) == 1; 
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_init() {
+  using namespace radsan;
+
+  if (radsan_is_initialized()) return;
+
+  SanitizerToolName = "RealtimeSanitizer";
+
+  initializeFlags();
+  initialiseInterceptors(); 
+
+  __sanitizer::atomic_store(&radsan_inited, 1, memory_order_release);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter() {
   radsan::getContextForThisThread().realtimePush();
 }
 
-RADSAN_EXPORT void radsan_realtime_exit() {
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_exit() {
   radsan::getContextForThisThread().realtimePop();
 }
 
-RADSAN_EXPORT void radsan_off() {
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_off() {
   radsan::getContextForThisThread().bypassPush();
 }
 
-RADSAN_EXPORT void radsan_on() {
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_on() {
   radsan::getContextForThisThread().bypassPop();
 }
 }

compiler-rt/lib/radsan/radsan.h

@@ -8,17 +8,31 @@
 
 #pragma once
 
-#define RADSAN_EXPORT __attribute__((visibility("default")))
+#include "sanitizer_common/sanitizer_internal_defs.h"
 
 extern "C" {
 
+/** Ensure RADSan is initialized.
+
+    This method ensures the first thread to call it will initialize RADSan.
+    Any subsequent calls will be no-ops.
+*/
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_ensure_initialized();
+
+/** Check if RADSan is initialized.
+
+    @return true if RADSan is initialized, false otherwise.
+*/
+SANITIZER_INTERFACE_ATTRIBUTE bool radsan_is_initialized();
+
 /**
-    Initialise radsan interceptors. A call to this method is added to the
-    preinit array on Linux systems.
+    Initialise radsan interceptors and other flags. A call to this method is added to the
+    preinit array on Linux systems. On non-linux systems this must be called explicitly 
+    before other radsan methods.
 
-    @warning Do not call this method as a user.
+    @warning Do not call this method as a user. See radsan_ensure_initialized() instead.
 */
-RADSAN_EXPORT void radsan_init();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_init();
 
 /** Enter real-time context.
 
@@ -28,7 +42,7 @@ RADSAN_EXPORT void radsan_init();
 
     @warning Do not call this method as a user
 */
-RADSAN_EXPORT void radsan_realtime_enter();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter();
 
 /** Exit the real-time context.
 
@@ -37,7 +51,7 @@ RADSAN_EXPORT void radsan_realtime_enter();
 
     @warning Do not call this method as a user
 */
-RADSAN_EXPORT void radsan_realtime_exit();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_exit();
 
 /** Disable all RADSan error reporting.
 
@@ -62,12 +76,13 @@ RADSAN_EXPORT void radsan_realtime_exit();
         }
 
 */
-RADSAN_EXPORT void radsan_off();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_off();
 
 /** Re-enable all RADSan error reporting.
 
     The counterpart to `radsan_off`. See the description for `radsan_off` for
     details about how to use this method.
 */
-RADSAN_EXPORT void radsan_on();
-}
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_on();
+
+} // extern "C"

compiler-rt/lib/radsan/radsan_context.cpp

@@ -6,6 +6,7 @@
     Subject to GNU General Public License (GPL) v3.0
 */
 
+#include "radsan.h"
 #include <radsan/radsan_context.h>
 
 #include <radsan/radsan_stack.h>
@@ -25,10 +26,21 @@ static pthread_key_t key;
 static pthread_once_t key_once = PTHREAD_ONCE_INIT;
 void internalFree(void *ptr) { InternalFree(ptr); }
 
+static __sanitizer::atomic_uint64_t radsan_report_count{};
+
+void IncrementReportCount();
 } // namespace detail
 
 namespace radsan {
 
+__sanitizer::u64 GetReportCount() { 
+  return __sanitizer::atomic_load(&detail::radsan_report_count, memory_order_acquire); 
+}
+
+void IncrementReportCount() { 
+  __sanitizer::atomic_fetch_add(&detail::radsan_report_count, 1, memory_order_relaxed); 
+}
+
 Context::Context() : Context(createErrorActionGetter()) {}
 
 Context::Context(std::function<OnErrorAction()> get_error_action)
@@ -43,11 +55,12 @@ void Context::bypassPush() { bypass_depth_++; }
 void Context::bypassPop() { bypass_depth_--; }
 
 void Context::expectNotRealtime(const char *intercepted_function_name) {
+  CHECK(radsan_is_initialized());
   if (inRealtimeContext() && !isBypassed()) {
     bypassPush();
     printDiagnostics(intercepted_function_name);
     if (get_error_action_() == OnErrorAction::ExitWithFailure) {
-      exit(EXIT_FAILURE);
+      exit(common_flags()->exitcode);
     }
     bypassPop();
   }
@@ -62,6 +75,8 @@ void Context::printDiagnostics(const char *intercepted_function_name) {
           "Real-time violation: intercepted call to real-time unsafe function "
           "`%s` in real-time context! Stack trace:\n",
           intercepted_function_name);
+
+  radsan::IncrementReportCount();
   radsan::printStackTrace();
 }
 

compiler-rt/lib/radsan/radsan_context.h

@@ -9,11 +9,14 @@
 #pragma once
 
 #include <radsan/radsan_user_interface.h>
+#include "sanitizer_common/sanitizer_common.h"
 
 #include <functional>
 
 namespace radsan {
 
+__sanitizer::u64 GetReportCount();
+
 class Context {
 public:
   Context();

compiler-rt/lib/radsan/radsan_flags.h

@@ -0,0 +1,29 @@
+//===-- radsan_flags.h --------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of RealtimeSanitizer.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RADSAN_FLAGS_H
+#define RADSAN_FLAGS_H
+
+namespace radsan {
+
+struct Flags {
+#define RADSAN_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "radsan_flags.inc"
+#undef RADSAN_FLAG
+
+  void SetDefaults();
+};
+
+Flags *flags();
+
+}  // namespace radsan
+
+#endif  // RADSAN_FLAGS_H

compiler-rt/lib/radsan/radsan_flags.inc

@@ -0,0 +1,19 @@
+//===-- radsan_flags.inc ------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// RadSan runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef RADSAN_FLAG
+# error "Define RADSAN_FLAG prior to including this file!"
+#endif
+
+// RADSAN_FLAG(Type, Name, DefaultValue, Description)
+// See COMMON_FLAG in sanitizer_flags.inc for more details.
+
+RADSAN_FLAG(const char*, error_mode, "exit", "Error mode: [continue|interactive|exit].")

compiler-rt/lib/radsan/radsan_interceptors.cpp

@@ -13,6 +13,7 @@
 
 #include "interception/interception.h"
 #include "radsan/radsan_context.h"
+#include "radsan/radsan.h"
 
 #if !SANITIZER_LINUX && !SANITIZER_APPLE
 #error Sorry, radsan does not yet support this platform
@@ -39,6 +40,8 @@ using namespace __sanitizer;
 
 namespace radsan {
 void expectNotRealtime(const char *intercepted_function_name) {
+  radsan_ensure_initialized();
+
   getContextForThisThread().expectNotRealtime(intercepted_function_name);
 }
 } // namespace radsan

compiler-rt/lib/radsan/radsan_preinit.cpp

@@ -16,6 +16,6 @@
 // This code is linked into the main executable when -fsanitize=realtime is in
 // the link flags. It can only use exported interface functions.
 __attribute__((section(".preinit_array"), used))
-void (*__local_radsan_preinit)(void) = radsan_init;
+void (*__local_radsan_preinit)(void) = radsan::radsan_init;
 
 #endif

compiler-rt/lib/radsan/radsan_stack.cpp

@@ -25,17 +25,6 @@ void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
 }
 } // namespace __sanitizer
 
-namespace {
-void setGlobalStackTraceFormat() {
-  SetCommonFlagsDefaults();
-  CommonFlags cf;
-  cf.CopyFrom(*common_flags());
-  cf.stack_trace_format = "DEFAULT";
-  cf.external_symbolizer_path = GetEnv("RADSAN_SYMBOLIZER_PATH");
-  OverrideCommonFlags(cf);
-}
-} // namespace
-
 namespace radsan {
 void printStackTrace() {
 
@@ -44,7 +33,6 @@ void printStackTrace() {
   GET_CURRENT_PC_BP;
   stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal);
 
-  setGlobalStackTraceFormat();
   stack.Print();
 }
 } // namespace radsan