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_EQ(kDefaultEnableCtMalloc, static_cast<bool>(aparams.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(kDefaultEnableRateTargetedHeaps,
90 E : static_cast<bool>(aparams.enable_rate_targeted_heaps));
91 : EXPECT_EQ(kDefaultLargeAllocationThreshold,
92 E : aparams.large_allocation_threshold);
93 E : }
94 :
95 E : TEST(AsanParametersTest, InflateAsanParametersStackIdsPastEnd) {
96 E : AsanParameters aparams = {};
97 E : SetDefaultAsanParameters(&aparams);
98 :
99 : aparams.ignored_stack_ids = reinterpret_cast<AsanStackId*>(
100 E : &aparams + 2);
101 :
102 E : InflatedAsanParameters iparams;
103 E : EXPECT_FALSE(InflateAsanParameters(&aparams, &iparams));
104 E : }
105 :
106 E : TEST(AsanParametersTest, InflateAsanParametersStackIdsBeforeBeginning) {
107 E : AsanParameters aparams = {};
108 E : SetDefaultAsanParameters(&aparams);
109 :
110 : aparams.ignored_stack_ids = reinterpret_cast<AsanStackId*>(
111 E : &aparams - 1);
112 :
113 E : InflatedAsanParameters iparams;
114 E : EXPECT_FALSE(InflateAsanParameters(&aparams, &iparams));
115 E : }
116 :
117 E : TEST(AsanParametersTest, InflateAsanParametersStackIdsOverlapParams) {
118 E : AsanParameters aparams = {};
119 E : SetDefaultAsanParameters(&aparams);
120 :
121 : aparams.ignored_stack_ids = reinterpret_cast<AsanStackId*>(
122 E : &aparams) + 2;
123 :
124 E : InflatedAsanParameters iparams;
125 E : EXPECT_FALSE(InflateAsanParameters(&aparams, &iparams));
126 E : }
127 :
128 E : TEST(AsanParametersTest, InflateAsanParametersStackIdsNoNull) {
129 E : uint8 data[sizeof(AsanParameters) + sizeof(AsanStackId)] = { 0 };
130 E : AsanParameters* aparams = reinterpret_cast<AsanParameters*>(data);
131 E : SetDefaultAsanParameters(aparams);
132 : aparams->ignored_stack_ids = reinterpret_cast<AsanStackId*>(
133 E : data + sizeof(AsanParameters));
134 :
135 E : aparams->size = sizeof(data);
136 E : aparams->ignored_stack_ids[0] = 0xDEADBEEF;
137 :
138 E : InflatedAsanParameters iparams;
139 E : EXPECT_FALSE(InflateAsanParameters(aparams, &iparams));
140 E : }
141 :
142 E : TEST(AsanParametersTest, InflateAsanParametersStackIds) {
143 E : uint8 data[sizeof(AsanParameters) + 2 * sizeof(AsanStackId)] = { 0 };
144 E : AsanParameters* aparams = reinterpret_cast<AsanParameters*>(data);
145 E : SetDefaultAsanParameters(aparams);
146 : aparams->ignored_stack_ids = reinterpret_cast<AsanStackId*>(
147 E : data + sizeof(AsanParameters));
148 :
149 E : aparams->size = sizeof(data);
150 E : aparams->ignored_stack_ids[0] = 0xDEADBEEF;
151 E : aparams->ignored_stack_ids[1] = NULL;
152 :
153 E : InflatedAsanParameters iparams;
154 E : EXPECT_TRUE(InflateAsanParameters(aparams, &iparams));
155 :
156 : // We normalize the few fields we expect to differ, and the rest should be
157 : // the same.
158 E : aparams->size = sizeof(AsanParameters);
159 E : aparams->ignored_stack_ids = NULL;
160 E : EXPECT_EQ(0, ::memcmp(aparams, &iparams, sizeof(AsanParameters)));
161 :
162 : // The ignored stack id should have been parsed.
163 E : EXPECT_EQ(1u, iparams.ignored_stack_ids_set.size());
164 E : EXPECT_EQ(1u, iparams.ignored_stack_ids_set.count(0xDEADBEEF));
165 E : }
166 :
167 E : TEST(AsanParametersTest, InflateAsanParametersNoStackIds) {
168 E : AsanParameters aparams = {};
169 E : SetDefaultAsanParameters(&aparams);
170 :
171 E : InflatedAsanParameters iparams;
172 E : EXPECT_TRUE(InflateAsanParameters(&aparams, &iparams));
173 :
174 E : EXPECT_EQ(0, ::memcmp(&aparams, &iparams, sizeof(AsanParameters)));
175 E : }
176 :
177 E : TEST(AsanParametersTest, ParseAsanParametersSizeNotANumber) {
178 : static const wchar_t kParams[] = L"--quarantine_size=foo";
179 E : InflatedAsanParameters iparams;
180 E : EXPECT_FALSE(ParseAsanParameters(kParams, &iparams));
181 E : }
182 :
183 E : TEST(AsanParametersTest, ParseAsanParametersNegativeSize) {
184 : static const wchar_t kParams[] = L"--quarantine_size=-45";
185 E : InflatedAsanParameters iparams;
186 E : EXPECT_FALSE(ParseAsanParameters(kParams, &iparams));
187 E : }
188 :
189 E : TEST(AsanParametersTest, ParseAsanParametersFloatingPointSize) {
190 : static const wchar_t kParams[] = L"--quarantine_size=4.5";
191 E : InflatedAsanParameters iparams;
192 E : EXPECT_FALSE(ParseAsanParameters(kParams, &iparams));
193 E : }
194 :
195 E : TEST(AsanParametersTest, ParseAsanParametersInvalidStackId) {
196 : static const wchar_t kParams[] = L"--ignored_stack_ids=foobaz";
197 E : InflatedAsanParameters iparams;
198 E : EXPECT_FALSE(ParseAsanParameters(kParams, &iparams));
199 E : }
200 :
201 E : TEST(AsanParametersTest, ParseAsanParametersMinimal) {
202 : static const wchar_t kParams[] = L"";
203 :
204 E : InflatedAsanParameters iparams;
205 E : SetDefaultAsanParameters(&iparams);
206 E : EXPECT_TRUE(ParseAsanParameters(kParams, &iparams));
207 :
208 E : EXPECT_EQ(sizeof(AsanParameters), iparams.size);
209 E : EXPECT_EQ(kAsanParametersVersion, iparams.version);
210 E : EXPECT_EQ(kDefaultQuarantineSize, iparams.quarantine_size);
211 E : EXPECT_EQ(kDefaultReportingPeriod, iparams.reporting_period);
212 E : EXPECT_EQ(kDefaultBottomFramesToSkip, iparams.bottom_frames_to_skip);
213 E : EXPECT_EQ(kDefaultMaxNumFrames, iparams.max_num_frames);
214 E : EXPECT_EQ(kDefaultTrailerPaddingSize, iparams.trailer_padding_size);
215 E : EXPECT_EQ(kDefaultQuarantineBlockSize, iparams.quarantine_block_size);
216 : EXPECT_EQ(kDefaultMiniDumpOnFailure,
217 E : static_cast<bool>(iparams.minidump_on_failure));
218 : EXPECT_EQ(kDefaultExitOnFailure,
219 E : static_cast<bool>(iparams.exit_on_failure));
220 : EXPECT_EQ(kDefaultCheckHeapOnFailure,
221 E : static_cast<bool>(iparams.check_heap_on_failure));
222 : EXPECT_EQ(kDefaultLogAsText,
223 E : static_cast<bool>(iparams.log_as_text));
224 : EXPECT_EQ(kDefaultCheckHeapOnFailure,
225 E : static_cast<bool>(iparams.check_heap_on_failure));
226 E : EXPECT_EQ(0u, iparams.reserved1);
227 E : EXPECT_TRUE(iparams.ignored_stack_ids_set.empty());
228 E : EXPECT_EQ(kDefaultZebraBlockHeapSize, iparams.zebra_block_heap_size);
229 : EXPECT_EQ(kDefaultZebraBlockHeapQuarantineRatio,
230 E : iparams.zebra_block_heap_quarantine_ratio);
231 : EXPECT_EQ(kDefaultEnableCtMalloc,
232 E : static_cast<bool>(iparams.enable_ctmalloc));
233 : EXPECT_EQ(kDefaultEnableZebraBlockHeap,
234 E : static_cast<bool>(iparams.enable_zebra_block_heap));
235 : EXPECT_EQ(kDefaultEnableLargeBlockHeap,
236 E : static_cast<bool>(iparams.enable_large_block_heap));
237 : EXPECT_EQ(kDefaultEnableAllocationFilter,
238 E : static_cast<bool>(iparams.enable_allocation_filter));
239 : EXPECT_EQ(kDefaultEnableRateTargetedHeaps,
240 E : static_cast<bool>(iparams.enable_rate_targeted_heaps));
241 : EXPECT_EQ(kDefaultLargeAllocationThreshold,
242 E : iparams.large_allocation_threshold);
243 E : }
244 :
245 E : TEST(AsanParametersTest, ParseAsanParametersMaximal) {
246 : static const wchar_t kParams[] =
247 : L"--quarantine_size=1024 "
248 : L"--quarantine_block_size=256 "
249 : L"--trailer_padding_size=100 "
250 : L"--compression_reporting_period=324 "
251 : L"--bottom_frames_to_skip=5 "
252 : L"--max_num_frames=27 "
253 : L"--ignored_stack_ids=0X1;0xDEADBEEF;0xBAADF00D;CAFEBABE "
254 : L"--exit_on_failure "
255 : L"--no_check_heap_on_failure "
256 : L"--minidump_on_failure "
257 : L"--no_log_as_text "
258 : L"--disable_breakpad "
259 : L"--allocation_guard_rate=0.6 "
260 : L"--ignored_as_it_doesnt_exist "
261 : L"--zebra_block_heap_size=8388608 "
262 : L"--zebra_block_heap_quarantine_ratio=0.5 "
263 : L"--disable_ctmalloc "
264 : L"--enable_zebra_block_heap "
265 : L"--disable_large_block_heap "
266 : L"--disable_rate_targeted_heaps "
267 : L"--enable_allocation_filter "
268 : L"--large_allocation_threshold=4096";
269 :
270 E : InflatedAsanParameters iparams;
271 E : SetDefaultAsanParameters(&iparams);
272 E : EXPECT_TRUE(ParseAsanParameters(kParams, &iparams));
273 :
274 E : EXPECT_EQ(sizeof(AsanParameters), iparams.size);
275 E : EXPECT_EQ(kAsanParametersVersion, iparams.version);
276 E : EXPECT_EQ(1024, iparams.quarantine_size);
277 E : EXPECT_EQ(324, iparams.reporting_period);
278 E : EXPECT_EQ(5, iparams.bottom_frames_to_skip);
279 E : EXPECT_EQ(27, iparams.max_num_frames);
280 E : EXPECT_EQ(100, iparams.trailer_padding_size);
281 E : EXPECT_EQ(256, iparams.quarantine_block_size);
282 E : EXPECT_EQ(true, static_cast<bool>(iparams.minidump_on_failure));
283 E : EXPECT_EQ(true, static_cast<bool>(iparams.exit_on_failure));
284 E : EXPECT_EQ(false, static_cast<bool>(iparams.check_heap_on_failure));
285 E : EXPECT_EQ(false, static_cast<bool>(iparams.log_as_text));
286 E : EXPECT_EQ(true, static_cast<bool>(iparams.disable_breakpad_reporting));
287 E : EXPECT_EQ(0u, iparams.reserved1);
288 E : EXPECT_EQ(0.6f, iparams.allocation_guard_rate);
289 : EXPECT_THAT(iparams.ignored_stack_ids_set,
290 E : testing::ElementsAre(0x1, 0xBAADF00D, 0xCAFEBABE, 0xDEADBEEF));
291 E : EXPECT_EQ(8388608, iparams.zebra_block_heap_size);
292 E : EXPECT_EQ(0.5, iparams.zebra_block_heap_quarantine_ratio);
293 E : EXPECT_FALSE(static_cast<bool>(iparams.enable_ctmalloc));
294 E : EXPECT_TRUE(static_cast<bool>(iparams.enable_zebra_block_heap));
295 E : EXPECT_FALSE(static_cast<bool>(iparams.enable_large_block_heap));
296 E : EXPECT_TRUE(static_cast<bool>(iparams.enable_allocation_filter));
297 E : EXPECT_FALSE(static_cast<bool>(iparams.enable_rate_targeted_heaps));
298 E : EXPECT_EQ(4096, iparams.large_allocation_threshold);
299 E : }
300 :
301 : } // namespace common
|