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