1 /*
2 * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <signal.h>
29 #include <errno.h>
30 #include <elf.h>
31 #include <dirent.h>
32 #include <ctype.h>
33 #include <sys/types.h>
34 #include <sys/wait.h>
35 #include <sys/ptrace.h>
36 #include <sys/uio.h>
37 #include "libproc_impl.h"
38
39 #if defined(x86_64) && !defined(amd64)
40 #define amd64 1
41 #endif
42
43 #ifndef __WALL
44 #define __WALL 0x40000000 // Copied from /usr/include/linux/wait.h
45 #endif
46
47 // This file has the libproc implementation specific to live process
48 // For core files, refer to ps_core.c
49
50 typedef enum {
51 ATTACH_SUCCESS,
52 ATTACH_FAIL,
53 ATTACH_THREAD_DEAD
54 } attach_state_t;
55
56 static inline uintptr_t align(uintptr_t ptr, size_t size) {
57 return (ptr & ~(size - 1));
58 }
59
60 // ---------------------------------------------
61 // ptrace functions
62 // ---------------------------------------------
63
64 // read "size" bytes of data from "addr" within the target process.
65 // unlike the standard ptrace() function, process_read_data() can handle
66 // unaligned address - alignment check, if required, should be done
67 // before calling process_read_data.
68
69 static bool process_read_data(struct ps_prochandle* ph, uintptr_t addr, char *buf, size_t size) {
70 long rslt;
71 size_t i, words;
72 uintptr_t end_addr = addr + size;
73 uintptr_t aligned_addr = align(addr, sizeof(long));
74
75 if (aligned_addr != addr) {
76 char *ptr = (char *)&rslt;
77 errno = 0;
78 rslt = ptrace(PTRACE_PEEKDATA, ph->pid, aligned_addr, 0);
79 if (errno) {
80 print_debug("ptrace(PTRACE_PEEKDATA, ..) failed for %d bytes @ %lx\n", size, addr);
81 return false;
82 }
83 for (; aligned_addr != addr; aligned_addr++, ptr++);
84 for (; ((intptr_t)aligned_addr % sizeof(long)) && aligned_addr < end_addr;
85 aligned_addr++)
86 *(buf++) = *(ptr++);
87 }
88
89 words = (end_addr - aligned_addr) / sizeof(long);
90
91 // assert((intptr_t)aligned_addr % sizeof(long) == 0);
92 for (i = 0; i < words; i++) {
93 errno = 0;
94 rslt = ptrace(PTRACE_PEEKDATA, ph->pid, aligned_addr, 0);
95 if (errno) {
96 print_debug("ptrace(PTRACE_PEEKDATA, ..) failed for %d bytes @ %lx\n", size, addr);
97 return false;
98 }
99 *(long *)buf = rslt;
100 buf += sizeof(long);
101 aligned_addr += sizeof(long);
102 }
103
104 if (aligned_addr != end_addr) {
105 char *ptr = (char *)&rslt;
106 errno = 0;
107 rslt = ptrace(PTRACE_PEEKDATA, ph->pid, aligned_addr, 0);
108 if (errno) {
109 print_debug("ptrace(PTRACE_PEEKDATA, ..) failed for %d bytes @ %lx\n", size, addr);
110 return false;
111 }
112 for (; aligned_addr != end_addr; aligned_addr++)
113 *(buf++) = *(ptr++);
114 }
115 return true;
116 }
117
118 // null implementation for write
119 static bool process_write_data(struct ps_prochandle* ph,
120 uintptr_t addr, const char *buf , size_t size) {
121 return false;
122 }
123
124 // "user" should be a pointer to a user_regs_struct
125 static bool process_get_lwp_regs(struct ps_prochandle* ph, pid_t pid, struct user_regs_struct *user) {
126 // we have already attached to all thread 'pid's, just use ptrace call
127 // to get regset now. Note that we don't cache regset upfront for processes.
128 // Linux on x86 and sparc are different. On x86 ptrace(PTRACE_GETREGS, ...)
129 // uses pointer from 4th argument and ignores 3rd argument. On sparc it uses
130 // pointer from 3rd argument and ignores 4th argument
131 #if defined(sparc) || defined(sparcv9)
132 #define ptrace_getregs(request, pid, addr, data) ptrace(request, pid, addr, data)
133 #else
134 #define ptrace_getregs(request, pid, addr, data) ptrace(request, pid, data, addr)
135 #endif
136
137 #if defined(_LP64) && defined(PTRACE_GETREGS64)
138 #define PTRACE_GETREGS_REQ PTRACE_GETREGS64
139 #elif defined(PTRACE_GETREGS)
140 #define PTRACE_GETREGS_REQ PTRACE_GETREGS
141 #elif defined(PT_GETREGS)
142 #define PTRACE_GETREGS_REQ PT_GETREGS
143 #endif
144
145 #ifdef PTRACE_GETREGS_REQ
146 if (ptrace_getregs(PTRACE_GETREGS_REQ, pid, user, NULL) < 0) {
147 print_debug("ptrace(PTRACE_GETREGS, ...) failed for lwp %d\n", pid);
148 return false;
149 }
150 return true;
151 #elif defined(PTRACE_GETREGSET)
152 struct iovec iov;
153 iov.iov_base = user;
154 iov.iov_len = sizeof(*user);
155 if (ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, (void*) &iov) < 0) {
156 print_debug("ptrace(PTRACE_GETREGSET, ...) failed for lwp %d\n", pid);
157 return false;
158 }
159 return true;
160 #else
161 print_debug("ptrace(PTRACE_GETREGS, ...) not supported\n");
162 return false;
163 #endif
164
165 }
166
167 static bool ptrace_continue(pid_t pid, int signal) {
168 // pass the signal to the process so we don't swallow it
169 if (ptrace(PTRACE_CONT, pid, NULL, signal) < 0) {
170 print_debug("ptrace(PTRACE_CONT, ..) failed for %d\n", pid);
171 return false;
172 }
173 return true;
174 }
175
176 // waits until the ATTACH has stopped the process
177 // by signal SIGSTOP
178 static attach_state_t ptrace_waitpid(pid_t pid) {
179 int ret;
180 int status;
181 errno = 0;
182 while (true) {
183 // Wait for debuggee to stop.
184 ret = waitpid(pid, &status, 0);
185 if (ret == -1 && errno == ECHILD) {
186 // try cloned process.
187 ret = waitpid(pid, &status, __WALL);
188 }
189 if (ret >= 0) {
190 if (WIFSTOPPED(status)) {
191 // Any signal will stop the thread, make sure it is SIGSTOP. Otherwise SIGSTOP
192 // will still be pending and delivered when the process is DETACHED and the process
193 // will go to sleep.
194 if (WSTOPSIG(status) == SIGSTOP) {
195 // Debuggee stopped by SIGSTOP.
196 return ATTACH_SUCCESS;
197 }
198 if (!ptrace_continue(pid, WSTOPSIG(status))) {
199 print_error("Failed to correctly attach to VM. VM might HANG! [PTRACE_CONT failed, stopped by %d]\n", WSTOPSIG(status));
200 return ATTACH_FAIL;
201 }
202 } else {
203 print_debug("waitpid(): Child process %d exited/terminated (status = 0x%x)\n", pid, status);
204 return ATTACH_THREAD_DEAD;
205 }
206 } else {
207 switch (errno) {
208 case EINTR:
209 continue;
210 break;
211 case ECHILD:
212 print_debug("waitpid() failed. Child process pid (%d) does not exist \n", pid);
213 return ATTACH_THREAD_DEAD;
214 case EINVAL:
215 print_error("waitpid() failed. Invalid options argument.\n");
216 return ATTACH_FAIL;
217 default:
218 print_error("waitpid() failed. Unexpected error %d\n", errno);
219 return ATTACH_FAIL;
220 }
221 } // else
222 } // while
223 }
224
225 // checks the state of the thread/process specified by "pid", by reading
226 // in the 'State:' value from the /proc/<pid>/status file. From the proc
227 // man page, "Current state of the process. One of "R (running)",
228 // "S (sleeping)", "D (disk sleep)", "T (stopped)", "T (tracing stop)",
229 // "Z (zombie)", or "X (dead)"." Assumes that the thread is dead if we
230 // don't find the status file or if the status is 'X' or 'Z'.
231 static bool process_doesnt_exist(pid_t pid) {
232 char fname[32];
233 char buf[30];
234 FILE *fp = NULL;
235 const char state_string[] = "State:";
236
237 sprintf(fname, "/proc/%d/status", pid);
238 fp = fopen(fname, "r");
239 if (fp == NULL) {
240 print_debug("can't open /proc/%d/status file\n", pid);
241 // Assume the thread does not exist anymore.
242 return true;
243 }
244 bool found_state = false;
245 size_t state_len = strlen(state_string);
246 while (fgets(buf, sizeof(buf), fp) != NULL) {
247 char *state = NULL;
248 if (strncmp (buf, state_string, state_len) == 0) {
249 found_state = true;
250 state = buf + state_len;
251 // Skip the spaces
252 while (isspace(*state)) {
253 state++;
254 }
255 // A state value of 'X' indicates that the thread is dead. 'Z'
256 // indicates that the thread is a zombie.
257 if (*state == 'X' || *state == 'Z') {
258 fclose (fp);
259 return true;
260 }
261 break;
262 }
263 }
264 // If the state value is not 'X' or 'Z', the thread exists.
265 if (!found_state) {
266 // We haven't found the line beginning with 'State:'.
267 // Assuming the thread exists.
268 print_error("Could not find the 'State:' string in the /proc/%d/status file\n", pid);
269 }
270 fclose (fp);
271 return false;
272 }
273
274 // attach to a process/thread specified by "pid"
275 static attach_state_t ptrace_attach(pid_t pid, char* err_buf, size_t err_buf_len) {
276 errno = 0;
277 if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0) {
278 if (errno == EPERM || errno == ESRCH) {
279 // Check if the process/thread is exiting or is a zombie
280 if (process_doesnt_exist(pid)) {
281 print_debug("Thread with pid %d does not exist\n", pid);
282 return ATTACH_THREAD_DEAD;
283 }
284 }
285 char buf[200];
286 char* msg = strerror_r(errno, buf, sizeof(buf));
287 snprintf(err_buf, err_buf_len, "ptrace(PTRACE_ATTACH, ..) failed for %d: %s", pid, msg);
288 print_error("%s\n", err_buf);
289 return ATTACH_FAIL;
290 } else {
291 attach_state_t wait_ret = ptrace_waitpid(pid);
292 if (wait_ret == ATTACH_THREAD_DEAD) {
293 print_debug("Thread with pid %d does not exist\n", pid);
294 }
295 return wait_ret;
296 }
297 }
298
299 // -------------------------------------------------------
300 // functions for obtaining library information
301 // -------------------------------------------------------
302
303 /*
304 * splits a string _str_ into substrings with delimiter _delim_ by replacing old * delimiters with _new_delim_ (ideally, '\0'). the address of each substring
305 * is stored in array _ptrs_ as the return value. the maximum capacity of _ptrs_ * array is specified by parameter _n_.
306 * RETURN VALUE: total number of substrings (always <= _n_)
307 * NOTE: string _str_ is modified if _delim_!=_new_delim_
308 */
309 static int split_n_str(char * str, int n, char ** ptrs, char delim, char new_delim)
310 {
311 int i;
312 for(i = 0; i < n; i++) ptrs[i] = NULL;
313 if (str == NULL || n < 1 ) return 0;
314
315 i = 0;
316
317 // skipping leading blanks
318 while(*str&&*str==delim) str++;
319
320 while(*str&&i<n){
321 ptrs[i++] = str;
322 while(*str&&*str!=delim) str++;
323 while(*str&&*str==delim) *(str++) = new_delim;
324 }
325
326 return i;
327 }
328
329 /*
330 * fgets without storing '\n' at the end of the string
331 */
332 static char * fgets_no_cr(char * buf, int n, FILE *fp)
333 {
334 char * rslt = fgets(buf, n, fp);
335 if (rslt && buf && *buf){
336 char *p = strchr(buf, '\0');
337 if (*--p=='\n') *p='\0';
338 }
339 return rslt;
340 }
341
342 // callback for read_thread_info
343 static bool add_new_thread(struct ps_prochandle* ph, pthread_t pthread_id, lwpid_t lwp_id) {
344 return add_thread_info(ph, pthread_id, lwp_id) != NULL;
345 }
346
347 static bool read_lib_info(struct ps_prochandle* ph) {
348 char fname[32];
349 char buf[PATH_MAX];
350 FILE *fp = NULL;
351
352 sprintf(fname, "/proc/%d/maps", ph->pid);
353 fp = fopen(fname, "r");
354 if (fp == NULL) {
355 print_debug("can't open /proc/%d/maps file\n", ph->pid);
356 return false;
357 }
358
359 while(fgets_no_cr(buf, PATH_MAX, fp)){
360 char * word[7];
361 int nwords = split_n_str(buf, 7, word, ' ', '\0');
362
363 if (nwords < 6) {
364 // not a shared library entry. ignore.
365 continue;
366 }
367
368 // SA does not handle the lines with patterns:
369 // "[stack]", "[heap]", "[vdso]", "[vsyscall]", etc.
370 if (word[5][0] == '[') {
371 // not a shared library entry. ignore.
372 continue;
373 }
374
375 if (nwords > 6) {
376 // prelink altered mapfile when the program is running.
377 // Entries like one below have to be skipped
378 // /lib64/libc-2.15.so (deleted)
379 // SO name in entries like one below have to be stripped.
380 // /lib64/libpthread-2.15.so.#prelink#.EECVts
381 char *s = strstr(word[5],".#prelink#");
382 if (s == NULL) {
383 // No prelink keyword. skip deleted library
384 print_debug("skip shared object %s deleted by prelink\n", word[5]);
385 continue;
386 }
387
388 // Fall through
389 print_debug("rectifying shared object name %s changed by prelink\n", word[5]);
390 *s = 0;
391 }
392
393 if (find_lib(ph, word[5]) == false) {
394 intptr_t base;
395 lib_info* lib;
396 #ifdef _LP64
397 sscanf(word[0], "%lx", &base);
398 #else
399 sscanf(word[0], "%x", &base);
400 #endif
401 if ((lib = add_lib_info(ph, word[5], (uintptr_t)base)) == NULL)
402 continue; // ignore, add_lib_info prints error
403
404 // we don't need to keep the library open, symtab is already
405 // built. Only for core dump we need to keep the fd open.
406 close(lib->fd);
407 lib->fd = -1;
408 }
409 }
410 fclose(fp);
411 return true;
412 }
413
414 // detach a given pid
415 static bool ptrace_detach(pid_t pid) {
416 if (pid && ptrace(PTRACE_DETACH, pid, NULL, NULL) < 0) {
417 print_debug("ptrace(PTRACE_DETACH, ..) failed for %d\n", pid);
418 return false;
419 } else {
420 return true;
421 }
422 }
423
424 // detach all pids of a ps_prochandle
425 static void detach_all_pids(struct ps_prochandle* ph) {
426 thread_info* thr = ph->threads;
427 while (thr) {
428 ptrace_detach(thr->lwp_id);
429 thr = thr->next;
430 }
431 }
432
433 static void process_cleanup(struct ps_prochandle* ph) {
434 detach_all_pids(ph);
435 }
436
437 static ps_prochandle_ops process_ops = {
438 .release= process_cleanup,
439 .p_pread= process_read_data,
440 .p_pwrite= process_write_data,
441 .get_lwp_regs= process_get_lwp_regs
442 };
443
444 // attach to the process. One and only one exposed stuff
445 JNIEXPORT struct ps_prochandle* JNICALL
446 Pgrab(pid_t pid, char* err_buf, size_t err_buf_len, bool is_in_container) {
447 struct ps_prochandle* ph = NULL;
448 thread_info* thr = NULL;
449 attach_state_t attach_status = ATTACH_SUCCESS;
450
451 if ( (ph = (struct ps_prochandle*) calloc(1, sizeof(struct ps_prochandle))) == NULL) {
452 snprintf(err_buf, err_buf_len, "can't allocate memory for ps_prochandle");
453 print_debug("%s\n", err_buf);
454 return NULL;
455 }
456
457 if ((attach_status = ptrace_attach(pid, err_buf, err_buf_len)) != ATTACH_SUCCESS) {
458 if (attach_status == ATTACH_THREAD_DEAD) {
459 print_error("The process with pid %d does not exist.\n", pid);
460 }
461 free(ph);
462 return NULL;
463 }
464
465 // initialize ps_prochandle
466 ph->pid = pid;
467
468 // initialize vtable
469 ph->ops = &process_ops;
470
471 // read library info and symbol tables, must do this before attaching threads,
472 // as the symbols in the pthread library will be used to figure out
473 // the list of threads within the same process.
474 read_lib_info(ph);
475
476 // read thread info
477 if (is_in_container) {
478 /*
479 * If the process is running in the container, SA scans all tasks in
480 * /proc/<PID>/task to read all threads info.
481 */
482 char taskpath[PATH_MAX];
483 DIR *dirp;
484 struct dirent *entry;
485
486 snprintf(taskpath, PATH_MAX, "/proc/%d/task", ph->pid);
487 dirp = opendir(taskpath);
488 int lwp_id;
489 while ((entry = readdir(dirp)) != NULL) {
490 if (*entry->d_name == '.') {
491 continue;
492 }
493 lwp_id = atoi(entry->d_name);
494 if (lwp_id == ph->pid) {
495 continue;
496 }
497 add_new_thread(ph, -1, lwp_id);
498 }
499 closedir(dirp);
500 } else {
501 read_thread_info(ph, add_new_thread);
502 }
503
504 // attach to the threads
505 thr = ph->threads;
506
507 while (thr) {
508 thread_info* current_thr = thr;
509 thr = thr->next;
510 // don't attach to the main thread again
511 if (ph->pid != current_thr->lwp_id) {
512 if ((attach_status = ptrace_attach(current_thr->lwp_id, err_buf, err_buf_len)) != ATTACH_SUCCESS) {
513 if (attach_status == ATTACH_THREAD_DEAD) {
514 // Remove this thread from the threads list
515 delete_thread_info(ph, current_thr);
516 }
517 else {
518 Prelease(ph);
519 return NULL;
520 } // ATTACH_THREAD_DEAD
521 } // !ATTACH_SUCCESS
522 }
523 }
524 return ph;
525 }