/*

 * Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "salibproc.h"

#include "sun_jvm_hotspot_debugger_proc_ProcDebuggerLocal.h"

#include <thread_db.h>

#include <strings.h>

#include <limits.h>

#include <demangle.h>

#include <stdarg.h>

#include <stdlib.h>

#include <errno.h>

#define CHECK_EXCEPTION_(value) if(env->ExceptionOccurred()) { return value; }

#define CHECK_EXCEPTION if(env->ExceptionOccurred()) { return;}

#define THROW_NEW_DEBUGGER_EXCEPTION_(str, value) { throwNewDebuggerException(env, str); return value; }

#define THROW_NEW_DEBUGGER_EXCEPTION(str) { throwNewDebuggerException(env, str); return;}

#define SYMBOL_BUF_SIZE  256

#define ERR_MSG_SIZE     (PATH_MAX + 256)

// debug modes

static int _libsaproc_debug = 0;

static void print_debug(const char* format,...) {

  if (_libsaproc_debug) {

    va_list alist;

    va_start(alist, format);

    fputs("libsaproc DEBUG: ", stderr);

    vfprintf(stderr, format, alist);

    va_end(alist);

  }

}

struct Debugger {

    JNIEnv* env;

    jobject this_obj;

};

struct DebuggerWithObject : Debugger {

    jobject obj;

};

struct DebuggerWith2Objects : DebuggerWithObject {

    jobject obj2;

};

/*

* Portions of user thread level detail gathering code is from pstack source

* code. See pstack.c in Solaris 2.8 user commands source code.

*/

static void throwNewDebuggerException(JNIEnv* env, const char* errMsg) {

  jclass clazz = env->FindClass("sun/jvm/hotspot/debugger/DebuggerException");

  CHECK_EXCEPTION;

  env->ThrowNew(clazz, errMsg);

}

// JNI ids for some fields, methods

// libproc handler pointer

static jfieldID p_ps_prochandle_ID = 0;

// libthread.so dlopen handle, thread agent ptr and function pointers

static jfieldID libthread_db_handle_ID   = 0;

static jfieldID p_td_thragent_t_ID       = 0;

static jfieldID p_td_init_ID             = 0;

static jfieldID p_td_ta_new_ID           = 0;

static jfieldID p_td_ta_delete_ID        = 0;

static jfieldID p_td_ta_thr_iter_ID      = 0;

static jfieldID p_td_thr_get_info_ID     = 0;

static jfieldID p_td_ta_map_id2thr_ID    = 0;

static jfieldID p_td_thr_getgregs_ID     = 0;

// reg index fields

static jfieldID pcRegIndex_ID            = 0;

static jfieldID fpRegIndex_ID            = 0;

// part of the class sharing workaround

static jfieldID classes_jsa_fd_ID        = 0;

static jfieldID p_file_map_header_ID     = 0;

// method ids

static jmethodID getThreadForThreadId_ID = 0;

static jmethodID createSenderFrame_ID    = 0;

static jmethodID createLoadObject_ID     = 0;

static jmethodID createClosestSymbol_ID  = 0;

static jmethodID listAdd_ID              = 0;

/*

 * Functions we need from libthread_db

 */

typedef td_err_e

        (*p_td_init_t)(void);

typedef td_err_e

        (*p_td_ta_new_t)(void *, td_thragent_t **);

typedef td_err_e

        (*p_td_ta_delete_t)(td_thragent_t *);

typedef td_err_e

        (*p_td_ta_thr_iter_t)(const td_thragent_t *, td_thr_iter_f *, void *,

                td_thr_state_e, int, sigset_t *, unsigned);

typedef td_err_e

        (*p_td_thr_get_info_t)(const td_thrhandle_t *, td_thrinfo_t *);

typedef td_err_e

        (*p_td_ta_map_id2thr_t)(const td_thragent_t *, thread_t,  td_thrhandle_t *);

typedef td_err_e

        (*p_td_thr_getgregs_t)(const td_thrhandle_t *, prgregset_t);

