1 //===-- asan_globals.cpp --------------------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file is a part of AddressSanitizer, an address sanity checker.
12 //===----------------------------------------------------------------------===//
14 #include "asan_interceptors.h"
15 #include "asan_internal.h"
16 #include "asan_mapping.h"
17 #include "asan_poisoning.h"
18 #include "asan_report.h"
19 #include "asan_stack.h"
20 #include "asan_stats.h"
21 #include "asan_suppressions.h"
22 #include "asan_thread.h"
23 #include "sanitizer_common/sanitizer_common.h"
24 #include "sanitizer_common/sanitizer_mutex.h"
25 #include "sanitizer_common/sanitizer_placement_new.h"
26 #include "sanitizer_common/sanitizer_stackdepot.h"
27 #include "sanitizer_common/sanitizer_symbolizer.h"
31 typedef __asan_global Global
;
33 struct ListOfGlobals
{
38 static Mutex mu_for_globals
;
39 static ListOfGlobals
*list_of_all_globals
;
41 static const int kDynamicInitGlobalsInitialCapacity
= 512;
42 struct DynInitGlobal
{
46 typedef InternalMmapVector
<DynInitGlobal
> VectorOfGlobals
;
47 // Lazy-initialized and never deleted.
48 static VectorOfGlobals
*dynamic_init_globals
;
50 // We want to remember where a certain range of globals was registered.
51 struct GlobalRegistrationSite
{
53 Global
*g_first
, *g_last
;
55 typedef InternalMmapVector
<GlobalRegistrationSite
> GlobalRegistrationSiteVector
;
56 static GlobalRegistrationSiteVector
*global_registration_site_vector
;
58 ALWAYS_INLINE
void PoisonShadowForGlobal(const Global
*g
, u8 value
) {
59 FastPoisonShadow(g
->beg
, g
->size_with_redzone
, value
);
62 ALWAYS_INLINE
void PoisonRedZones(const Global
&g
) {
63 uptr aligned_size
= RoundUpTo(g
.size
, ASAN_SHADOW_GRANULARITY
);
64 FastPoisonShadow(g
.beg
+ aligned_size
, g
.size_with_redzone
- aligned_size
,
65 kAsanGlobalRedzoneMagic
);
66 if (g
.size
!= aligned_size
) {
67 FastPoisonShadowPartialRightRedzone(
68 g
.beg
+ RoundDownTo(g
.size
, ASAN_SHADOW_GRANULARITY
),
69 g
.size
% ASAN_SHADOW_GRANULARITY
, ASAN_SHADOW_GRANULARITY
,
70 kAsanGlobalRedzoneMagic
);
74 const uptr kMinimalDistanceFromAnotherGlobal
= 64;
76 static bool IsAddressNearGlobal(uptr addr
, const __asan_global
&g
) {
77 if (addr
<= g
.beg
- kMinimalDistanceFromAnotherGlobal
) return false;
78 if (addr
>= g
.beg
+ g
.size_with_redzone
) return false;
82 static void ReportGlobal(const Global
&g
, const char *prefix
) {
84 bool symbolized
= Symbolizer::GetOrInit()->SymbolizeData(g
.beg
, &info
);
86 "%s Global[%p]: beg=%p size=%zu/%zu name=%s source=%s module=%s "
89 prefix
, (void *)&g
, (void *)g
.beg
, g
.size
, g
.size_with_redzone
, g
.name
,
90 g
.module_name
, (symbolized
? info
.module
: "?"), g
.has_dynamic_init
,
91 (void *)g
.odr_indicator
);
93 if (symbolized
&& info
.line
!= 0) {
94 Report(" location: name=%s, %d\n", info
.file
, static_cast<int>(info
.line
));
95 } else if (g
.gcc_location
!= 0) {
96 // Fallback to Global::gcc_location
97 Report(" location: name=%s, %d\n", g
.gcc_location
->filename
, g
.gcc_location
->line_no
);
101 static u32
FindRegistrationSite(const Global
*g
) {
102 mu_for_globals
.CheckLocked();
103 CHECK(global_registration_site_vector
);
104 for (uptr i
= 0, n
= global_registration_site_vector
->size(); i
< n
; i
++) {
105 GlobalRegistrationSite
&grs
= (*global_registration_site_vector
)[i
];
106 if (g
>= grs
.g_first
&& g
<= grs
.g_last
)
112 int GetGlobalsForAddress(uptr addr
, Global
*globals
, u32
*reg_sites
,
114 if (!flags()->report_globals
) return 0;
115 Lock
lock(&mu_for_globals
);
117 for (ListOfGlobals
*l
= list_of_all_globals
; l
; l
= l
->next
) {
118 const Global
&g
= *l
->g
;
119 if (flags()->report_globals
>= 2)
120 ReportGlobal(g
, "Search");
121 if (IsAddressNearGlobal(addr
, g
)) {
122 internal_memcpy(&globals
[res
], &g
, sizeof(g
));
124 reg_sites
[res
] = FindRegistrationSite(&g
);
126 if (res
== max_globals
)
133 enum GlobalSymbolState
{
138 // Check ODR violation for given global G via special ODR indicator. We use
139 // this method in case compiler instruments global variables through their
141 static void CheckODRViolationViaIndicator(const Global
*g
) {
142 // Instrumentation requests to skip ODR check.
143 if (g
->odr_indicator
== UINTPTR_MAX
)
145 u8
*odr_indicator
= reinterpret_cast<u8
*>(g
->odr_indicator
);
146 if (*odr_indicator
== UNREGISTERED
) {
147 *odr_indicator
= REGISTERED
;
150 // If *odr_indicator is DEFINED, some module have already registered
151 // externally visible symbol with the same name. This is an ODR violation.
152 for (ListOfGlobals
*l
= list_of_all_globals
; l
; l
= l
->next
) {
153 if (g
->odr_indicator
== l
->g
->odr_indicator
&&
154 (flags()->detect_odr_violation
>= 2 || g
->size
!= l
->g
->size
) &&
155 !IsODRViolationSuppressed(g
->name
))
156 ReportODRViolation(g
, FindRegistrationSite(g
),
157 l
->g
, FindRegistrationSite(l
->g
));
161 // Clang provides two different ways for global variables protection:
162 // it can poison the global itself or its private alias. In former
163 // case we may poison same symbol multiple times, that can help us to
164 // cheaply detect ODR violation: if we try to poison an already poisoned
165 // global, we have ODR violation error.
166 // In latter case, we poison each symbol exactly once, so we use special
167 // indicator symbol to perform similar check.
168 // In either case, compiler provides a special odr_indicator field to Global
169 // structure, that can contain two kinds of values:
170 // 1) Non-zero value. In this case, odr_indicator is an address of
171 // corresponding indicator variable for given global.
172 // 2) Zero. This means that we don't use private aliases for global variables
173 // and can freely check ODR violation with the first method.
175 // This routine chooses between two different methods of ODR violation
177 static inline bool UseODRIndicator(const Global
*g
) {
178 return g
->odr_indicator
> 0;
181 // Register a global variable.
182 // This function may be called more than once for every global
183 // so we store the globals in a map.
184 static void RegisterGlobal(const Global
*g
) {
186 if (flags()->report_globals
>= 2)
187 ReportGlobal(*g
, "Added");
188 CHECK(flags()->report_globals
);
189 CHECK(AddrIsInMem(g
->beg
));
190 if (!AddrIsAlignedByGranularity(g
->beg
)) {
191 Report("The following global variable is not properly aligned.\n");
192 Report("This may happen if another global with the same name\n");
193 Report("resides in another non-instrumented module.\n");
194 Report("Or the global comes from a C file built w/o -fno-common.\n");
195 Report("In either case this is likely an ODR violation bug,\n");
196 Report("but AddressSanitizer can not provide more details.\n");
197 ReportODRViolation(g
, FindRegistrationSite(g
), g
, FindRegistrationSite(g
));
198 CHECK(AddrIsAlignedByGranularity(g
->beg
));
200 CHECK(AddrIsAlignedByGranularity(g
->size_with_redzone
));
201 if (flags()->detect_odr_violation
) {
202 // Try detecting ODR (One Definition Rule) violation, i.e. the situation
203 // where two globals with the same name are defined in different modules.
204 if (UseODRIndicator(g
))
205 CheckODRViolationViaIndicator(g
);
207 if (CanPoisonMemory())
209 ListOfGlobals
*l
= new (GetGlobalLowLevelAllocator()) ListOfGlobals
;
211 l
->next
= list_of_all_globals
;
212 list_of_all_globals
= l
;
213 if (g
->has_dynamic_init
) {
214 if (!dynamic_init_globals
) {
215 dynamic_init_globals
= new (GetGlobalLowLevelAllocator()) VectorOfGlobals
;
216 dynamic_init_globals
->reserve(kDynamicInitGlobalsInitialCapacity
);
218 DynInitGlobal dyn_global
= { *g
, false };
219 dynamic_init_globals
->push_back(dyn_global
);
223 static void UnregisterGlobal(const Global
*g
) {
225 if (flags()->report_globals
>= 2)
226 ReportGlobal(*g
, "Removed");
227 CHECK(flags()->report_globals
);
228 CHECK(AddrIsInMem(g
->beg
));
229 CHECK(AddrIsAlignedByGranularity(g
->beg
));
230 CHECK(AddrIsAlignedByGranularity(g
->size_with_redzone
));
231 if (CanPoisonMemory())
232 PoisonShadowForGlobal(g
, 0);
233 // We unpoison the shadow memory for the global but we do not remove it from
234 // the list because that would require O(n^2) time with the current list
235 // implementation. It might not be worth doing anyway.
237 // Release ODR indicator.
238 if (UseODRIndicator(g
) && g
->odr_indicator
!= UINTPTR_MAX
) {
239 u8
*odr_indicator
= reinterpret_cast<u8
*>(g
->odr_indicator
);
240 *odr_indicator
= UNREGISTERED
;
244 void StopInitOrderChecking() {
245 Lock
lock(&mu_for_globals
);
246 if (!flags()->check_initialization_order
|| !dynamic_init_globals
)
248 flags()->check_initialization_order
= false;
249 for (uptr i
= 0, n
= dynamic_init_globals
->size(); i
< n
; ++i
) {
250 DynInitGlobal
&dyn_g
= (*dynamic_init_globals
)[i
];
251 const Global
*g
= &dyn_g
.g
;
252 // Unpoison the whole global.
253 PoisonShadowForGlobal(g
, 0);
254 // Poison redzones back.
259 static bool IsASCII(unsigned char c
) { return /*0x00 <= c &&*/ c
<= 0x7F; }
261 const char *MaybeDemangleGlobalName(const char *name
) {
262 // We can spoil names of globals with C linkage, so use an heuristic
263 // approach to check if the name should be demangled.
264 bool should_demangle
= false;
265 if (name
[0] == '_' && name
[1] == 'Z')
266 should_demangle
= true;
267 else if (SANITIZER_WINDOWS
&& name
[0] == '\01' && name
[1] == '?')
268 should_demangle
= true;
270 return should_demangle
? Symbolizer::GetOrInit()->Demangle(name
) : name
;
273 // Check if the global is a zero-terminated ASCII string. If so, print it.
274 void PrintGlobalNameIfASCII(InternalScopedString
*str
, const __asan_global
&g
) {
275 for (uptr p
= g
.beg
; p
< g
.beg
+ g
.size
- 1; p
++) {
276 unsigned char c
= *(unsigned char *)p
;
277 if (c
== '\0' || !IsASCII(c
)) return;
279 if (*(char *)(g
.beg
+ g
.size
- 1) != '\0') return;
280 str
->AppendF(" '%s' is ascii string '%s'\n", MaybeDemangleGlobalName(g
.name
),
284 void PrintGlobalLocation(InternalScopedString
*str
, const __asan_global
&g
,
285 bool print_module_name
) {
287 if (Symbolizer::GetOrInit()->SymbolizeData(g
.beg
, &info
) && info
.line
!= 0) {
288 str
->AppendF("%s:%d", info
.file
, static_cast<int>(info
.line
));
289 } else if (g
.gcc_location
!= 0) {
290 // Fallback to Global::gcc_location
291 str
->AppendF("%s", g
.gcc_location
->filename
? g
.gcc_location
->filename
293 if (g
.gcc_location
->line_no
)
294 str
->AppendF(":%d", g
.gcc_location
->line_no
);
295 if (g
.gcc_location
->column_no
)
296 str
->AppendF(":%d", g
.gcc_location
->column_no
);
298 str
->AppendF("%s", g
.module_name
);
300 if (print_module_name
&& info
.module
)
301 str
->AppendF(" in %s", info
.module
);
304 } // namespace __asan
306 // ---------------------- Interface ---------------- {{{1
307 using namespace __asan
;
309 // Apply __asan_register_globals to all globals found in the same loaded
310 // executable or shared library as `flag'. The flag tracks whether globals have
311 // already been registered or not for this image.
312 void __asan_register_image_globals(uptr
*flag
) {
315 AsanApplyToGlobals(__asan_register_globals
, flag
);
319 // This mirrors __asan_register_image_globals.
320 void __asan_unregister_image_globals(uptr
*flag
) {
323 AsanApplyToGlobals(__asan_unregister_globals
, flag
);
327 void __asan_register_elf_globals(uptr
*flag
, void *start
, void *stop
) {
330 CHECK_EQ(0, ((uptr
)stop
- (uptr
)start
) % sizeof(__asan_global
));
331 __asan_global
*globals_start
= (__asan_global
*)start
;
332 __asan_global
*globals_stop
= (__asan_global
*)stop
;
333 __asan_register_globals(globals_start
, globals_stop
- globals_start
);
337 void __asan_unregister_elf_globals(uptr
*flag
, void *start
, void *stop
) {
340 CHECK_EQ(0, ((uptr
)stop
- (uptr
)start
) % sizeof(__asan_global
));
341 __asan_global
*globals_start
= (__asan_global
*)start
;
342 __asan_global
*globals_stop
= (__asan_global
*)stop
;
343 __asan_unregister_globals(globals_start
, globals_stop
- globals_start
);
347 // Register an array of globals.
348 void __asan_register_globals(__asan_global
*globals
, uptr n
) {
349 if (!flags()->report_globals
) return;
350 GET_STACK_TRACE_MALLOC
;
351 u32 stack_id
= StackDepotPut(stack
);
352 Lock
lock(&mu_for_globals
);
353 if (!global_registration_site_vector
) {
354 global_registration_site_vector
=
355 new (GetGlobalLowLevelAllocator()) GlobalRegistrationSiteVector
;
356 global_registration_site_vector
->reserve(128);
358 GlobalRegistrationSite site
= {stack_id
, &globals
[0], &globals
[n
- 1]};
359 global_registration_site_vector
->push_back(site
);
360 if (flags()->report_globals
>= 2) {
361 PRINT_CURRENT_STACK();
362 Printf("=== ID %d; %p %p\n", stack_id
, (void *)&globals
[0],
363 (void *)&globals
[n
- 1]);
365 for (uptr i
= 0; i
< n
; i
++) {
366 if (SANITIZER_WINDOWS
&& globals
[i
].beg
== 0) {
367 // The MSVC incremental linker may pad globals out to 256 bytes. As long
368 // as __asan_global is less than 256 bytes large and its size is a power
369 // of two, we can skip over the padding.
371 sizeof(__asan_global
) < 256 &&
372 (sizeof(__asan_global
) & (sizeof(__asan_global
) - 1)) == 0,
373 "sizeof(__asan_global) incompatible with incremental linker padding");
374 // If these are padding bytes, the rest of the global should be zero.
375 CHECK(globals
[i
].size
== 0 && globals
[i
].size_with_redzone
== 0 &&
376 globals
[i
].name
== nullptr && globals
[i
].module_name
== nullptr &&
377 globals
[i
].odr_indicator
== 0);
380 RegisterGlobal(&globals
[i
]);
383 // Poison the metadata. It should not be accessible to user code.
384 PoisonShadow(reinterpret_cast<uptr
>(globals
), n
* sizeof(__asan_global
),
385 kAsanGlobalRedzoneMagic
);
388 // Unregister an array of globals.
389 // We must do this when a shared objects gets dlclosed.
390 void __asan_unregister_globals(__asan_global
*globals
, uptr n
) {
391 if (!flags()->report_globals
) return;
392 Lock
lock(&mu_for_globals
);
393 for (uptr i
= 0; i
< n
; i
++) {
394 if (SANITIZER_WINDOWS
&& globals
[i
].beg
== 0) {
395 // Skip globals that look like padding from the MSVC incremental linker.
396 // See comment in __asan_register_globals.
399 UnregisterGlobal(&globals
[i
]);
402 // Unpoison the metadata.
403 PoisonShadow(reinterpret_cast<uptr
>(globals
), n
* sizeof(__asan_global
), 0);
406 // This method runs immediately prior to dynamic initialization in each TU,
407 // when all dynamically initialized globals are unpoisoned. This method
408 // poisons all global variables not defined in this TU, so that a dynamic
409 // initializer can only touch global variables in the same TU.
410 void __asan_before_dynamic_init(const char *module_name
) {
411 if (!flags()->check_initialization_order
||
412 !CanPoisonMemory() ||
413 !dynamic_init_globals
)
415 bool strict_init_order
= flags()->strict_init_order
;
418 Lock
lock(&mu_for_globals
);
419 if (flags()->report_globals
>= 3)
420 Printf("DynInitPoison module: %s\n", module_name
);
421 for (uptr i
= 0, n
= dynamic_init_globals
->size(); i
< n
; ++i
) {
422 DynInitGlobal
&dyn_g
= (*dynamic_init_globals
)[i
];
423 const Global
*g
= &dyn_g
.g
;
424 if (dyn_g
.initialized
)
426 if (g
->module_name
!= module_name
)
427 PoisonShadowForGlobal(g
, kAsanInitializationOrderMagic
);
428 else if (!strict_init_order
)
429 dyn_g
.initialized
= true;
433 // This method runs immediately after dynamic initialization in each TU, when
434 // all dynamically initialized globals except for those defined in the current
435 // TU are poisoned. It simply unpoisons all dynamically initialized globals.
436 void __asan_after_dynamic_init() {
437 if (!flags()->check_initialization_order
||
438 !CanPoisonMemory() ||
439 !dynamic_init_globals
)
442 Lock
lock(&mu_for_globals
);
443 // FIXME: Optionally report that we're unpoisoning globals from a module.
444 for (uptr i
= 0, n
= dynamic_init_globals
->size(); i
< n
; ++i
) {
445 DynInitGlobal
&dyn_g
= (*dynamic_init_globals
)[i
];
446 const Global
*g
= &dyn_g
.g
;
447 if (!dyn_g
.initialized
) {
448 // Unpoison the whole global.
449 PoisonShadowForGlobal(g
, 0);
450 // Poison redzones back.