1 : // Copyright 2014 Google Inc. All Rights Reserved.
2 : //
3 : // Licensed under the Apache License, Version 2.0 (the "License");
4 : // you may not use this file except in compliance with the License.
5 : // You may obtain a copy of the License at
6 : //
7 : // http://www.apache.org/licenses/LICENSE-2.0
8 : //
9 : // Unless required by applicable law or agreed to in writing, software
10 : // distributed under the License is distributed on an "AS IS" BASIS,
11 : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 : // See the License for the specific language governing permissions and
13 : // limitations under the License.
14 :
15 : #include "syzygy/common/asan_parameters.h"
16 :
17 : #include "gmock/gmock.h"
18 : #include "gtest/gtest.h"
19 :
20 : namespace common {
21 :
22 E : TEST(AsanParametersTest, FlatAsanParametersConstructorNoStackIds) {
23 E : InflatedAsanParameters iparams;
24 E : SetDefaultAsanParameters(&iparams);
25 E : FlatAsanParameters fparams(iparams);
26 E : EXPECT_EQ(sizeof(AsanParameters), fparams.data().size());
27 E : EXPECT_EQ(0, ::memcmp(&iparams, &fparams.params(), sizeof(AsanParameters)));
28 E : }
29 :
30 E : TEST(AsanParametersTest, FlatAsanParametersConstructorWithStackIds) {
31 E : InflatedAsanParameters iparams;
32 E : SetDefaultAsanParameters(&iparams);
33 E : iparams.ignored_stack_ids_set.insert(0xCAFEBABE);
34 :
35 E : FlatAsanParameters fparams(iparams);
36 : EXPECT_EQ(sizeof(AsanParameters) + 2 * sizeof(AsanStackId),
37 E : fparams.data().size());
38 :
39 : // Patch up the things that will be different between the two structs.
40 E : iparams.size = fparams.data().size();
41 : static_cast<AsanParameters*>(&iparams)->ignored_stack_ids =
42 : const_cast<AsanStackId*>(reinterpret_cast<const AsanStackId*>(
43 E : fparams.data().data() + sizeof(AsanParameters)));
44 E : const AsanParameters* aparams = &fparams.params();
45 :
46 : // Now compare the rest of their POD content.
47 E : EXPECT_EQ(0, ::memcmp(&iparams, aparams, sizeof(AsanParameters)));
48 :
49 : // Finally, confirm that the stack IDs have been properly serialized.
50 E : EXPECT_EQ(0xCAFEBABE, fparams->ignored_stack_ids[0]);
51 E : EXPECT_EQ(NULL, fparams->ignored_stack_ids[1]);
52 E : }
53 :
54 E : TEST(AsanParametersTest, SetDefaultAsanParameters) {
55 E : AsanParameters aparams = {};
56 E : SetDefaultAsanParameters(&aparams);
57 :
58 E : EXPECT_EQ(sizeof(AsanParameters), aparams.size);
59 E : EXPECT_EQ(kAsanParametersVersion, aparams.version);
60 E : EXPECT_EQ(kDefaultQuarantineSize, aparams.quarantine_size);
61 E : EXPECT_EQ(kDefaultReportingPeriod, aparams.reporting_period);
62 E : EXPECT_EQ(kDefaultBottomFramesToSkip, aparams.bottom_frames_to_skip);
63 E : EXPECT_EQ(kDefaultMaxNumFrames, aparams.max_num_frames);
64 E : EXPECT_EQ(kDefaultTrailerPaddingSize, aparams.trailer_padding_size);
65 E : EXPECT_EQ(NULL, aparams.ignored_stack_ids);
66 E : EXPECT_EQ(kDefaultQuarantineBlockSize, aparams.quarantine_block_size);
67 : EXPECT_EQ(kDefaultMiniDumpOnFailure,
68 E : static_cast<bool>(aparams.minidump_on_failure));
69 : EXPECT_EQ(kDefaultExitOnFailure,
70 E : static_cast<bool>(aparams.exit_on_failure));
71 : EXPECT_EQ(kDefaultCheckHeapOnFailure,
72 E : static_cast<bool>(aparams.check_heap_on_failure));
73 : EXPECT_EQ(kDefaultLogAsText,
74 E : static_cast<bool>(aparams.log_as_text));
75 : EXPECT_EQ(kDefaultDisableBreakpadReporting,
76 E : static_cast<bool>(aparams.disable_breakpad_reporting));
77 E : EXPECT_EQ(0u, aparams.reserved1);
78 E : EXPECT_EQ(kDefaultAllocationGuardRate, aparams.allocation_guard_rate);
79 E : EXPECT_EQ(kDefaultZebraBlockHeapSize, aparams.zebra_block_heap_size);
80 : EXPECT_EQ(kDefaultZebraBlockHeapQuarantineRatio,
81 E : aparams.zebra_block_heap_quarantine_ratio);
82 E : EXPECT_FALSE(static_cast<bool>(aparams.deprecated_enable_ctmalloc));
83 : EXPECT_EQ(kDefaultEnableZebraBlockHeap,
84 E : static_cast<bool>(aparams.enable_zebra_block_heap));
85 : EXPECT_EQ(kDefaultEnableLargeBlockHeap,
86 E : static_cast<bool>(aparams.enable_large_block_heap));
87 : EXPECT_EQ(kDefaultEnableAllocationFilter,
88 E : static_cast<bool>(aparams.enable_allocation_filter));
89 : EXPECT_EQ(kDefaultLargeAllocationThreshold,
90 E : aparams.large_allocation_threshold);
91 : EXPECT_EQ(kDefaultQuarantineFloodFillRate,
92 E : aparams.quarantine_flood_fill_rate);
93 : EXPECT_EQ(kDefaultFeatureRandomization,
94 E : static_cast<bool>(aparams.feature_randomization));
95 : EXPECT_EQ(kDefaultPreventDuplicateCorruptionCrashes,
96 E : static_cast<bool>(aparams.prevent_duplicate_corruption_crashes));
97 : EXPECT_EQ(kDefaultReportInvalidAccesses,
98 E : static_cast<bool>(aparams.report_invalid_accesses));
99 E : }
100 :
101 E : TEST(AsanParametersTest, InflateAsanParametersStackIdsPastEnd) {
102 E : AsanParameters aparams = {};
103 E : SetDefaultAsanParameters(&aparams);
104 :
105 : aparams.ignored_stack_ids = reinterpret_cast<AsanStackId*>(
106 E : &aparams + 2);
107 :
108 E : InflatedAsanParameters iparams;
109 E : EXPECT_FALSE(InflateAsanParameters(&aparams, &iparams));
110 E : }
111 :
112 E : TEST(AsanParametersTest, InflateAsanParametersStackIdsBeforeBeginning) {
113 E : AsanParameters aparams = {};
114 E : SetDefaultAsanParameters(&aparams);
115 :
116 : aparams.ignored_stack_ids = reinterpret_cast<AsanStackId*>(
117 E : &aparams - 1);
118 :
119 E : InflatedAsanParameters iparams;
120 E : EXPECT_FALSE(InflateAsanParameters(&aparams, &iparams));
121 E : }
122 :
123 E : TEST(AsanParametersTest, InflateAsanParametersStackIdsOverlapParams) {
124 E : AsanParameters aparams = {};
125 E : SetDefaultAsanParameters(&aparams);
126 :
127 : aparams.ignored_stack_ids = reinterpret_cast<AsanStackId*>(
128 E : &aparams) + 2;
129 :
130 E : InflatedAsanParameters iparams;
131 E : EXPECT_FALSE(InflateAsanParameters(&aparams, &iparams));
132 E : }
133 :
134 E : TEST(AsanParametersTest, InflateAsanParametersStackIdsNoNull) {
135 E : uint8 data[sizeof(AsanParameters) + sizeof(AsanStackId)] = { 0 };
136 E : AsanParameters* aparams = reinterpret_cast<AsanParameters*>(data);
137 E : SetDefaultAsanParameters(aparams);
138 : aparams->ignored_stack_ids = reinterpret_cast<AsanStackId*>(
139 E : data + sizeof(AsanParameters));
140 :
141 E : aparams->size = sizeof(data);
142 E : aparams->ignored_stack_ids[0] = 0xDEADBEEF;
143 :
144 E : InflatedAsanParameters iparams;
145 E : EXPECT_FALSE(InflateAsanParameters(aparams, &iparams));
146 E : }
147 :
148 E : TEST(AsanParametersTest, InflateAsanParametersStackIds) {
149 E : uint8 data[sizeof(AsanParameters) + 2 * sizeof(AsanStackId)] = { 0 };
150 E : AsanParameters* aparams = reinterpret_cast<AsanParameters*>(data);
151 E : SetDefaultAsanParameters(aparams);
152 : aparams->ignored_stack_ids = reinterpret_cast<AsanStackId*>(
153 E : data + sizeof(AsanParameters));
154 :
155 E : aparams->size = sizeof(data);
156 E : aparams->ignored_stack_ids[0] = 0xDEADBEEF;
157 E : aparams->ignored_stack_ids[1] = NULL;
158 :
159 E : InflatedAsanParameters iparams;
160 E : EXPECT_TRUE(InflateAsanParameters(aparams, &iparams));
161 :
162 : // We normalize the few fields we expect to differ, and the rest should be
163 : // the same.
164 E : aparams->size = sizeof(AsanParameters);
165 E : aparams->ignored_stack_ids = NULL;
166 E : EXPECT_EQ(0, ::memcmp(aparams, &iparams, sizeof(AsanParameters)));
167 :
168 : // The ignored stack id should have been parsed.
169 E : EXPECT_EQ(1u, iparams.ignored_stack_ids_set.size());
170 E : EXPECT_EQ(1u, iparams.ignored_stack_ids_set.count(0xDEADBEEF));
171 E : }
172 :
173 E : TEST(AsanParametersTest, InflateAsanParametersNoStackIds) {
174 E : AsanParameters aparams = {};
175 E : SetDefaultAsanParameters(&aparams);
176 :
177 E : InflatedAsanParameters iparams;
178 E : EXPECT_TRUE(InflateAsanParameters(&aparams, &iparams));
179 :
180 E : EXPECT_EQ(0, ::memcmp(&aparams, &iparams, sizeof(AsanParameters)));
181 E : }
182 :
183 E : TEST(AsanParametersTest, ParseAsanParametersSizeNotANumber) {
184 : static const wchar_t kParams[] = L"--quarantine_size=foo";
185 E : InflatedAsanParameters iparams;
186 E : EXPECT_FALSE(ParseAsanParameters(kParams, &iparams));
187 E : }
188 :
189 E : TEST(AsanParametersTest, ParseAsanParametersNegativeSize) {
190 : static const wchar_t kParams[] = L"--quarantine_size=-45";
191 E : InflatedAsanParameters iparams;
192 E : EXPECT_FALSE(ParseAsanParameters(kParams, &iparams));
193 E : }
194 :
195 E : TEST(AsanParametersTest, ParseAsanParametersFloatingPointSize) {
196 : static const wchar_t kParams[] = L"--quarantine_size=4.5";
197 E : InflatedAsanParameters iparams;
198 E : EXPECT_FALSE(ParseAsanParameters(kParams, &iparams));
199 E : }
200 :
201 E : TEST(AsanParametersTest, ParseAsanParametersInvalidStackId) {
202 : static const wchar_t kParams[] = L"--ignored_stack_ids=foobaz";
203 E : InflatedAsanParameters iparams;
204 E : EXPECT_FALSE(ParseAsanParameters(kParams, &iparams));
205 E : }
206 :
207 E : TEST(AsanParametersTest, ParseAsanParametersMinimal) {
208 : static const wchar_t kParams[] = L"";
209 :
210 E : InflatedAsanParameters iparams;
211 E : SetDefaultAsanParameters(&iparams);
212 E : EXPECT_TRUE(ParseAsanParameters(kParams, &iparams));
213 :
214 E : EXPECT_EQ(sizeof(AsanParameters), iparams.size);
215 E : EXPECT_EQ(kAsanParametersVersion, iparams.version);
216 E : EXPECT_EQ(kDefaultQuarantineSize, iparams.quarantine_size);
217 E : EXPECT_EQ(kDefaultReportingPeriod, iparams.reporting_period);
218 E : EXPECT_EQ(kDefaultBottomFramesToSkip, iparams.bottom_frames_to_skip);
219 E : EXPECT_EQ(kDefaultMaxNumFrames, iparams.max_num_frames);
220 E : EXPECT_EQ(kDefaultTrailerPaddingSize, iparams.trailer_padding_size);
221 E : EXPECT_EQ(kDefaultQuarantineBlockSize, iparams.quarantine_block_size);
222 : EXPECT_EQ(kDefaultMiniDumpOnFailure,
223 E : static_cast<bool>(iparams.minidump_on_failure));
224 : EXPECT_EQ(kDefaultExitOnFailure,
225 E : static_cast<bool>(iparams.exit_on_failure));
226 : EXPECT_EQ(kDefaultCheckHeapOnFailure,
227 E : static_cast<bool>(iparams.check_heap_on_failure));
228 : EXPECT_EQ(kDefaultLogAsText,
229 E : static_cast<bool>(iparams.log_as_text));
230 : EXPECT_EQ(kDefaultCheckHeapOnFailure,
231 E : static_cast<bool>(iparams.check_heap_on_failure));
232 E : EXPECT_EQ(0u, iparams.reserved1);
233 E : EXPECT_TRUE(iparams.ignored_stack_ids_set.empty());
234 E : EXPECT_EQ(kDefaultZebraBlockHeapSize, iparams.zebra_block_heap_size);
235 : EXPECT_EQ(kDefaultZebraBlockHeapQuarantineRatio,
236 E : iparams.zebra_block_heap_quarantine_ratio);
237 E : EXPECT_FALSE(static_cast<bool>(iparams.deprecated_enable_ctmalloc));
238 : EXPECT_EQ(kDefaultEnableZebraBlockHeap,
239 E : static_cast<bool>(iparams.enable_zebra_block_heap));
240 : EXPECT_EQ(kDefaultEnableLargeBlockHeap,
241 E : static_cast<bool>(iparams.enable_large_block_heap));
242 : EXPECT_EQ(kDefaultEnableAllocationFilter,
243 E : static_cast<bool>(iparams.enable_allocation_filter));
244 : EXPECT_EQ(kDefaultLargeAllocationThreshold,
245 E : iparams.large_allocation_threshold);
246 : EXPECT_EQ(kDefaultQuarantineFloodFillRate,
247 E : iparams.quarantine_flood_fill_rate);
248 : EXPECT_EQ(kDefaultFeatureRandomization,
249 E : static_cast<bool>(iparams.feature_randomization));
250 : EXPECT_EQ(kDefaultPreventDuplicateCorruptionCrashes,
251 E : static_cast<bool>(iparams.prevent_duplicate_corruption_crashes));
252 : EXPECT_EQ(kDefaultReportInvalidAccesses,
253 E : static_cast<bool>(iparams.report_invalid_accesses));
254 E : }
255 :
256 E : TEST(AsanParametersTest, ParseAsanParametersMaximal) {
257 : static const wchar_t kParams[] =
258 : L"--quarantine_size=1024 "
259 : L"--quarantine_block_size=256 "
260 : L"--trailer_padding_size=100 "
261 : L"--compression_reporting_period=324 "
262 : L"--bottom_frames_to_skip=5 "
263 : L"--max_num_frames=27 "
264 : L"--ignored_stack_ids=0X1;0xDEADBEEF;0xBAADF00D;CAFEBABE "
265 : L"--exit_on_failure "
266 : L"--no_check_heap_on_failure "
267 : L"--minidump_on_failure "
268 : L"--no_log_as_text "
269 : L"--disable_breakpad "
270 : L"--allocation_guard_rate=0.6 "
271 : L"--ignored_as_it_doesnt_exist "
272 : L"--zebra_block_heap_size=8388608 "
273 : L"--zebra_block_heap_quarantine_ratio=0.5 "
274 : L"--enable_zebra_block_heap "
275 : L"--disable_large_block_heap "
276 : L"--enable_allocation_filter "
277 : L"--large_allocation_threshold=4096 "
278 : L"--quarantine_flood_fill_rate=0.25 "
279 : L"--enable_feature_randomization "
280 : L"--prevent_duplicate_corruption_crashes "
281 : L"--report_invalid_accesses";
282 :
283 E : InflatedAsanParameters iparams;
284 E : SetDefaultAsanParameters(&iparams);
285 E : EXPECT_TRUE(ParseAsanParameters(kParams, &iparams));
286 :
287 E : EXPECT_EQ(sizeof(AsanParameters), iparams.size);
288 E : EXPECT_EQ(kAsanParametersVersion, iparams.version);
289 E : EXPECT_EQ(1024, iparams.quarantine_size);
290 E : EXPECT_EQ(324, iparams.reporting_period);
291 E : EXPECT_EQ(5, iparams.bottom_frames_to_skip);
292 E : EXPECT_EQ(27, iparams.max_num_frames);
293 E : EXPECT_EQ(100, iparams.trailer_padding_size);
294 E : EXPECT_EQ(256, iparams.quarantine_block_size);
295 E : EXPECT_EQ(true, static_cast<bool>(iparams.minidump_on_failure));
296 E : EXPECT_EQ(true, static_cast<bool>(iparams.exit_on_failure));
297 E : EXPECT_EQ(false, static_cast<bool>(iparams.check_heap_on_failure));
298 E : EXPECT_EQ(false, static_cast<bool>(iparams.log_as_text));
299 E : EXPECT_EQ(true, static_cast<bool>(iparams.disable_breakpad_reporting));
300 E : EXPECT_EQ(0u, iparams.reserved1);
301 E : EXPECT_EQ(0.6f, iparams.allocation_guard_rate);
302 : EXPECT_THAT(iparams.ignored_stack_ids_set,
303 E : testing::ElementsAre(0x1, 0xBAADF00D, 0xCAFEBABE, 0xDEADBEEF));
304 E : EXPECT_EQ(8388608, iparams.zebra_block_heap_size);
305 E : EXPECT_EQ(0.5f, iparams.zebra_block_heap_quarantine_ratio);
306 E : EXPECT_FALSE(static_cast<bool>(iparams.deprecated_enable_ctmalloc));
307 E : EXPECT_TRUE(static_cast<bool>(iparams.enable_zebra_block_heap));
308 E : EXPECT_FALSE(static_cast<bool>(iparams.enable_large_block_heap));
309 E : EXPECT_TRUE(static_cast<bool>(iparams.enable_allocation_filter));
310 E : EXPECT_EQ(4096, iparams.large_allocation_threshold);
311 E : EXPECT_EQ(0.25f, iparams.quarantine_flood_fill_rate);
312 E : EXPECT_EQ(true, static_cast<bool>(iparams.feature_randomization));
313 : EXPECT_EQ(true, static_cast<bool>(
314 E : iparams.prevent_duplicate_corruption_crashes));
315 E : EXPECT_EQ(true, static_cast<bool>(iparams.report_invalid_accesses));
316 E : }
317 :
318 : } // namespace common
|