static void

clear_libthread_db_ptrs(JNIEnv* env, jobject this_obj) {

  // release libthread_db agent, if we had created

  p_td_ta_delete_t p_td_ta_delete = 0;

  p_td_ta_delete = (p_td_ta_delete_t) env->GetLongField(this_obj, p_td_ta_delete_ID);

  td_thragent_t *p_td_thragent_t = 0;

  p_td_thragent_t = (td_thragent_t*) env->GetLongField(this_obj, p_td_thragent_t_ID);

  if (p_td_thragent_t != 0 && p_td_ta_delete != 0) {

     p_td_ta_delete(p_td_thragent_t);

  }

  // dlclose libthread_db.so

  void* libthread_db_handle = (void*) env->GetLongField(this_obj, libthread_db_handle_ID);

  if (libthread_db_handle != 0) {

    dlclose(libthread_db_handle);

  }

  env->SetLongField(this_obj, libthread_db_handle_ID, (jlong)0);

  env->SetLongField(this_obj, p_td_init_ID, (jlong)0);

  env->SetLongField(this_obj, p_td_ta_new_ID, (jlong)0);

  env->SetLongField(this_obj, p_td_ta_delete_ID, (jlong)0);

  env->SetLongField(this_obj, p_td_ta_thr_iter_ID, (jlong)0);

  env->SetLongField(this_obj, p_td_thr_get_info_ID, (jlong)0);

  env->SetLongField(this_obj, p_td_ta_map_id2thr_ID, (jlong)0);

  env->SetLongField(this_obj, p_td_thr_getgregs_ID, (jlong)0);

}

static void detach_internal(JNIEnv* env, jobject this_obj) {

  // clear libthread_db stuff

  clear_libthread_db_ptrs(env, this_obj);

  // release ptr to ps_prochandle

  jlong p_ps_prochandle;

  p_ps_prochandle = env->GetLongField(this_obj, p_ps_prochandle_ID);

  if (p_ps_prochandle != 0L) {

    Prelease((struct ps_prochandle*) p_ps_prochandle, PRELEASE_CLEAR);

  }

  // part of the class sharing workaround

  int classes_jsa_fd = env->GetIntField(this_obj, classes_jsa_fd_ID);

  if (classes_jsa_fd != -1) {

    close(classes_jsa_fd);

    struct FileMapHeader* pheader = (struct FileMapHeader*) env->GetLongField(this_obj, p_file_map_header_ID);

    if (pheader != NULL) {

      free(pheader);

    }

  }

}

// Is it okay to ignore libthread_db failure? Set env var to ignore

// libthread_db failure. You can still debug, but will miss threads

// related functionality.

static bool sa_ignore_threaddb = (getenv("SA_IGNORE_THREADDB") != 0);

#define HANDLE_THREADDB_FAILURE(msg)          \

  if (sa_ignore_threaddb) {                   \

     printf("libsaproc WARNING: %s\n", msg);  \

     return;                                  \

  } else {                                    \

     THROW_NEW_DEBUGGER_EXCEPTION(msg);       \

  }

#define HANDLE_THREADDB_FAILURE_(msg, ret)    \

  if (sa_ignore_threaddb) {                   \

     printf("libsaproc WARNING: %s\n", msg);  \

     return ret;                              \

  } else {                                    \

     THROW_NEW_DEBUGGER_EXCEPTION_(msg, ret); \

  }

static const char * alt_root = NULL;

static int alt_root_len = -1;

#define SA_ALTROOT "SA_ALTROOT"

static void init_alt_root() {

  if (alt_root_len == -1) {

    alt_root = getenv(SA_ALTROOT);

    if (alt_root)

      alt_root_len = strlen(alt_root);

    else

      alt_root_len = 0;

  }

}

// This function is a complete substitute for the open system call

// since it's also used to override open calls from libproc to

// implement as a pathmap style facility for the SA.  If libproc

// starts using other interfaces then this might have to extended to

