tsan/msan: add halt_on_error flag

[dvyukov]

Summary

If halt_on_error==true, program terminates after reporting first error.

[samsonov]

Can we make halt_on_error a common sanitizer flag and use it in all three tools?

[eugenis]

LGTM, but please add a few RUN: lines with the new flag name to msan/lit_tests/keep-going.cc

[Eugene.Zelenko]

Committed in r188279.

msan/msan.cc

 static void ParseFlagsFromString(Flags *f, const char *str) {
   ParseCommonFlagsFromString(str);
   ParseFlag(str, &f->poison_heap_with_zeroes, "poison_heap_with_zeroes");
   ParseFlag(str, &f->poison_stack_with_zeroes, "poison_stack_with_zeroes");
   ParseFlag(str, &f->poison_in_malloc, "poison_in_malloc");
   ParseFlag(str, &f->exit_code, "exit_code");
   if (f->exit_code < 0 || f->exit_code > 127) {
     Printf("Exit code not in [0, 128) range: %d\n", f->exit_code);
-    f->exit_code = 1;
     Die();
   }
   ParseFlag(str, &f->report_umrs, "report_umrs");
   ParseFlag(str, &f->verbosity, "verbosity");
   ParseFlag(str, &f->wrap_signals, "wrap_signals");
-  ParseFlag(str, &f->keep_going, "keep_going");
+
+  // keep_going is an old name for halt_on_error,
+  // and it has inverse meaning.
+  f->halt_on_error = !f->halt_on_error;
+  ParseFlag(str, &f->halt_on_error, "keep_going");
+  f->halt_on_error = !f->halt_on_error;
+  ParseFlag(str, &f->halt_on_error, "halt_on_error");
 }
 
 static void InitializeFlags(Flags *f, const char *options) {
   CommonFlags *cf = common_flags();
   cf->external_symbolizer_path = GetEnv("MSAN_SYMBOLIZER_PATH");
   cf->strip_path_prefix = "";
   cf->fast_unwind_on_fatal = false;
   cf->fast_unwind_on_malloc = true;
   cf->malloc_context_size = 20;
   cf->handle_ioctl = true;
   cf->log_path = 0;
 
   internal_memset(f, 0, sizeof(*f));
   f->poison_heap_with_zeroes = false;
   f->poison_stack_with_zeroes = false;
   f->poison_in_malloc = true;
   f->exit_code = 77;
   f->report_umrs = true;
   f->verbosity = 0;
   f->wrap_signals = true;
-  f->keep_going = !!&__msan_keep_going;
+  f->halt_on_error = !&__msan_keep_going;
 
   // Override from user-specified string.
   if (__msan_default_options)
     ParseFlagsFromString(f, __msan_default_options());
   ParseFlagsFromString(f, options);
 }
 
 static void GetCurrentStackBounds(uptr *stack_top, uptr *stack_bottom) {

 // Interface.
 
 using namespace __msan;
 
 void __msan_warning() {
   GET_CALLER_PC_BP_SP;
   (void)sp;
   PrintWarning(pc, bp);
-  if (!__msan::flags()->keep_going) {
+  if (__msan::flags()->halt_on_error) {
     Printf("Exiting\n");
     Die();
   }
 }
 
 void __msan_warning_noreturn() {
   GET_CALLER_PC_BP_SP;
   (void)sp;
void __msan_init() {
   msan_inited = 1;
 }
 
 void __msan_set_exit_code(int exit_code) {
   flags()->exit_code = exit_code;
 }
 
 void __msan_set_keep_going(int keep_going) {
-  flags()->keep_going = keep_going;
+  flags()->halt_on_error = !keep_going;
 }
 
 void __msan_set_expect_umr(int expect_umr) {
   if (expect_umr) {
     msan_expected_umr_found = 0;
   } else if (!msan_expected_umr_found) {
     GET_CALLER_PC_BP_SP;
     (void)sp;

msan/msan_flags.h

 struct Flags {
   int exit_code;
   int verbosity;
   bool poison_heap_with_zeroes;  // default: false
   bool poison_stack_with_zeroes;  // default: false
   bool poison_in_malloc;  // default: true
   bool report_umrs;
   bool wrap_signals;
-  bool keep_going;
+  bool halt_on_error;
 };
 
 Flags *flags();
 
 }  // namespace __msan
 
 #endif  // MSAN_FLAGS_H

msan/msan_interceptors.cc

do {                                                                       \
     if (__msan::IsInSymbolizer()) break;                                     \
     if (offset >= 0 && __msan::flags()->report_umrs) {                       \
       GET_CALLER_PC_BP_SP;                                                   \
       (void) sp;                                                             \
       Printf("UMR in %s at offset %d inside [%p, +%d) \n", __FUNCTION__,     \
              offset, x, n);                                                  \
       __msan::PrintWarningWithOrigin(pc, bp,                                 \
                                      __msan_get_origin((char *)x + offset)); \
-      if (!__msan::flags()->keep_going) {                                    \
+      if (__msan::flags()->halt_on_error) {                                  \
         Printf("Exiting\n");                                                 \
         Die();                                                               \
       }                                                                      \
     }                                                                        \
   } while (0)
 
 // Check that [x, x+n) range is unpoisoned unless we are in a nested
 // interceptor.

tsan/check_cmake.sh

 #!/bin/bash
 set -u
 set -e
 
 ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 mkdir -p $ROOT/build
 cd $ROOT/build
 CC=clang CXX=clang++ cmake -DLLVM_ENABLE_WERROR=ON -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=ON $ROOT/../../../..
 make -j64
 make check-sanitizer -j64
 make check-tsan -j64
 make check-asan -j64
+make check-msan -j64

tsan/lit_tests/halt_on_error.cc

+// RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS halt_on_error=1" not %t 2>&1 | FileCheck %s
+#include <pthread.h>
+#include <stdio.h>
+
+int X;
+
+void *Thread(void *x) {
+  X = 42;
+  return 0;
+}
+
+int main() {
+  fprintf(stderr, "BEFORE\n");
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  X = 43;
+  pthread_join(t, 0);
+  fprintf(stderr, "AFTER\n");
+  return 0;
+}
+
+// CHECK: BEFORE
+// CHECK: WARNING: ThreadSanitizer: data race
+// CHECK-NOT: AFTER
+

tsan/rtl/tsan_flags.h

struct Flags {
   // Suppressions filename.
   const char *suppressions;
   // Print matched suppressions at exit.
   bool print_suppressions;
   // Print matched "benign" races at exit.
   bool print_benign;
   // Override exit status if something was reported.
   int exitcode;
+  // Exit after first reported error.
+  bool halt_on_error;
   // Write logs to "log_path.pid".
   // The special values are "stdout" and "stderr".
   // The default is "stderr".
   const char *log_path;
   // Sleep in main thread before exiting for that many ms
   // (useful to catch "at exit" races).
   int atexit_sleep_ms;
   // Verbosity level (0 - silent, 1 - a bit of output, 2+ - more output).

tsan/rtl/tsan_flags.cc

void InitializeFlags(Flags *f, const char *env) {
   f->report_signal_unsafe = true;
   f->report_atomic_races = true;
   f->force_seq_cst_atomics = false;
   f->strip_path_prefix = "";
   f->suppressions = "";
   f->print_suppressions = false;
   f->print_benign = false;
   f->exitcode = 66;
+  f->halt_on_error = false;
   f->log_path = "stderr";
   f->atexit_sleep_ms = 1000;
   f->verbosity = 0;
   f->profile_memory = "";
   f->flush_memory_ms = 0;
   f->flush_symbolizer_ms = 5000;
   f->stop_on_start = false;
   f->running_on_valgrind = false;
void InitializeFlags(Flags *f, const char *env) {
   ParseFlag(env, &f->report_signal_unsafe, "report_signal_unsafe");
   ParseFlag(env, &f->report_atomic_races, "report_atomic_races");
   ParseFlag(env, &f->force_seq_cst_atomics, "force_seq_cst_atomics");
   ParseFlag(env, &f->strip_path_prefix, "strip_path_prefix");
   ParseFlag(env, &f->suppressions, "suppressions");
   ParseFlag(env, &f->print_suppressions, "print_suppressions");
   ParseFlag(env, &f->print_benign, "print_benign");
   ParseFlag(env, &f->exitcode, "exitcode");
+  ParseFlag(env, &f->halt_on_error, "halt_on_error");
   ParseFlag(env, &f->log_path, "log_path");
   ParseFlag(env, &f->atexit_sleep_ms, "atexit_sleep_ms");
   ParseFlag(env, &f->verbosity, "verbosity");
   ParseFlag(env, &f->profile_memory, "profile_memory");
   ParseFlag(env, &f->flush_memory_ms, "flush_memory_ms");
   ParseFlag(env, &f->flush_symbolizer_ms, "flush_symbolizer_ms");
   ParseFlag(env, &f->stop_on_start, "stop_on_start");
   ParseFlag(env, &f->external_symbolizer_path, "external_symbolizer_path");

tsan/rtl/tsan_rtl_report.cc

if (suppress_pc == 0)
     suppress_pc = IsSuppressed(rep->typ, suppress_loc, &supp);
   if (suppress_pc != 0) {
     FiredSuppression s = {srep.GetReport()->typ, suppress_pc, supp};
     ctx->fired_suppressions.push_back(s);
   }
   if (OnReport(rep, suppress_pc != 0))
     return false;
   PrintReport(rep);
-  CTX()->nreported++;
+  ctx->nreported++;
+  if (flags()->halt_on_error)
+    internal__exit(flags()->exitcode);
   return true;
 }
 
 bool IsFiredSuppression(Context *ctx,
                         const ScopedReport &srep,
                         const StackTrace &trace) {
   for (uptr k = 0; k < ctx->fired_suppressions.size(); k++) {
     if (ctx->fired_suppressions[k].type != srep.GetReport()->typ)