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 

    48 static 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 

    61 static 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

   111 static 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

   117 static 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 

   159 static 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

   170 static 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"

   218 static 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  */

   240 static 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  */

   263 static 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

   274 static 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 

   278 static 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

   346 static 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

   356 static 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 

   364 static void process_cleanup(struct ps_prochandle* ph) {

   365   detach_all_pids(ph);

   366 }

   367 

   368 static 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

   376 struct 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 }