// cover other calls.

extern "C" int libsaproc_open(const char * name, int oflag, ...) {

  if (oflag == O_RDONLY) {

    init_alt_root();

    if (_libsaproc_debug) {

      printf("libsaproc DEBUG: libsaproc_open %s\n", name);

    }

    if (alt_root_len > 0) {

      int fd = -1;

      char alt_path[PATH_MAX+1];

      strcpy(alt_path, alt_root);

      strcat(alt_path, name);

      fd = open(alt_path, O_RDONLY);

      if (fd >= 0) {

        if (_libsaproc_debug) {

          printf("libsaproc DEBUG: libsaproc_open substituted %s\n", alt_path);

        }

        return fd;

      }

      if (strrchr(name, '/')) {

        strcpy(alt_path, alt_root);

        strcat(alt_path, strrchr(name, '/'));

        fd = open(alt_path, O_RDONLY);

        if (fd >= 0) {

          if (_libsaproc_debug) {

            printf("libsaproc DEBUG: libsaproc_open substituted %s\n", alt_path);

          }

          return fd;

        }

      }

    }

  }

  {

    mode_t mode;

    va_list ap;

    va_start(ap, oflag);

    mode = va_arg(ap, mode_t);

    va_end(ap);

    return open(name, oflag, mode);

  }

}

static void * pathmap_dlopen(const char * name, int mode) {

  init_alt_root();

  if (_libsaproc_debug) {

    printf("libsaproc DEBUG: pathmap_dlopen %s\n", name);

  }

  void * handle = NULL;

  if (alt_root_len > 0) {

    char alt_path[PATH_MAX+1];

    strcpy(alt_path, alt_root);

    strcat(alt_path, name);

    handle = dlopen(alt_path, mode);

    if (_libsaproc_debug && handle) {

      printf("libsaproc DEBUG: pathmap_dlopen substituted %s\n", alt_path);

    }

    if (handle == NULL && strrchr(name, '/')) {

      strcpy(alt_path, alt_root);

      strcat(alt_path, strrchr(name, '/'));

      handle = dlopen(alt_path, mode);

      if (_libsaproc_debug && handle) {

        printf("libsaproc DEBUG: pathmap_dlopen substituted %s\n", alt_path);

      }

    }

  }

  if (handle == NULL) {

    handle = dlopen(name, mode);

  }

  if (_libsaproc_debug) {

    printf("libsaproc DEBUG: pathmap_dlopen %s return 0x%lx\n", name, (unsigned long) handle);

  }

  return handle;

}

// libproc and libthread_db callback functions

