1/*
2 * Copyright (c) 2003, 2013, 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 <sys/types.h>
32#include <sys/wait.h>
33#include <sys/ptrace.h>
34#include <sys/uio.h>
35#include "libproc_impl.h"
36
37#if defined(x86_64) && !defined(amd64)
38#define amd64 1
39#endif
40
41#ifndef __WALL
42#define __WALL          0x40000000  // Copied from /usr/include/linux/wait.h
43#endif
44
45// This file has the libproc implementation specific to live process
46// For core files, refer to ps_core.c
47
48static inline uintptr_t align(uintptr_t ptr, size_t size) {
49  return (ptr & ~(size - 1));
50}
51
52// ---------------------------------------------
53// ptrace functions
54// ---------------------------------------------
55
56// read "size" bytes of data from "addr" within the target process.
57// unlike the standard ptrace() function, process_read_data() can handle
58// unaligned address - alignment check, if required, should be done
59// before calling process_read_data.
60
61static bool process_read_data(struct ps_prochandle* ph, uintptr_t addr, char *buf, size_t size) {
62  long rslt;
63  size_t i, words;
64  uintptr_t end_addr = addr + size;
65  uintptr_t aligned_addr = align(addr, sizeof(long));
66
67  if (aligned_addr != addr) {
68    char *ptr = (char *)&rslt;
69    errno = 0;
70    rslt = ptrace(PTRACE_PEEKDATA, ph->pid, aligned_addr, 0);
71    if (errno) {
72      print_debug("ptrace(PTRACE_PEEKDATA, ..) failed for %d bytes @ %lx\n", size, addr);
73      return false;
74    }
75    for (; aligned_addr != addr; aligned_addr++, ptr++);
76    for (; ((intptr_t)aligned_addr % sizeof(long)) && aligned_addr < end_addr;
77        aligned_addr++)
78       *(buf++) = *(ptr++);
79  }
80
81  words = (end_addr - aligned_addr) / sizeof(long);
82
83  // assert((intptr_t)aligned_addr % sizeof(long) == 0);
84  for (i = 0; i < words; i++) {
85    errno = 0;
86    rslt = ptrace(PTRACE_PEEKDATA, ph->pid, aligned_addr, 0);
87    if (errno) {
88      print_debug("ptrace(PTRACE_PEEKDATA, ..) failed for %d bytes @ %lx\n", size, addr);
89      return false;
90    }
91    *(long *)buf = rslt;
92    buf += sizeof(long);
93    aligned_addr += sizeof(long);
94  }
95
96  if (aligned_addr != end_addr) {
97    char *ptr = (char *)&rslt;
98    errno = 0;
99    rslt = ptrace(PTRACE_PEEKDATA, ph->pid, aligned_addr, 0);
100    if (errno) {
101      print_debug("ptrace(PTRACE_PEEKDATA, ..) failed for %d bytes @ %lx\n", size, addr);
102      return false;
103    }
104    for (; aligned_addr != end_addr; aligned_addr++)
105       *(buf++) = *(ptr++);
106  }
107  return true;
108}
109
110// null implementation for write
111static bool process_write_data(struct ps_prochandle* ph,
112                             uintptr_t addr, const char *buf , size_t size) {
113  return false;
114}
115
116// "user" should be a pointer to a user_regs_struct
117static bool process_get_lwp_regs(struct ps_prochandle* ph, pid_t pid, struct user_regs_struct *user) {
118  // we have already attached to all thread 'pid's, just use ptrace call
119  // to get regset now. Note that we don't cache regset upfront for processes.
120// Linux on x86 and sparc are different.  On x86 ptrace(PTRACE_GETREGS, ...)
121// uses pointer from 4th argument and ignores 3rd argument.  On sparc it uses
122// pointer from 3rd argument and ignores 4th argument
123#if defined(sparc) || defined(sparcv9)
124#define ptrace_getregs(request, pid, addr, data) ptrace(request, pid, addr, data)
125#else
126#define ptrace_getregs(request, pid, addr, data) ptrace(request, pid, data, addr)
127#endif
128
129#if defined(_LP64) && defined(PTRACE_GETREGS64)
130#define PTRACE_GETREGS_REQ PTRACE_GETREGS64
131#elif defined(PTRACE_GETREGS)
132#define PTRACE_GETREGS_REQ PTRACE_GETREGS
133#elif defined(PT_GETREGS)
134#define PTRACE_GETREGS_REQ PT_GETREGS
135#endif
136
137#ifdef PTRACE_GETREGS_REQ
138 if (ptrace_getregs(PTRACE_GETREGS_REQ, pid, user, NULL) < 0) {
139   print_debug("ptrace(PTRACE_GETREGS, ...) failed for lwp %d\n", pid);
140   return false;
141 }
142 return true;
143#elif defined(PTRACE_GETREGSET)
144 struct iovec iov;
145 iov.iov_base = user;
146 iov.iov_len = sizeof(*user);
147 if (ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, (void*) &iov) < 0) {
148   print_debug("ptrace(PTRACE_GETREGSET, ...) failed for lwp %d\n", pid);
149   return false;
150 }
151 return true;
152#else
153 print_debug("ptrace(PTRACE_GETREGS, ...) not supported\n");
154 return false;
155#endif
156
157}
158
159static bool ptrace_continue(pid_t pid, int signal) {
160  // pass the signal to the process so we don't swallow it
161  if (ptrace(PTRACE_CONT, pid, NULL, signal) < 0) {
162    print_debug("ptrace(PTRACE_CONT, ..) failed for %d\n", pid);
163    return false;
164  }
165  return true;
166}
167
168// waits until the ATTACH has stopped the process
169// by signal SIGSTOP
170static bool ptrace_waitpid(pid_t pid) {
171  int ret;
172  int status;
173  while (true) {
174    // Wait for debuggee to stop.
175    ret = waitpid(pid, &status, 0);
176    if (ret == -1 && errno == ECHILD) {
177      // try cloned process.
178      ret = waitpid(pid, &status, __WALL);
179    }
180    if (ret >= 0) {
181      if (WIFSTOPPED(status)) {
182        // Any signal will stop the thread, make sure it is SIGSTOP. Otherwise SIGSTOP
183        // will still be pending and delivered when the process is DETACHED and the process
184        // will go to sleep.
185        if (WSTOPSIG(status) == SIGSTOP) {
186          // Debuggee stopped by SIGSTOP.
187          return true;
188        }
189        if (!ptrace_continue(pid, WSTOPSIG(status))) {
190          print_error("Failed to correctly attach to VM. VM might HANG! [PTRACE_CONT failed, stopped by %d]\n", WSTOPSIG(status));
191          return false;
192        }
193      } else {
194        print_debug("waitpid(): Child process exited/terminated (status = 0x%x)\n", status);
195        return false;
196      }
197    } else {
198      switch (errno) {
199        case EINTR:
200          continue;
201          break;
202        case ECHILD:
203          print_debug("waitpid() failed. Child process pid (%d) does not exist \n", pid);
204          break;
205        case EINVAL:
206          print_debug("waitpid() failed. Invalid options argument.\n");
207          break;
208        default:
209          print_debug("waitpid() failed. Unexpected error %d\n",errno);
210          break;
211      }
212      return false;
213    }
214  }
215}
216
217// attach to a process/thread specified by "pid"
218static bool ptrace_attach(pid_t pid, char* err_buf, size_t err_buf_len) {
219  if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0) {
220    char buf[200];
221    char* msg = strerror_r(errno, buf, sizeof(buf));
222    snprintf(err_buf, err_buf_len, "ptrace(PTRACE_ATTACH, ..) failed for %d: %s", pid, msg);
223    print_debug("%s\n", err_buf);
224    return false;
225  } else {
226    return ptrace_waitpid(pid);
227  }
228}
229
230// -------------------------------------------------------
231// functions for obtaining library information
232// -------------------------------------------------------
233
234/*
235 * splits a string _str_ into substrings with delimiter _delim_ by replacing old * delimiters with _new_delim_ (ideally, '\0'). the address of each substring
236 * is stored in array _ptrs_ as the return value. the maximum capacity of _ptrs_ * array is specified by parameter _n_.
237 * RETURN VALUE: total number of substrings (always <= _n_)
238 * NOTE: string _str_ is modified if _delim_!=_new_delim_
239 */
240static int split_n_str(char * str, int n, char ** ptrs, char delim, char new_delim)
241{
242   int i;
243   for(i = 0; i < n; i++) ptrs[i] = NULL;
244   if (str == NULL || n < 1 ) return 0;
245
246   i = 0;
247
248   // skipping leading blanks
249   while(*str&&*str==delim) str++;
250
251   while(*str&&i<n){
252     ptrs[i++] = str;
253     while(*str&&*str!=delim) str++;
254     while(*str&&*str==delim) *(str++) = new_delim;
255   }
256
257   return i;
258}
259
260/*
261 * fgets without storing '\n' at the end of the string
262 */
263static char * fgets_no_cr(char * buf, int n, FILE *fp)
264{
265   char * rslt = fgets(buf, n, fp);
266   if (rslt && buf && *buf){
267       char *p = strchr(buf, '\0');
268       if (*--p=='\n') *p='\0';
269   }
270   return rslt;
271}
272
273// callback for read_thread_info
274static bool add_new_thread(struct ps_prochandle* ph, pthread_t pthread_id, lwpid_t lwp_id) {
275  return add_thread_info(ph, pthread_id, lwp_id) != NULL;
276}
277
278static bool read_lib_info(struct ps_prochandle* ph) {
279  char fname[32];
280  char buf[PATH_MAX];
281  FILE *fp = NULL;
282
283  sprintf(fname, "/proc/%d/maps", ph->pid);
284  fp = fopen(fname, "r");
285  if (fp == NULL) {
286    print_debug("can't open /proc/%d/maps file\n", ph->pid);
287    return false;
288  }
289
290  while(fgets_no_cr(buf, PATH_MAX, fp)){
291    char * word[7];
292    int nwords = split_n_str(buf, 7, word, ' ', '\0');
293
294    if (nwords < 6) {
295      // not a shared library entry. ignore.
296      continue;
297    }
298
299    // SA does not handle the lines with patterns:
300    //   "[stack]", "[heap]", "[vdso]", "[vsyscall]", etc.
301    if (word[5][0] == '[') {
302        // not a shared library entry. ignore.
303        continue;
304    }
305
306    if (nwords > 6) {
307      // prelink altered mapfile when the program is running.
308      // Entries like one below have to be skipped
309      //  /lib64/libc-2.15.so (deleted)
310      // SO name in entries like one below have to be stripped.
311      //  /lib64/libpthread-2.15.so.#prelink#.EECVts
312      char *s = strstr(word[5],".#prelink#");
313      if (s == NULL) {
314        // No prelink keyword. skip deleted library
315        print_debug("skip shared object %s deleted by prelink\n", word[5]);
316        continue;
317      }
318
319      // Fall through
320      print_debug("rectifying shared object name %s changed by prelink\n", word[5]);
321      *s = 0;
322    }
323
324    if (find_lib(ph, word[5]) == false) {
325       intptr_t base;
326       lib_info* lib;
327#ifdef _LP64
328       sscanf(word[0], "%lx", &base);
329#else
330       sscanf(word[0], "%x", &base);
331#endif
332       if ((lib = add_lib_info(ph, word[5], (uintptr_t)base)) == NULL)
333          continue; // ignore, add_lib_info prints error
334
335       // we don't need to keep the library open, symtab is already
336       // built. Only for core dump we need to keep the fd open.
337       close(lib->fd);
338       lib->fd = -1;
339    }
340  }
341  fclose(fp);
342  return true;
343}
344
345// detach a given pid
346static bool ptrace_detach(pid_t pid) {
347  if (pid && ptrace(PTRACE_DETACH, pid, NULL, NULL) < 0) {
348    print_debug("ptrace(PTRACE_DETACH, ..) failed for %d\n", pid);
349    return false;
350  } else {
351    return true;
352  }
353}
354
355// detach all pids of a ps_prochandle
356static void detach_all_pids(struct ps_prochandle* ph) {
357  thread_info* thr = ph->threads;
358  while (thr) {
359     ptrace_detach(thr->lwp_id);
360     thr = thr->next;
361  }
362}
363
364static void process_cleanup(struct ps_prochandle* ph) {
365  detach_all_pids(ph);
366}
367
368static ps_prochandle_ops process_ops = {
369  .release=  process_cleanup,
370  .p_pread=  process_read_data,
371  .p_pwrite= process_write_data,
372  .get_lwp_regs= process_get_lwp_regs
373};
374
375// attach to the process. One and only one exposed stuff
376struct ps_prochandle* Pgrab(pid_t pid, char* err_buf, size_t err_buf_len) {
377  struct ps_prochandle* ph = NULL;
378  thread_info* thr = NULL;
379
380  if ( (ph = (struct ps_prochandle*) calloc(1, sizeof(struct ps_prochandle))) == NULL) {
381     snprintf(err_buf, err_buf_len, "can't allocate memory for ps_prochandle");
382     print_debug("%s\n", err_buf);
383     return NULL;
384  }
385
386  if (ptrace_attach(pid, err_buf, err_buf_len) != true) {
387     free(ph);
388     return NULL;
389  }
390
391  // initialize ps_prochandle
392  ph->pid = pid;
393
394  // initialize vtable
395  ph->ops = &process_ops;
396
397  // read library info and symbol tables, must do this before attaching threads,
398  // as the symbols in the pthread library will be used to figure out
399  // the list of threads within the same process.
400  read_lib_info(ph);
401
402  // read thread info
403  read_thread_info(ph, add_new_thread);
404
405  // attach to the threads
406  thr = ph->threads;
407  while (thr) {
408     // don't attach to the main thread again
409    if (ph->pid != thr->lwp_id && ptrace_attach(thr->lwp_id, err_buf, err_buf_len) != true) {
410        // even if one attach fails, we get return NULL
411        Prelease(ph);
412        return NULL;
413     }
414     thr = thr->next;
415  }
416  return ph;
417}
418