[sanitizer] Add a variant of "include" flag that does not abort on missing file and support process name substitution.

[eugenis]

Summary

include_if_exists=/path/to/asan/options reads flags from the file if it is present.
"%b" in the include file path (for both variants of the flag) is replaced with the basename of the main executable.

[samsonov]

LGTM

lib/sanitizer_common/sanitizer_flags.cc

88

I would be prefer smth. more verbose like "optional_include", but this is optional.

[samsonov]

lib/sanitizer_common/sanitizer_flags.cc

48

Add a comment that out should be at least kMaxPathLength. Also, you don't seem to actually trim s to this. constant if necessary. Consider using InternalScopedString *out and out->append() instead.

55

if base was trimmed, you would advance pointer t too far, and may make an out-of-bound write on the next iteration.

[eugenis]

Renamed the option to a more obvious name.
Do you think we should change "%b" to something else? "b" stands for basename (as in man 1 basename). Maybe %n?

[samsonov]

I have no strong preference. %b looks okay.

[eugenis]

fixed oob issues

[samsonov]

LGTM

[eugenis]

Thanks. Committed as r242853.

lib/asan/asan_activation.cc

 #define ASAN_ACTIVATION_FLAG(Type, Name) \
   RegisterFlag(parser, #Name, "", &f->Name);
 #define COMMON_ACTIVATION_FLAG(Type, Name) \
   RegisterFlag(parser, #Name, "", &cf->Name);
 #include "asan_activation_flags.inc"
 #undef ASAN_ACTIVATION_FLAG
 #undef COMMON_ACTIVATION_FLAG
 
-    RegisterIncludeFlag(parser, cf);
+    RegisterIncludeFlags(parser, cf);
   }
 
   void OverrideFromActivationFlags() {
     Flags f;
     CommonFlags cf;
     FlagParser parser;
     RegisterActivationFlags(&parser, &f, &cf);
 

lib/asan/asan_rtl.cc

 }
 
 static void AsanInitInternal() {
   if (LIKELY(asan_inited)) return;
   SanitizerToolName = "AddressSanitizer";
   CHECK(!asan_init_is_running && "ASan init calls itself!");
   asan_init_is_running = true;
 
+  CacheBinaryName();
+
   // Initialize flags. This must be done early, because most of the
   // initialization steps look at flags().
   InitializeFlags();
 
-  CacheBinaryName();
-
   AsanCheckIncompatibleRT();
   AsanCheckDynamicRTPrereqs();
 
   SetCanPoisonMemory(flags()->poison_heap);
   SetMallocContextSize(common_flags()->malloc_context_size);
 
   InitializeHighMemEnd();
 

lib/lsan/lsan.cc

 }
 
 extern "C" void __lsan_init() {
   CHECK(!lsan_init_is_running);
   if (lsan_inited)
     return;
   lsan_init_is_running = true;
   SanitizerToolName = "LeakSanitizer";
+  CacheBinaryName();
   InitializeFlags();
   InitCommonLsan();
   InitializeAllocator();
   InitTlsSize();
   InitializeInterceptors();
   InitializeThreadRegistry();
   u32 tid = ThreadCreate(0, 0, true);
   CHECK_EQ(tid, 0);

lib/msan/msan.cc

void __msan_init() {
   CHECK(!msan_init_is_running);
   if (msan_inited) return;
   msan_init_is_running = 1;
   SanitizerToolName = "MemorySanitizer";
 
   SetDieCallback(MsanDie);
   InitTlsSize();
 
-  InitializeFlags();
   CacheBinaryName();
+  InitializeFlags();
   __sanitizer_set_report_path(common_flags()->log_path);
 
   InitializeInterceptors();
   InstallAtExitHandler(); // Needs __cxa_atexit interceptor.
 
   DisableCoreDumperIfNecessary();
   if (StackSizeIsUnlimited()) {
     VPrintf(1, "Unlimited stack, doing reexec\n");

lib/sanitizer_common/sanitizer_flag_parser.h

class FlagParser {
   const char *buf_;
   uptr pos_;
 
  public:
   FlagParser();
   void RegisterHandler(const char *name, FlagHandlerBase *handler,
                        const char *desc);
   void ParseString(const char *s);
+  bool ParseFile(const char *path, bool ignore_missing);
   void PrintFlagDescriptions();
 
   static LowLevelAllocator Alloc;
 
  private:
   void fatal_error(const char *err);
   bool is_space(char c);
   void skip_whitespace();

lib/sanitizer_common/sanitizer_flag_parser.cc

void FlagParser::ParseString(const char *s) {
   pos_ = 0;
 
   parse_flags();
 
   buf_ = old_buf_;
   pos_ = old_pos_;
 }
 
+bool FlagParser::ParseFile(const char *path, bool ignore_missing) {
+  static const uptr kMaxIncludeSize = 1 << 15;
+  char *data;
+  uptr data_mapped_size;
+  error_t err;
+  uptr len;
+  if (!ReadFileToBuffer(path, &data, &data_mapped_size, &len,
+                        Max(kMaxIncludeSize, GetPageSizeCached()), &err)) {
+    if (ignore_missing)
+      return true;
+    Printf("Failed to read options from '%s': error %d\n", path, err);
+    return false;
+  }
+  ParseString(data);
+  UnmapOrDie(data, data_mapped_size);
+  return true;
+}
+
 bool FlagParser::run_handler(const char *name, const char *value) {
   for (int i = 0; i < n_flags_; ++i) {
     if (internal_strcmp(name, flags_[i].name) == 0)
       return flags_[i].handler->Parse(value);
   }
   // Unrecognized flag. This is not a fatal error, we may print a warning later.
   unknown_flags.Add(name);
   return true;

lib/sanitizer_common/sanitizer_flags.h

 // the first time).
 inline void OverrideCommonFlags(const CommonFlags &cf) {
   common_flags_dont_use.CopyFrom(cf);
 }
 
 class FlagParser;
 void RegisterCommonFlags(FlagParser *parser,
                          CommonFlags *cf = &common_flags_dont_use);
-void RegisterIncludeFlag(FlagParser *parser, CommonFlags *cf);
+void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf);
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FLAGS_H

lib/sanitizer_common/sanitizer_flags.cc

 #include "sanitizer_flags.inc"
 #undef COMMON_FLAG
 }
 
 void CommonFlags::CopyFrom(const CommonFlags &other) {
   internal_memcpy(this, &other, sizeof(*this));
 }
 
+static void SubstituteBinaryName(const char *s, char *out) {
+  char *t = out;
+  while (*s) {
+    if (s[0] != '%' || s[1] != 'b') { *t++ = *s++; continue; }
+    const char *base = GetBinaryBasename();
+    CHECK(base);
+    internal_strncpy(t, base, kMaxPathLength - (t - out));
+    t += internal_strlen(base);
+    s += 2;
+  }
+  *t = '\0';
+}
+
 class FlagHandlerInclude : public FlagHandlerBase {
-  static const uptr kMaxIncludeSize = 1 << 15;
   FlagParser *parser_;
+  bool ignore_missing_;
 
  public:
-  explicit FlagHandlerInclude(FlagParser *parser) : parser_(parser) {}
+  explicit FlagHandlerInclude(FlagParser *parser, bool ignore_missing)
+      : parser_(parser), ignore_missing_(ignore_missing) {}
   bool Parse(const char *value) final {
-    char *data;
-    uptr data_mapped_size;
-    uptr len;
-    error_t err;
-    if (!ReadFileToBuffer(value, &data, &data_mapped_size, &len,
-                          Max(kMaxIncludeSize, GetPageSizeCached()), &err)) {
-      Printf("Failed to read options from '%s': error %d\n", value, err);
-      return false;
-    }
-    parser_->ParseString(data);
-    UnmapOrDie(data, data_mapped_size);
-    return true;
+    if (internal_strchr(value, '%')) {
+      char *buf = (char *)MmapOrDie(kMaxPathLength, "FlagHandlerInclude");
+      SubstituteBinaryName(value, buf);
+      bool res = parser_->ParseFile(buf, ignore_missing_);
+      UnmapOrDie(buf, kMaxPathLength);
+      return res;
+    }
+    return parser_->ParseFile(value, ignore_missing_);
   }
 };
 
-void RegisterIncludeFlag(FlagParser *parser, CommonFlags *cf) {
+void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf) {
   FlagHandlerInclude *fh_include =
-      new (FlagParser::Alloc) FlagHandlerInclude(parser);  // NOLINT
+      new (FlagParser::Alloc) FlagHandlerInclude(parser, false); // NOLINT
   parser->RegisterHandler("include", fh_include,
                           "read more options from the given file");
+  FlagHandlerInclude *fh_include_ignore_missing =
+      new (FlagParser::Alloc) FlagHandlerInclude(parser, true); // NOLINT
+  parser->RegisterHandler(
+      "include?", fh_include_ignore_missing,
+      "read more options from the given file (if it exists)");
 }
 
 void RegisterCommonFlags(FlagParser *parser, CommonFlags *cf) {
 #define COMMON_FLAG(Type, Name, DefaultValue, Description) \
   RegisterFlag(parser, #Name, Description, &cf->Name);
 #include "sanitizer_flags.inc"
 #undef COMMON_FLAG
 
-  RegisterIncludeFlag(parser, cf);
+  RegisterIncludeFlags(parser, cf);
 }
 
 }  // namespace __sanitizer

lib/tsan/rtl/tsan_rtl.cc

void Initialize(ThreadState *thr) {
   // We are not ready to handle interceptors yet.
   ScopedIgnoreInterceptors ignore;
   SanitizerToolName = "ThreadSanitizer";
   // Install tool-specific callbacks in sanitizer_common.
   SetCheckFailedCallback(TsanCheckFailed);
 
   ctx = new(ctx_placeholder) Context;
   const char *options = GetEnv(kTsanOptionsEnv);
-  InitializeFlags(&ctx->flags, options);
   CacheBinaryName();
+  InitializeFlags(&ctx->flags, options);
 #ifndef SANITIZER_GO
   InitializeAllocator();
 #endif
   InitializeInterceptors();
   CheckShadowMapping();
   InitializePlatform();
   InitializeMutex();
   InitializeDynamicAnnotations();

test/sanitizer_common/TestCases/options-include.cc

 // RUN: %clangxx -O0 %s -o %t
+
+// Recursive include: options1 includes options2
 // RUN: echo -e "symbolize=1\ninclude='%t.options2.txt'" >%t.options1.txt
 // RUN: echo -e "help=1\n" >%t.options2.txt
+// RUN: echo -e "help=1\n" >%t.options.options-include.cc.tmp
 // RUN: cat %t.options1.txt
 // RUN: cat %t.options2.txt
+
 // RUN: %tool_options="help=0:include='%t.options1.txt'" %run %t 2>&1 | tee %t.out
-// RUN: FileCheck %s --check-prefix=CHECK-VERBOSITY1 <%t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND <%t.out
+
 // RUN: %tool_options="include='%t.options1.txt',help=0" %run %t 2>&1 | tee %t.out
-// RUN: FileCheck %s --check-prefix=CHECK-VERBOSITY0 <%t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITHOUT-HELP --check-prefix=CHECK-FOUND <%t.out
+
 // RUN: %tool_options="include='%t.options-not-found.txt',help=1" not %run %t 2>&1 | tee %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-NOT-FOUND < %t.out
 
+// include? does not fail when the file is missing
+// RUN: %tool_options="include?='%t.options-not-found.txt',help=1" %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND < %t.out
+
+// %b (binary basename substitution)
+// RUN: %tool_options="include='%t.options.%b'" %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND < %t.out
+
+// RUN: %tool_options="include='%t.options-not-found.%b'" not %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITHOUT-HELP --check-prefix=CHECK-NOT-FOUND < %t.out
+
+// RUN: %tool_options="include?='%t.options.%b'" %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND < %t.out
+
+// RUN: %tool_options="include?='%t.options-not-found.%b'" %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITHOUT-HELP --check-prefix=CHECK-FOUND < %t.out
+
+
 #include <stdio.h>
 
 int main() {
   fprintf(stderr, "done\n");
 }
 
-// CHECK-VERBOSITY1: Available flags for
-// CHECK-VERBOSITY0-NOT: Available flags for
+// CHECK-WITH-HELP: Available flags for
+// CHECK-WITHOUT-HELP-NOT: Available flags for
+// CHECK-FOUND-NOT: Failed to read options from
 // CHECK-NOT-FOUND: Failed to read options from