[lsan] Add leak_check_at_exit flag.

[earthdok]

Summary

We needed a way to tell LSan to invoke leak checking only if __do_leak_check() is called explicitly.
This can now be achieved by setting leak_check_at_exit=false.

[samsonov]

Please add a test for this.

lib/sanitizer_common/sanitizer_flags.h

45

... if leak checking is disabled, or if ...

[earthdok]

• added a test which I forgot to commit the previous time

[samsonov]

LGTM

lib/lsan/lit_tests/TestCases/leak_check_at_exit.cc

12

Do you really need this printf here?

[earthdok]

lib/lsan/lit_tests/TestCases/leak_check_at_exit.cc

12

Somehow atexit handlers are not invoked if main is a no-op. I didn't investigate further.

[samsonov]

lib/lsan/lit_tests/TestCases/leak_check_at_exit.cc

12

That is, LSan wouldn't run leak checking if main() is empty? I think it's
worth investigating.

[earthdok]

lib/lsan/lit_tests/TestCases/leak_check_at_exit.cc

12

Ok, there are actually 2 separate issues here.

1. FileCheck barks at empty input (the last invocation, where we make sure that leak detection is not invoked, doesnt' produce any output).
2. Standalone LSan does not use preinit_array for initialization. Instead it initializes whenever an intercepted function is called for the first time. So if main() is a no-op, LSan will not print the "0 bytes leaked" line because we never call Init() (which is where the atexit handler is installed). This didn't matter before, because it used to be that no interceptors called = no leaks = no output. But now that we want to be able to print the summary even when no memory is leaked, this is no longer correct. Should probably fix that if only just to make it consistent with ASan.

[samsonov]

lib/lsan/lit_tests/TestCases/leak_check_at_exit.cc

12

Ah, I see. I won't bother with (2), as I assume LSan will surely initialize itself as soon as the first malloc() is called, so I don't think there's any reason in explicitly calling Init() somehow.

[earthdok]

lib/lsan/lit_tests/TestCases/leak_check_at_exit.cc

12

Unfortunately it could cause the atexit handler to be installed late, and there would be discrepancy between standalone and ASan tools.

lib/asan/asan_rtl.cc

void InitializeFlags(Flags *f, const char *env) {
   cf->symbolize = true;
   cf->malloc_context_size = kDefaultMallocContextSize;
   cf->fast_unwind_on_fatal = false;
   cf->fast_unwind_on_malloc = true;
   cf->strip_path_prefix = "";
   cf->handle_ioctl = false;
   cf->log_path = 0;
   cf->detect_leaks = false;
+  cf->leak_check_at_exit = true;
 
   internal_memset(f, 0, sizeof(*f));
   f->quarantine_size = (ASAN_LOW_MEMORY) ? 1UL << 26 : 1UL << 28;
   f->verbosity = 0;
   f->redzone = 16;
   f->debug = false;
   f->report_globals = 1;
   f->check_initialization_order = false;
u32 main_tid = asanThreadRegistry().CreateThread(
       0, true, 0, &create_main_args);
   CHECK_EQ(0, main_tid);
   SetCurrentThread(main_thread);
   main_thread->ThreadStart(internal_getpid());
   force_interface_symbols();  // no-op.
 
 #if CAN_SANITIZE_LEAKS
   __lsan::InitCommonLsan();
-  if (common_flags()->detect_leaks) {
+  if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit) {
     Atexit(__lsan::DoLeakCheck);
   }
 #endif  // CAN_SANITIZE_LEAKS
 
   if (flags()->verbosity) {
     Report("AddressSanitizer Init done\n");
   }
 }

lib/lsan/lit_tests/TestCases/leak_check_at_exit.cc

+// Test for the leak_check_at_exit flag.
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS="verbosity=1" %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
+// RUN: LSAN_OPTIONS="verbosity=1" %t 2>&1 | FileCheck %s --check-prefix=CHECK-do
+// RUN: LSAN_OPTIONS="verbosity=1:leak_check_at_exit=0" ASAN_OPTIONS="$ASAN_OPTIONS:leak_check_at_exit=0" %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
+// RUN: LSAN_OPTIONS="verbosity=1:leak_check_at_exit=0" ASAN_OPTIONS="$ASAN_OPTIONS:leak_check_at_exit=0" %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont
+
+#include <stdio.h>
+#include <sanitizer/lsan_interface.h>
+
+int main(int argc, char *argv[]) {
+  printf("printf to break optimization\n");
+  if (argc > 1)
+    __lsan_do_leak_check();
+  return 0;
+}
+
+// CHECK-do: SUMMARY: LeakSanitizer:
+// CHECK-dont-NOT: SUMMARY: LeakSanitizer:

lib/lsan/lsan.cc

static void InitializeCommonFlags() {
   CommonFlags *cf = common_flags();
   cf->external_symbolizer_path = GetEnv("LSAN_SYMBOLIZER_PATH");
   cf->symbolize = (cf->external_symbolizer_path &&
       cf->external_symbolizer_path[0]);
   cf->strip_path_prefix = "";
   cf->fast_unwind_on_malloc = true;
   cf->malloc_context_size = 30;
   cf->detect_leaks = true;
+  cf->leak_check_at_exit = true;
 
   ParseCommonFlagsFromString(GetEnv("LSAN_OPTIONS"));
 }
 
 void Init() {
   static bool inited;
   if (inited)
     return;
void Init() {
   // Start symbolizer process if necessary.
   const char* external_symbolizer = common_flags()->external_symbolizer_path;
   if (common_flags()->symbolize && external_symbolizer &&
       external_symbolizer[0]) {
     InitializeExternalSymbolizer(external_symbolizer);
   }
 
   InitCommonLsan();
+  if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit)
     Atexit(DoLeakCheck);
 }
 
 }  // namespace __lsan

lib/sanitizer_common/sanitizer_flags.h

struct CommonFlags {
   // Intercept and handle ioctl requests.
   bool handle_ioctl;
   // Max number of stack frames kept for each allocation/deallocation.
   int malloc_context_size;
   // Write logs to "log_path.pid" instead of stderr.
   const char *log_path;
   // Enable memory leak detection.
   bool detect_leaks;
+  // Invoke leak checking in an atexit handler. Has no effect if
+  // detect_leaks=false, or if __lsan_do_leak_check() is called before the
+  // handler has a chance to run.
+  bool leak_check_at_exit;
 };
 
 extern CommonFlags common_flags_dont_use_directly;
 
 inline CommonFlags *common_flags() {
   return &common_flags_dont_use_directly;
 }
 
 void ParseCommonFlagsFromString(const char *str);
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FLAGS_H

lib/sanitizer_common/sanitizer_flags.cc

void ParseCommonFlagsFromString(const char *str) {
   ParseFlag(str, &f->malloc_context_size, "malloc_context_size");
   ParseFlag(str, &f->strip_path_prefix, "strip_path_prefix");
   ParseFlag(str, &f->fast_unwind_on_fatal, "fast_unwind_on_fatal");
   ParseFlag(str, &f->fast_unwind_on_malloc, "fast_unwind_on_malloc");
   ParseFlag(str, &f->symbolize, "symbolize");
   ParseFlag(str, &f->handle_ioctl, "handle_ioctl");
   ParseFlag(str, &f->log_path, "log_path");
   ParseFlag(str, &f->detect_leaks, "detect_leaks");
+  ParseFlag(str, &f->leak_check_at_exit, "leak_check_at_exit");
 }
 
 static bool GetFlagValue(const char *env, const char *name,
                          const char **value, int *value_length) {
   if (env == 0)
     return false;
   const char *pos = 0;
   for (;;) {