1 //===-- sanitizer_symbolizer_linux.cc -------------------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is shared between AddressSanitizer and ThreadSanitizer
10 // Linux-specific implementation of symbolizer parts.
11 //===----------------------------------------------------------------------===//
13 #include "sanitizer_common.h"
14 #include "sanitizer_internal_defs.h"
15 #include "sanitizer_libc.h"
16 #include "sanitizer_placement_new.h"
17 #include "sanitizer_symbolizer.h"
22 #include <sys/socket.h>
23 #include <sys/types.h>
26 #if !defined(__ANDROID__) && !defined(ANDROID)
30 namespace __sanitizer
{
32 bool StartSymbolizerSubprocess(const char *path_to_symbolizer
,
33 int *input_fd
, int *output_fd
) {
36 // The client program may close its stdin and/or stdout and/or stderr
37 // thus allowing socketpair to reuse file descriptors 0, 1 or 2.
38 // In this case the communication between the forked processes may be
39 // broken if either the parent or the child tries to close or duplicate
40 // these descriptors. The loop below produces two pairs of file
41 // descriptors, each greater than 2 (stderr).
43 for (int i
= 0; i
< 5; i
++) {
44 if (pipe(sock_pair
[i
]) == -1) {
45 for (int j
= 0; j
< i
; j
++) {
46 internal_close(sock_pair
[j
][0]);
47 internal_close(sock_pair
[j
][1]);
49 Report("WARNING: Can't create a socket pair to start "
50 "external symbolizer (errno: %d)\n", errno
);
52 } else if (sock_pair
[i
][0] > 2 && sock_pair
[i
][1] > 2) {
57 for (int j
= 0; j
< i
; j
++) {
58 if (sock_pair
[j
] == infd
) continue;
59 internal_close(sock_pair
[j
][0]);
60 internal_close(sock_pair
[j
][1]);
72 internal_close(infd
[0]);
73 internal_close(infd
[1]);
74 internal_close(outfd
[0]);
75 internal_close(outfd
[1]);
76 Report("WARNING: failed to fork external symbolizer "
77 " (errno: %d)\n", errno
);
79 } else if (pid
== 0) {
81 internal_close(STDOUT_FILENO
);
82 internal_close(STDIN_FILENO
);
83 internal_dup2(outfd
[0], STDIN_FILENO
);
84 internal_dup2(infd
[1], STDOUT_FILENO
);
85 internal_close(outfd
[0]);
86 internal_close(outfd
[1]);
87 internal_close(infd
[0]);
88 internal_close(infd
[1]);
89 for (int fd
= getdtablesize(); fd
> 2; fd
--)
91 execl(path_to_symbolizer
, path_to_symbolizer
, (char*)0);
95 // Continue execution in parent process.
96 internal_close(outfd
[0]);
97 internal_close(infd
[1]);
99 *output_fd
= outfd
[1];
103 #if defined(__ANDROID__) || defined(ANDROID)
104 uptr
GetListOfModules(LoadedModule
*modules
, uptr max_modules
) {
109 typedef ElfW(Phdr
) Elf_Phdr
;
111 struct DlIteratePhdrData
{
112 LoadedModule
*modules
;
117 static const uptr kMaxPathLength
= 512;
119 static int dl_iterate_phdr_cb(dl_phdr_info
*info
, size_t size
, void *arg
) {
120 DlIteratePhdrData
*data
= (DlIteratePhdrData
*)arg
;
121 if (data
->current_n
== data
->max_n
)
123 InternalScopedBuffer
<char> module_name(kMaxPathLength
);
124 module_name
.data()[0] = '\0';
125 if (data
->current_n
== 0) {
126 // First module is the binary itself.
127 uptr module_name_len
= internal_readlink(
128 "/proc/self/exe", module_name
.data(), module_name
.size());
129 CHECK_NE(module_name_len
, (uptr
)-1);
130 CHECK_LT(module_name_len
, module_name
.size());
131 module_name
[module_name_len
] = '\0';
132 } else if (info
->dlpi_name
) {
133 internal_strncpy(module_name
.data(), info
->dlpi_name
, module_name
.size());
135 if (module_name
.data()[0] == '\0')
137 void *mem
= &data
->modules
[data
->current_n
];
138 LoadedModule
*cur_module
= new(mem
) LoadedModule(module_name
.data(),
141 for (int i
= 0; i
< info
->dlpi_phnum
; i
++) {
142 const Elf_Phdr
*phdr
= &info
->dlpi_phdr
[i
];
143 if (phdr
->p_type
== PT_LOAD
) {
144 uptr cur_beg
= info
->dlpi_addr
+ phdr
->p_vaddr
;
145 uptr cur_end
= cur_beg
+ phdr
->p_memsz
;
146 cur_module
->addAddressRange(cur_beg
, cur_end
);
152 uptr
GetListOfModules(LoadedModule
*modules
, uptr max_modules
) {
154 DlIteratePhdrData data
= {modules
, 0, max_modules
};
155 dl_iterate_phdr(dl_iterate_phdr_cb
, &data
);
156 return data
.current_n
;
160 } // namespace __sanitizer