extern "C" {

static int

init_libthread_db_ptrs(void *cd, const prmap_t *pmp, const char *object_name) {

  Debugger* dbg = (Debugger*) cd;

  JNIEnv* env = dbg->env;

  jobject this_obj = dbg->this_obj;

  struct ps_prochandle* ph = (struct ps_prochandle*) env->GetLongField(this_obj, p_ps_prochandle_ID);

  char *s1 = 0, *s2 = 0;

  char libthread_db[PATH_MAX];

  if (strstr(object_name, "/libthread.so.") == NULL)

     return (0);

  /*

   * We found a libthread.

   * dlopen() the matching libthread_db and get the thread agent handle.

   */

  if (Pstatus(ph)->pr_dmodel == PR_MODEL_NATIVE) {

     (void) strcpy(libthread_db, object_name);

     s1 = (char*) strstr(object_name, ".so.");

     s2 = (char*) strstr(libthread_db, ".so.");

     (void) strcpy(s2, "_db");

     s2 += 3;

     (void) strcpy(s2, s1);

  } else {

#ifdef _LP64

     /*

      * The victim process is 32-bit, we are 64-bit.

      * We have to find the 64-bit version of libthread_db

      * that matches the victim's 32-bit version of libthread.

      */

     (void) strcpy(libthread_db, object_name);

     s1 = (char*) strstr(object_name, "/libthread.so.");

     s2 = (char*) strstr(libthread_db, "/libthread.so.");

     (void) strcpy(s2, "/64");

     s2 += 3;

     (void) strcpy(s2, s1);

     s1 = (char*) strstr(s1, ".so.");

     s2 = (char*) strstr(s2, ".so.");

     (void) strcpy(s2, "_db");

     s2 += 3;

     (void) strcpy(s2, s1);

#else

     return (0);

#endif  /* _LP64 */

  }

  void* libthread_db_handle = 0;

  if ((libthread_db_handle = pathmap_dlopen(libthread_db, RTLD_LAZY|RTLD_LOCAL)) == NULL) {

     char errMsg[PATH_MAX + 256];

     sprintf(errMsg, "Can't load %s!", libthread_db);

     HANDLE_THREADDB_FAILURE_(errMsg, 0);

  }

  env->SetLongField(this_obj, libthread_db_handle_ID, (jlong)(uintptr_t)libthread_db_handle);

  void* tmpPtr = 0;

  tmpPtr = dlsym(libthread_db_handle, "td_init");

  if (tmpPtr == 0) {

     HANDLE_THREADDB_FAILURE_("dlsym failed on td_init!", 0);

  }

  env->SetLongField(this_obj, p_td_init_ID, (jlong)(uintptr_t) tmpPtr);

  tmpPtr =dlsym(libthread_db_handle, "td_ta_new");

  if (tmpPtr == 0) {

     HANDLE_THREADDB_FAILURE_("dlsym failed on td_ta_new!", 0);

  }

  env->SetLongField(this_obj, p_td_ta_new_ID, (jlong)(uintptr_t) tmpPtr);

  tmpPtr = dlsym(libthread_db_handle, "td_ta_delete");

  if (tmpPtr == 0) {

     HANDLE_THREADDB_FAILURE_("dlsym failed on td_ta_delete!", 0);

  }

  env->SetLongField(this_obj, p_td_ta_delete_ID, (jlong)(uintptr_t) tmpPtr);

  tmpPtr = dlsym(libthread_db_handle, "td_ta_thr_iter");

  if (tmpPtr == 0) {

     HANDLE_THREADDB_FAILURE_("dlsym failed on td_ta_thr_iter!", 0);

  }

  env->SetLongField(this_obj, p_td_ta_thr_iter_ID, (jlong)(uintptr_t) tmpPtr);

  tmpPtr = dlsym(libthread_db_handle, "td_thr_get_info");

  if (tmpPtr == 0) {

     HANDLE_THREADDB_FAILURE_("dlsym failed on td_thr_get_info!", 0);

  }

  env->SetLongField(this_obj, p_td_thr_get_info_ID, (jlong)(uintptr_t) tmpPtr);

  tmpPtr = dlsym(libthread_db_handle, "td_ta_map_id2thr");

  if (tmpPtr == 0) {

     HANDLE_THREADDB_FAILURE_("dlsym failed on td_ta_map_id2thr!", 0);

  }

  env->SetLongField(this_obj, p_td_ta_map_id2thr_ID, (jlong)(uintptr_t) tmpPtr);

  tmpPtr = dlsym(libthread_db_handle, "td_thr_getgregs");

  if (tmpPtr == 0) {

     HANDLE_THREADDB_FAILURE_("dlsym failed on td_thr_getgregs!", 0);

  }

  env->SetLongField(this_obj, p_td_thr_getgregs_ID, (jlong)(uintptr_t) tmpPtr);

  return 1;

}

static int

fill_thread_list(const td_thrhandle_t *p_td_thragent_t, void* cd) {

  DebuggerWithObject* dbgo = (DebuggerWithObject*) cd;

  JNIEnv* env = dbgo->env;

  jobject this_obj = dbgo->this_obj;

  jobject list = dbgo->obj;

  td_thrinfo_t thrinfo;

  p_td_thr_get_info_t p_td_thr_get_info = (p_td_thr_get_info_t) env->GetLongField(this_obj, p_td_thr_get_info_ID);

  if (p_td_thr_get_info(p_td_thragent_t, &thrinfo) != TD_OK)

    return (0);

  jobject threadProxy = env->CallObjectMethod(this_obj, getThreadForThreadId_ID, (jlong)(uintptr_t) thrinfo.ti_tid);

  CHECK_EXCEPTION_(1);

  env->CallBooleanMethod(list, listAdd_ID, threadProxy);

  CHECK_EXCEPTION_(1);

  return 0;

}

static int

fill_load_object_list(void *cd, const prmap_t* pmp, const char* obj_name) {

  if (obj_name) {

     DebuggerWithObject* dbgo = (DebuggerWithObject*) cd;

     JNIEnv* env = dbgo->env;

     jobject this_obj = dbgo->this_obj;

     jobject list = dbgo->obj;

     jstring objectName = env->NewStringUTF(obj_name);

     CHECK_EXCEPTION_(1);

     jlong mapSize = (jlong) pmp->pr_size;

     jobject sharedObject = env->CallObjectMethod(this_obj, createLoadObject_ID,

                                  objectName, mapSize, (jlong)(uintptr_t)pmp->pr_vaddr);

     CHECK_EXCEPTION_(1);

     env->CallBooleanMethod(list, listAdd_ID, sharedObject);

     CHECK_EXCEPTION_(1);

  }

  return 0;

}

// Pstack_iter() proc_stack_f callback prior to Nevada-B159

static int

fill_cframe_list(void *cd, const prgregset_t regs, uint_t argc, const long *argv) {

  DebuggerWith2Objects* dbgo2 = (DebuggerWith2Objects*) cd;

  JNIEnv* env = dbgo2->env;

  jobject this_obj = dbgo2->this_obj;

  jobject curFrame = dbgo2->obj2;

  jint pcRegIndex = env->GetIntField(this_obj, pcRegIndex_ID);

  jint fpRegIndex = env->GetIntField(this_obj, fpRegIndex_ID);

  jlong pc = (jlong) (uintptr_t) regs[pcRegIndex];

  jlong fp = (jlong) (uintptr_t) regs[fpRegIndex];

  dbgo2->obj2 = env->CallObjectMethod(this_obj, createSenderFrame_ID,

                                    curFrame, pc, fp);

  CHECK_EXCEPTION_(1);

  if (dbgo2->obj == 0) {

     dbgo2->obj = dbgo2->obj2;

  }

  return 0;

}

// Pstack_iter() proc_stack_f callback in Nevada-B159 or later

/*ARGSUSED*/

static int

wrapper_fill_cframe_list(void *cd, const prgregset_t regs, uint_t argc,

                         const long *argv, int frame_flags, int sig) {

  return(fill_cframe_list(cd, regs, argc, argv));

}

// part of the class sharing workaround

// FIXME: !!HACK ALERT!!

// The format of sharing achive file header is needed to read shared heap

// file mappings. For now, I am hard coding portion of FileMapHeader here.

// Refer to filemap.hpp.

// FileMapHeader describes the shared space data in the file to be

// mapped.  This structure gets written to a file.  It is not a class, so

// that the compilers don't add any compiler-private data to it.

const int NUM_SHARED_MAPS = 4;

// Refer to FileMapInfo::_current_version in filemap.hpp

const int CURRENT_ARCHIVE_VERSION = 1;

struct FileMapHeader {

 int   _magic;              // identify file type.

 int   _version;            // (from enum, above.)

 size_t _alignment;         // how shared archive should be aligned

 struct space_info {

   int    _file_offset;     // sizeof(this) rounded to vm page size

   char*  _base;            // copy-on-write base address

   size_t _capacity;        // for validity checking

   size_t _used;            // for setting space top on read

   bool   _read_only;       // read only space?

   bool   _allow_exec;      // executable code in space?

 } _space[NUM_SHARED_MAPS];

 // Ignore the rest of the FileMapHeader. We don't need those fields here.

};

static bool