1 //===-- sanitizer_symbolizer_linux.cc -------------------------------------===//
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 shared between AddressSanitizer and ThreadSanitizer
11 // run-time libraries.
12 // Linux-specific implementation of symbolizer parts.
13 //===----------------------------------------------------------------------===//
14 #ifdef __linux__
15 #include "sanitizer_common.h"
16 #include "sanitizer_internal_defs.h"
17 #include "sanitizer_libc.h"
18 #include "sanitizer_placement_new.h"
19 #include "sanitizer_symbolizer.h"
20
21 #include <elf.h>
22 #include <errno.h>
23 #include <poll.h>
24 #include <sys/socket.h>
25 #include <sys/types.h>
26 #include <sys/wait.h>
27 #include <unistd.h>
28
29 #if !defined(__ANDROID__) && !defined(ANDROID)
30 #include <link.h>
31 #endif
32
33 namespace __sanitizer {
34
35 static const int kSymbolizerStartupTimeMillis = 10;
36
StartSymbolizerSubprocess(const char * path_to_symbolizer,int * input_fd,int * output_fd)37 bool StartSymbolizerSubprocess(const char *path_to_symbolizer,
38 int *input_fd, int *output_fd) {
39 if (!FileExists(path_to_symbolizer)) {
40 Report("WARNING: invalid path to external symbolizer!\n");
41 return false;
42 }
43
44 int *infd = NULL;
45 int *outfd = NULL;
46 // The client program may close its stdin and/or stdout and/or stderr
47 // thus allowing socketpair to reuse file descriptors 0, 1 or 2.
48 // In this case the communication between the forked processes may be
49 // broken if either the parent or the child tries to close or duplicate
50 // these descriptors. The loop below produces two pairs of file
51 // descriptors, each greater than 2 (stderr).
52 int sock_pair[5][2];
53 for (int i = 0; i < 5; i++) {
54 if (pipe(sock_pair[i]) == -1) {
55 for (int j = 0; j < i; j++) {
56 internal_close(sock_pair[j][0]);
57 internal_close(sock_pair[j][1]);
58 }
59 Report("WARNING: Can't create a socket pair to start "
60 "external symbolizer (errno: %d)\n", errno);
61 return false;
62 } else if (sock_pair[i][0] > 2 && sock_pair[i][1] > 2) {
63 if (infd == NULL) {
64 infd = sock_pair[i];
65 } else {
66 outfd = sock_pair[i];
67 for (int j = 0; j < i; j++) {
68 if (sock_pair[j] == infd) continue;
69 internal_close(sock_pair[j][0]);
70 internal_close(sock_pair[j][1]);
71 }
72 break;
73 }
74 }
75 }
76 CHECK(infd);
77 CHECK(outfd);
78
79 int pid = fork();
80 if (pid == -1) {
81 // Fork() failed.
82 internal_close(infd[0]);
83 internal_close(infd[1]);
84 internal_close(outfd[0]);
85 internal_close(outfd[1]);
86 Report("WARNING: failed to fork external symbolizer "
87 " (errno: %d)\n", errno);
88 return false;
89 } else if (pid == 0) {
90 // Child subprocess.
91 internal_close(STDOUT_FILENO);
92 internal_close(STDIN_FILENO);
93 internal_dup2(outfd[0], STDIN_FILENO);
94 internal_dup2(infd[1], STDOUT_FILENO);
95 internal_close(outfd[0]);
96 internal_close(outfd[1]);
97 internal_close(infd[0]);
98 internal_close(infd[1]);
99 for (int fd = getdtablesize(); fd > 2; fd--)
100 internal_close(fd);
101 execl(path_to_symbolizer, path_to_symbolizer, (char*)0);
102 internal__exit(1);
103 }
104
105 // Continue execution in parent process.
106 internal_close(outfd[0]);
107 internal_close(infd[1]);
108 *input_fd = infd[0];
109 *output_fd = outfd[1];
110
111 // Check that symbolizer subprocess started successfully.
112 int pid_status;
113 SleepForMillis(kSymbolizerStartupTimeMillis);
114 int exited_pid = waitpid(pid, &pid_status, WNOHANG);
115 if (exited_pid != 0) {
116 // Either waitpid failed, or child has already exited.
117 Report("WARNING: external symbolizer didn't start up correctly!\n");
118 return false;
119 }
120
121 return true;
122 }
123
124 #if defined(__ANDROID__) || defined(ANDROID)
GetListOfModules(LoadedModule * modules,uptr max_modules)125 uptr GetListOfModules(LoadedModule *modules, uptr max_modules) {
126 UNIMPLEMENTED();
127 return max_modules;
128 }
129 #else // ANDROID
130 typedef ElfW(Phdr) Elf_Phdr;
131
132 struct DlIteratePhdrData {
133 LoadedModule *modules;
134 uptr current_n;
135 uptr max_n;
136 };
137
138 static const uptr kMaxPathLength = 512;
139
dl_iterate_phdr_cb(dl_phdr_info * info,size_t size,void * arg)140 static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
141 DlIteratePhdrData *data = (DlIteratePhdrData*)arg;
142 if (data->current_n == data->max_n)
143 return 0;
144 InternalScopedBuffer<char> module_name(kMaxPathLength);
145 module_name.data()[0] = '\0';
146 if (data->current_n == 0) {
147 // First module is the binary itself.
148 uptr module_name_len = internal_readlink(
149 "/proc/self/exe", module_name.data(), module_name.size());
150 CHECK_NE(module_name_len, (uptr)-1);
151 CHECK_LT(module_name_len, module_name.size());
152 module_name[module_name_len] = '\0';
153 } else if (info->dlpi_name) {
154 internal_strncpy(module_name.data(), info->dlpi_name, module_name.size());
155 }
156 if (module_name.data()[0] == '\0')
157 return 0;
158 void *mem = &data->modules[data->current_n];
159 LoadedModule *cur_module = new(mem) LoadedModule(module_name.data(),
160 info->dlpi_addr);
161 data->current_n++;
162 for (int i = 0; i < info->dlpi_phnum; i++) {
163 const Elf_Phdr *phdr = &info->dlpi_phdr[i];
164 if (phdr->p_type == PT_LOAD) {
165 uptr cur_beg = info->dlpi_addr + phdr->p_vaddr;
166 uptr cur_end = cur_beg + phdr->p_memsz;
167 cur_module->addAddressRange(cur_beg, cur_end);
168 }
169 }
170 return 0;
171 }
172
GetListOfModules(LoadedModule * modules,uptr max_modules)173 uptr GetListOfModules(LoadedModule *modules, uptr max_modules) {
174 CHECK(modules);
175 DlIteratePhdrData data = {modules, 0, max_modules};
176 dl_iterate_phdr(dl_iterate_phdr_cb, &data);
177 return data.current_n;
178 }
179 #endif // ANDROID
180
181 } // namespace __sanitizer
182
183 #endif // __linux__
184