| 1 |
//===-- sanitizer_flags.cpp -----------------------------------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// This file is a part of ThreadSanitizer/AddressSanitizer runtime. |
| 10 |
// |
| 11 |
//===----------------------------------------------------------------------===// |
| 12 |
|
| 13 |
#include "sanitizer_flags.h" |
| 14 |
|
| 15 |
#include "sanitizer_common.h" |
| 16 |
#include "sanitizer_flag_parser.h" |
| 17 |
#include "sanitizer_libc.h" |
| 18 |
#include "sanitizer_linux.h" |
| 19 |
#include "sanitizer_list.h" |
| 20 |
|
| 21 |
namespace __sanitizer { |
| 22 |
|
| 23 |
CommonFlags common_flags_dont_use; |
| 24 |
|
| 25 |
void CommonFlags::SetDefaults() { |
| 26 |
#define COMMON_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue; |
| 27 |
#include "sanitizer_flags.inc" |
| 28 |
#undef COMMON_FLAG |
| 29 |
} |
| 30 |
|
| 31 |
void CommonFlags::CopyFrom(const CommonFlags &other) { |
| 32 |
internal_memcpy(this, &other, sizeof(*this)); |
| 33 |
} |
| 34 |
|
| 35 |
// Copy the string from "s" to "out", making the following substitutions: |
| 36 |
// %b = binary basename |
| 37 |
// %p = pid |
| 38 |
// %d = binary directory |
| 39 |
void SubstituteForFlagValue(const char *s, char *out, uptr out_size) { |
| 40 |
char *out_end = out + out_size; |
| 41 |
while (*s && out < out_end - 1) { |
| 42 |
if (s[0] != '%') { |
| 43 |
*out++ = *s++; |
| 44 |
continue; |
| 45 |
} |
| 46 |
switch (s[1]) { |
| 47 |
case 'b': { |
| 48 |
const char *base = GetProcessName(); |
| 49 |
CHECK(base); |
| 50 |
while (*base && out < out_end - 1) |
| 51 |
*out++ = *base++; |
| 52 |
s += 2; // skip "%b" |
| 53 |
break; |
| 54 |
} |
| 55 |
case 'p': { |
| 56 |
int pid = internal_getpid(); |
| 57 |
char buf[32]; |
| 58 |
char *buf_pos = buf + 32; |
| 59 |
do { |
| 60 |
*--buf_pos = (pid % 10) + '0'; |
| 61 |
pid /= 10; |
| 62 |
} while (pid); |
| 63 |
while (buf_pos < buf + 32 && out < out_end - 1) |
| 64 |
*out++ = *buf_pos++; |
| 65 |
s += 2; // skip "%p" |
| 66 |
break; |
| 67 |
} |
| 68 |
case 'd': { |
| 69 |
uptr len = ReadBinaryDir(out, out_end - out); |
| 70 |
out += len; |
| 71 |
s += 2; // skip "%d" |
| 72 |
break; |
| 73 |
} |
| 74 |
default: |
| 75 |
*out++ = *s++; |
| 76 |
break; |
| 77 |
} |
| 78 |
} |
| 79 |
CHECK(out < out_end - 1); |
| 80 |
*out = '\0'; |
| 81 |
} |
| 82 |
|
| 83 |
class FlagHandlerInclude final : public FlagHandlerBase { |
| 84 |
FlagParser *parser_; |
| 85 |
bool ignore_missing_; |
| 86 |
const char *original_path_; |
| 87 |
|
| 88 |
public: |
| 89 |
explicit FlagHandlerInclude(FlagParser *parser, bool ignore_missing) |
| 90 |
: parser_(parser), ignore_missing_(ignore_missing), original_path_("") {} |
| 91 |
bool Parse(const char *value) final { |
| 92 |
original_path_ = value; |
| 93 |
if (internal_strchr(value, '%')) { |
| 94 |
char *buf = (char *)MmapOrDie(kMaxPathLength, "FlagHandlerInclude"); |
| 95 |
SubstituteForFlagValue(value, buf, kMaxPathLength); |
| 96 |
bool res = parser_->ParseFile(buf, ignore_missing_); |
| 97 |
UnmapOrDie(buf, kMaxPathLength); |
| 98 |
return res; |
| 99 |
} |
| 100 |
return parser_->ParseFile(value, ignore_missing_); |
| 101 |
} |
| 102 |
bool Format(char *buffer, uptr size) override { |
| 103 |
// Note `original_path_` isn't actually what's parsed due to `%` |
| 104 |
// substitutions. Printing the substituted path would require holding onto |
| 105 |
// mmap'ed memory. |
| 106 |
return FormatString(buffer, size, original_path_); |
| 107 |
} |
| 108 |
}; |
| 109 |
|
| 110 |
void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf) { |
| 111 |
FlagHandlerInclude *fh_include = new (GetGlobalLowLevelAllocator()) |
| 112 |
FlagHandlerInclude(parser, /*ignore_missing*/ false); |
| 113 |
parser->RegisterHandler("include", fh_include, |
| 114 |
"read more options from the given file"); |
| 115 |
FlagHandlerInclude *fh_include_if_exists = new (GetGlobalLowLevelAllocator()) |
| 116 |
FlagHandlerInclude(parser, /*ignore_missing*/ true); |
| 117 |
parser->RegisterHandler( |
| 118 |
"include_if_exists", fh_include_if_exists, |
| 119 |
"read more options from the given file (if it exists)"); |
| 120 |
} |
| 121 |
|
| 122 |
void RegisterCommonFlags(FlagParser *parser, CommonFlags *cf) { |
| 123 |
#define COMMON_FLAG(Type, Name, DefaultValue, Description) \ |
| 124 |
RegisterFlag(parser, #Name, Description, &cf->Name); |
| 125 |
#include "sanitizer_flags.inc" |
| 126 |
#undef COMMON_FLAG |
| 127 |
|
| 128 |
RegisterIncludeFlags(parser, cf); |
| 129 |
} |
| 130 |
|
| 131 |
void InitializeCommonFlags(CommonFlags *cf) { |
| 132 |
// need to record coverage to generate coverage report. |
| 133 |
cf->coverage |= cf->html_cov_report; |
| 134 |
SetVerbosity(cf->verbosity); |
| 135 |
|
| 136 |
InitializePlatformCommonFlags(cf); |
| 137 |
} |
| 138 |
|
| 139 |
} // namespace __sanitizer |