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