1 //===-- sanitizer/lsan_interface.h ------------------------------*- C++ -*-===// 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 LeakSanitizer. 10 // 11 // Public interface header. 12 //===----------------------------------------------------------------------===// 13 #ifndef SANITIZER_LSAN_INTERFACE_H 14 #define SANITIZER_LSAN_INTERFACE_H 15 16 #include <sanitizer/common_interface_defs.h> 17 18 #ifdef __cplusplus 19 extern "C" { 20 #endif 21 // Allocations made between calls to __lsan_disable() and __lsan_enable() will 22 // be treated as non-leaks. Disable/enable pairs may be nested. 23 void SANITIZER_CDECL __lsan_disable(void); 24 void SANITIZER_CDECL __lsan_enable(void); 25 26 // The heap object into which p points will be treated as a non-leak. 27 void SANITIZER_CDECL __lsan_ignore_object(const void *p); 28 29 // Memory regions registered through this interface will be treated as sources 30 // of live pointers during leak checking. Useful if you store pointers in 31 // mapped memory. 32 // Points of note: 33 // - __lsan_unregister_root_region() must be called with the same pointer and 34 // size that have earlier been passed to __lsan_register_root_region() 35 // - LSan will skip any inaccessible memory when scanning a root region. E.g., 36 // if you map memory within a larger region that you have mprotect'ed, you can 37 // register the entire large region. 38 // - the implementation is not optimized for performance. This interface is 39 // intended to be used for a small number of relatively static regions. 40 void SANITIZER_CDECL __lsan_register_root_region(const void *p, size_t size); 41 void SANITIZER_CDECL __lsan_unregister_root_region(const void *p, size_t size); 42 43 // Check for leaks now. This function behaves identically to the default 44 // end-of-process leak check. In particular, it will terminate the process if 45 // leaks are found and the exitcode runtime flag is non-zero. 46 // Subsequent calls to this function will have no effect and end-of-process 47 // leak check will not run. Effectively, end-of-process leak check is moved to 48 // the time of first invocation of this function. 49 // By calling this function early during process shutdown, you can instruct 50 // LSan to ignore shutdown-only leaks which happen later on. 51 void SANITIZER_CDECL __lsan_do_leak_check(void); 52 53 // Check for leaks now. Returns zero if no leaks have been found or if leak 54 // detection is disabled, non-zero otherwise. 55 // This function may be called repeatedly, e.g. to periodically check a 56 // long-running process. It prints a leak report if appropriate, but does not 57 // terminate the process. It does not affect the behavior of 58 // __lsan_do_leak_check() or the end-of-process leak check, and is not 59 // affected by them. 60 int SANITIZER_CDECL __lsan_do_recoverable_leak_check(void); 61 62 // The user may optionally provide this function to disallow leak checking 63 // for the program it is linked into (if the return value is non-zero). This 64 // function must be defined as returning a constant value; any behavior beyond 65 // that is unsupported. 66 // To avoid dead stripping, you may need to define this function with 67 // __attribute__((used)) 68 int SANITIZER_CDECL __lsan_is_turned_off(void); 69 70 // This function may be optionally provided by user and should return 71 // a string containing LSan runtime options. See lsan_flags.inc for details. 72 const char *SANITIZER_CDECL __lsan_default_options(void); 73 74 // This function may be optionally provided by the user and should return 75 // a string containing LSan suppressions. 76 const char *SANITIZER_CDECL __lsan_default_suppressions(void); 77 #ifdef __cplusplus 78 } // extern "C" 79 80 namespace __lsan { 81 class ScopedDisabler { 82 public: ScopedDisabler()83 ScopedDisabler() { __lsan_disable(); } ~ScopedDisabler()84 ~ScopedDisabler() { __lsan_enable(); } 85 }; 86 } // namespace __lsan 87 #endif 88 89 #endif // SANITIZER_LSAN_INTERFACE_H 90