rev 8073 : 8078521: AARCH64: Add AArch64 SA support
Reviewed-by: kvn

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