1//===-- sanitizer_suppressions.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// Suppression parsing/matching code.
10//
11//===----------------------------------------------------------------------===//
12
13#include "sanitizer_suppressions.h"
14
15#include "sanitizer_allocator_internal.h"
16#include "sanitizer_common.h"
17#include "sanitizer_flags.h"
18#include "sanitizer_file.h"
19#include "sanitizer_libc.h"
20#include "sanitizer_placement_new.h"
21
22namespace __sanitizer {
23
24SuppressionContext::SuppressionContext(const char *suppression_types[],
25 int suppression_types_num)
26 : suppression_types_(suppression_types),
27 suppression_types_num_(suppression_types_num),
28 can_parse_(true) {
29 CHECK_LE(suppression_types_num_, kMaxSuppressionTypes);
30 internal_memset(s: has_suppression_type_, c: 0, n: suppression_types_num_);
31}
32
33#if !SANITIZER_FUCHSIA
34static bool GetPathAssumingFileIsRelativeToExec(const char *file_path,
35 /*out*/char *new_file_path,
36 uptr new_file_path_size) {
37 InternalMmapVector<char> exec(kMaxPathLength);
38 if (ReadBinaryNameCached(buf: exec.data(), buf_len: exec.size())) {
39 const char *file_name_pos = StripModuleName(module: exec.data());
40 uptr path_to_exec_len = file_name_pos - exec.data();
41 internal_strncat(dst: new_file_path, src: exec.data(),
42 n: Min(a: path_to_exec_len, b: new_file_path_size - 1));
43 internal_strncat(dst: new_file_path, src: file_path,
44 n: new_file_path_size - internal_strlen(s: new_file_path) - 1);
45 return true;
46 }
47 return false;
48}
49
50static const char *FindFile(const char *file_path,
51 /*out*/char *new_file_path,
52 uptr new_file_path_size) {
53 // If we cannot find the file, check if its location is relative to
54 // the location of the executable.
55 if (!FileExists(filename: file_path) && !IsAbsolutePath(path: file_path) &&
56 GetPathAssumingFileIsRelativeToExec(file_path, new_file_path,
57 new_file_path_size)) {
58 return new_file_path;
59 }
60 return file_path;
61}
62#else
63static const char *FindFile(const char *file_path, char *, uptr) {
64 return file_path;
65}
66#endif
67
68void SuppressionContext::ParseFromFile(const char *filename) {
69 if (filename[0] == '\0')
70 return;
71
72 InternalMmapVector<char> new_file_path(kMaxPathLength);
73 filename = FindFile(file_path: filename, new_file_path: new_file_path.data(), new_file_path_size: new_file_path.size());
74
75 // Read the file.
76 VPrintf(1, "%s: reading suppressions file at %s\n",
77 SanitizerToolName, filename);
78 char *file_contents;
79 uptr buffer_size;
80 uptr contents_size;
81 if (!ReadFileToBuffer(file_name: filename, buff: &file_contents, buff_size: &buffer_size,
82 read_len: &contents_size)) {
83 Printf(format: "%s: failed to read suppressions file '%s'\n", SanitizerToolName,
84 filename);
85 Die();
86 }
87
88 Parse(str: file_contents);
89 UnmapOrDie(addr: file_contents, size: buffer_size);
90}
91
92bool SuppressionContext::Match(const char *str, const char *type,
93 Suppression **s) {
94 can_parse_ = false;
95 if (!HasSuppressionType(type))
96 return false;
97 for (uptr i = 0; i < suppressions_.size(); i++) {
98 Suppression &cur = suppressions_[i];
99 if (0 == internal_strcmp(s1: cur.type, s2: type) && TemplateMatch(templ: cur.templ, str)) {
100 *s = &cur;
101 return true;
102 }
103 }
104 return false;
105}
106
107static const char *StripPrefix(const char *str, const char *prefix) {
108 while (*str && *str == *prefix) {
109 str++;
110 prefix++;
111 }
112 if (!*prefix)
113 return str;
114 return 0;
115}
116
117void SuppressionContext::Parse(const char *str) {
118 // Context must not mutate once Match has been called.
119 CHECK(can_parse_);
120 const char *line = str;
121 while (line) {
122 while (line[0] == ' ' || line[0] == '\t')
123 line++;
124 const char *end = internal_strchr(s: line, c: '\n');
125 if (end == 0)
126 end = line + internal_strlen(s: line);
127 if (line != end && line[0] != '#') {
128 const char *end2 = end;
129 while (line != end2 &&
130 (end2[-1] == ' ' || end2[-1] == '\t' || end2[-1] == '\r'))
131 end2--;
132 int type;
133 for (type = 0; type < suppression_types_num_; type++) {
134 const char *next_char = StripPrefix(str: line, prefix: suppression_types_[type]);
135 if (next_char && *next_char == ':') {
136 line = ++next_char;
137 break;
138 }
139 }
140 if (type == suppression_types_num_) {
141 Printf(format: "%s: failed to parse suppressions.\n", SanitizerToolName);
142 Printf(format: "Supported suppression types are:\n");
143 for (type = 0; type < suppression_types_num_; type++)
144 Printf(format: "- %s\n", suppression_types_[type]);
145 Die();
146 }
147 Suppression s;
148 s.type = suppression_types_[type];
149 s.templ = (char*)InternalAlloc(size: end2 - line + 1);
150 internal_memcpy(dest: s.templ, src: line, n: end2 - line);
151 s.templ[end2 - line] = 0;
152 suppressions_.push_back(element: s);
153 has_suppression_type_[type] = true;
154 }
155 if (end[0] == 0)
156 break;
157 line = end + 1;
158 }
159}
160
161uptr SuppressionContext::SuppressionCount() const {
162 return suppressions_.size();
163}
164
165bool SuppressionContext::HasSuppressionType(const char *type) const {
166 for (int i = 0; i < suppression_types_num_; i++) {
167 if (0 == internal_strcmp(s1: type, s2: suppression_types_[i]))
168 return has_suppression_type_[i];
169 }
170 return false;
171}
172
173const Suppression *SuppressionContext::SuppressionAt(uptr i) const {
174 CHECK_LT(i, suppressions_.size());
175 return &suppressions_[i];
176}
177
178void SuppressionContext::GetMatched(
179 InternalMmapVector<Suppression *> *matched) {
180 for (uptr i = 0; i < suppressions_.size(); i++)
181 if (atomic_load_relaxed(a: &suppressions_[i].hit_count))
182 matched->push_back(element: &suppressions_[i]);
183}
184
185} // namespace __sanitizer
186