/*

 * Copyright 2002-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

// this is source code windbg based SA debugger agent to debug

// Dr. Watson dump files and process snapshots.

#include "sun_jvm_hotspot_debugger_windbg_WindbgDebuggerLocal.h"

#ifdef _M_IA64

  #include "sun_jvm_hotspot_debugger_ia64_IA64ThreadContext.h"

  #define NPRGREG sun_jvm_hotspot_debugger_ia64_IA64ThreadContext_NPRGREG

#elif _M_IX86

  #include "sun_jvm_hotspot_debugger_x86_X86ThreadContext.h"

  #define NPRGREG sun_jvm_hotspot_debugger_x86_X86ThreadContext_NPRGREG

#elif _M_AMD64

  #include "sun_jvm_hotspot_debugger_amd64_AMD64ThreadContext.h"

  #define NPRGREG sun_jvm_hotspot_debugger_amd64_AMD64ThreadContext_NPRGREG

#else

  #error "SA windbg back-end is not supported for your cpu!"

#endif

#include <limits.h>

#include <windows.h>

#ifndef STDMETHODV

#define STDMETHODV(method) virtual HRESULT STDMETHODVCALLTYPE method

#endif

#define DEBUG_NO_IMPLEMENTATION

#include <dbgeng.h>

#include <dbghelp.h>

// simple template to manage array delete across early (error) returns

template <class T>

class AutoArrayPtr {

      T* m_ptr;

   public:

      AutoArrayPtr(T* ptr) : m_ptr(ptr) {

      }

      ~AutoArrayPtr() {

         delete [] m_ptr;

      }

      T* asPtr() {

         return m_ptr;

      }

};

class AutoJavaString {

      JNIEnv* m_env;

      jstring m_str;

      const char* m_buf;

   public:

      AutoJavaString(JNIEnv* env, jstring str, const char* buf)

        : m_env(env), m_str(str), m_buf(buf) {

      }

      ~AutoJavaString() {

         m_env->ReleaseStringUTFChars(m_str, m_buf);

      }

      operator const char* () {

         return m_buf;

      }

};

// field and method IDs we want here

static jfieldID imagePath_ID                    = 0;

static jfieldID symbolPath_ID                   = 0;

static jfieldID ptrIDebugClient_ID              = 0;

static jfieldID ptrIDebugControl_ID             = 0;

static jfieldID ptrIDebugDataSpaces_ID          = 0;

static jfieldID ptrIDebugOutputCallbacks_ID     = 0;

static jfieldID ptrIDebugAdvanced_ID            = 0;

static jfieldID ptrIDebugSymbols_ID             = 0;

static jfieldID ptrIDebugSystemObjects_ID       = 0;

static jmethodID addLoadObject_ID               = 0;

static jmethodID addThread_ID                   = 0;

static jmethodID createClosestSymbol_ID         = 0;

static jmethodID setThreadIntegerRegisterSet_ID = 0;

#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;}

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

  env->ThrowNew(env->FindClass("sun/jvm/hotspot/debugger/DebuggerException"), errMsg);

}

/*

 * Class:     sun_jvm_hotspot_debugger_windbg_WindbgDebuggerLocal

 * Method:    initIDs

 * Signature: ()V

 */

JNIEXPORT void JNICALL Java_sun_jvm_hotspot_debugger_windbg_WindbgDebuggerLocal_initIDs

  (JNIEnv *env, jclass clazz) {

  imagePath_ID = env->GetStaticFieldID(clazz, "imagePath", "Ljava/lang/String;");

  CHECK_EXCEPTION;

  symbolPath_ID = env->GetStaticFieldID(clazz, "symbolPath", "Ljava/lang/String;");

  CHECK_EXCEPTION;

  ptrIDebugClient_ID = env->GetFieldID(clazz, "ptrIDebugClient", "J");

  CHECK_EXCEPTION;

  ptrIDebugControl_ID = env->GetFieldID(clazz, "ptrIDebugControl", "J");

  CHECK_EXCEPTION;

  ptrIDebugDataSpaces_ID = env->GetFieldID(clazz, "ptrIDebugDataSpaces", "J");

  CHECK_EXCEPTION;

  ptrIDebugOutputCallbacks_ID = env->GetFieldID(clazz,

                                            "ptrIDebugOutputCallbacks", "J");

  CHECK_EXCEPTION;

  ptrIDebugAdvanced_ID = env->GetFieldID(clazz, "ptrIDebugAdvanced", "J");

  CHECK_EXCEPTION;

  ptrIDebugSymbols_ID = env->GetFieldID(clazz,

                                         "ptrIDebugSymbols", "J");

  CHECK_EXCEPTION;

  ptrIDebugSystemObjects_ID = env->GetFieldID(clazz,

                                         "ptrIDebugSystemObjects", "J");

  CHECK_EXCEPTION;

  addLoadObject_ID = env->GetMethodID(clazz, "addLoadObject",

                                         "(Ljava/lang/String;JJ)V");

  CHECK_EXCEPTION;

  addThread_ID = env->GetMethodID(clazz, "addThread", "(J)V");

  CHECK_EXCEPTION;

  createClosestSymbol_ID = env->GetMethodID(clazz, "createClosestSymbol",

    "(Ljava/lang/String;J)Lsun/jvm/hotspot/debugger/cdbg/ClosestSymbol;");

  CHECK_EXCEPTION;

  setThreadIntegerRegisterSet_ID = env->GetMethodID(clazz,

                                         "setThreadIntegerRegisterSet", "(J[J)V");

  CHECK_EXCEPTION;

}

// class for IDebugOutputCallbacks

class SAOutputCallbacks : public IDebugOutputCallbacks {

   LONG  m_refCount;

   char* m_msgBuffer;

   public:

      SAOutputCallbacks() : m_refCount(0), m_msgBuffer(0) {

      }

      ~SAOutputCallbacks() {

         clearBuffer();

      }

      const char* getBuffer() const {

         return m_msgBuffer;

      }

      void clearBuffer() {

         if (m_msgBuffer) {

            free(m_msgBuffer);

            m_msgBuffer = 0;

         }

      }

      STDMETHOD_(ULONG, AddRef)(THIS);

      STDMETHOD_(ULONG, Release)(THIS);

      STDMETHOD(QueryInterface)(THIS_

                                IN REFIID interfaceId,

                                OUT PVOID* ppInterface);

      STDMETHOD(Output)(THIS_

                        IN ULONG mask,

                        IN PCSTR msg);

};

STDMETHODIMP_(ULONG) SAOutputCallbacks::AddRef(THIS) {

   InterlockedIncrement(&m_refCount);

   return m_refCount;

}

STDMETHODIMP_(ULONG) SAOutputCallbacks::Release(THIS) {

   LONG retVal;

   InterlockedDecrement(&m_refCount);

   retVal = m_refCount;

   if (retVal == 0) {

      delete this;

   }

   return retVal;

}

STDMETHODIMP SAOutputCallbacks::QueryInterface(THIS_

                                          IN REFIID interfaceId,

                                          OUT PVOID* ppInterface) {

   *ppInterface = 0;

   HRESULT res = E_NOINTERFACE;

   if (TRUE == IsEqualIID(interfaceId, __uuidof(IUnknown)) ||

       TRUE == IsEqualIID(interfaceId, __uuidof(IDebugOutputCallbacks))) {

      *ppInterface = (IDebugOutputCallbacks*) this;

      AddRef();

      res = S_OK;

   }

   return res;

}

STDMETHODIMP SAOutputCallbacks::Output(THIS_

                                       IN ULONG mask,

                                       IN PCSTR msg) {

   int len = (int) (strlen(msg) + 1);

   if (m_msgBuffer == 0) {

      m_msgBuffer = (char*) malloc(len);

      if (m_msgBuffer == 0) {

         fprintf(stderr, "out of memory debugger output!\n");

         return S_FALSE;

      }

      strcpy(m_msgBuffer, msg);

   } else {

      m_msgBuffer = (char*) realloc(m_msgBuffer, len + strlen(m_msgBuffer));

      if (m_msgBuffer == 0) {

         fprintf(stderr, "out of memory debugger output!\n");

         return S_FALSE;

      }

      strcat(m_msgBuffer, msg);

   }

   return S_OK;

}

static bool getWindbgInterfaces(JNIEnv* env, jobject obj) {

  // get windbg interfaces ..

  IDebugClient* ptrIDebugClient = 0;

  if (DebugCreate(__uuidof(IDebugClient), (PVOID*) &ptrIDebugClient) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: not able to create IDebugClient object!", false);

  }

  env->SetLongField(obj, ptrIDebugClient_ID, (jlong) ptrIDebugClient);

  IDebugControl* ptrIDebugControl = 0;

  if (ptrIDebugClient->QueryInterface(__uuidof(IDebugControl), (PVOID*) &ptrIDebugControl)

     != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: not able to get IDebugControl", false);

  }

  env->SetLongField(obj, ptrIDebugControl_ID, (jlong) ptrIDebugControl);

  IDebugDataSpaces* ptrIDebugDataSpaces = 0;

  if (ptrIDebugClient->QueryInterface(__uuidof(IDebugDataSpaces), (PVOID*) &ptrIDebugDataSpaces)

     != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: not able to get IDebugDataSpaces object!", false);

  }

  env->SetLongField(obj, ptrIDebugDataSpaces_ID, (jlong) ptrIDebugDataSpaces);

  SAOutputCallbacks* ptrIDebugOutputCallbacks = new SAOutputCallbacks();

  ptrIDebugOutputCallbacks->AddRef();

  env->SetLongField(obj, ptrIDebugOutputCallbacks_ID, (jlong) ptrIDebugOutputCallbacks);

  CHECK_EXCEPTION_(false);

  IDebugAdvanced* ptrIDebugAdvanced = 0;

  if (ptrIDebugClient->QueryInterface(__uuidof(IDebugAdvanced), (PVOID*) &ptrIDebugAdvanced)

     != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: not able to get IDebugAdvanced object!", false);

  }

  env->SetLongField(obj, ptrIDebugAdvanced_ID, (jlong) ptrIDebugAdvanced);

  IDebugSymbols* ptrIDebugSymbols = 0;

  if (ptrIDebugClient->QueryInterface(__uuidof(IDebugSymbols), (PVOID*) &ptrIDebugSymbols)

     != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: not able to get IDebugSymbols object!", false);

  }

  env->SetLongField(obj, ptrIDebugSymbols_ID, (jlong) ptrIDebugSymbols);

  IDebugSystemObjects* ptrIDebugSystemObjects = 0;

  if (ptrIDebugClient->QueryInterface(__uuidof(IDebugSystemObjects), (PVOID*) &ptrIDebugSystemObjects)

     != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: not able to get IDebugSystemObjects object!", false);

  }

  env->SetLongField(obj, ptrIDebugSystemObjects_ID, (jlong) ptrIDebugSystemObjects);

  return true;

}

static bool setImageAndSymbolPath(JNIEnv* env, jobject obj) {

  jboolean isCopy;

  jclass clazz = env->GetObjectClass(obj);

  jstring path;

  const char* buf;

  path = (jstring) env->GetStaticObjectField(clazz, imagePath_ID);

  buf = env->GetStringUTFChars(path, &isCopy);

  CHECK_EXCEPTION_(false);

  AutoJavaString imagePath(env, path, buf);

  path = (jstring) env->GetStaticObjectField(clazz, symbolPath_ID);

  buf = env->GetStringUTFChars(path, &isCopy);

  CHECK_EXCEPTION_(false);

  AutoJavaString symbolPath(env, path, buf);

  IDebugSymbols* ptrIDebugSymbols = (IDebugSymbols*) env->GetLongField(obj,

                                                      ptrIDebugSymbols_ID);

  CHECK_EXCEPTION_(false);

  ptrIDebugSymbols->SetImagePath(imagePath);

  ptrIDebugSymbols->SetSymbolPath(symbolPath);

  return true;

}

static bool openDumpFile(JNIEnv* env, jobject obj, jstring coreFileName) {

  // open the dump file

  jboolean isCopy;

  const char* buf = env->GetStringUTFChars(coreFileName, &isCopy);

  CHECK_EXCEPTION_(false);

  AutoJavaString coreFile(env, coreFileName, buf);

  if (setImageAndSymbolPath(env, obj) == false) {

     return false;

  }

  IDebugClient* ptrIDebugClient = (IDebugClient*) env->GetLongField(obj,

                                                      ptrIDebugClient_ID);

  CHECK_EXCEPTION_(false);

  if (ptrIDebugClient->OpenDumpFile(coreFile) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: OpenDumpFile failed!", false);

  }

  IDebugControl* ptrIDebugControl = (IDebugControl*) env->GetLongField(obj,

                                                     ptrIDebugControl_ID);

  CHECK_EXCEPTION_(false);

  if (ptrIDebugControl->WaitForEvent(DEBUG_WAIT_DEFAULT, INFINITE) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: WaitForEvent failed!", false);

  }

  return true;

}

static bool attachToProcess(JNIEnv* env, jobject obj, jint pid) {

  if (setImageAndSymbolPath(env, obj) == false) {

     return false;

  }

  IDebugClient* ptrIDebugClient = (IDebugClient*) env->GetLongField(obj,

                                                      ptrIDebugClient_ID);

  CHECK_EXCEPTION_(false);

  /***********************************************************************************

     We are attaching to a process in 'read-only' mode. i.e., we do not want to

     put breakpoints, suspend/resume threads etc. For read-only JDI and HSDB kind of

     usage this should suffice. We are not intending to use this for full-fledged

     ProcessControl implementation to be used with BugSpotAgent.

     Please refer to DEBUG_ATTACH_NONINVASIVE mode source comments from dbgeng.h.

     In this mode, debug engine does not call DebugActiveProrcess. i.e., we are not

     actually debugging at all. We can safely 'detach' from the process anytime

     we want and debuggee process is left as is on all Windows variants.

     This also makes JDI-on-SA installation/usage simpler because with this we would

     not need a tool like ServiceInstaller from http://www.kcmultimedia.com/smaster.

  ***********************************************************************************/

  if (ptrIDebugClient->AttachProcess(0, pid, DEBUG_ATTACH_NONINVASIVE) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: AttachProcess failed!", false);

  }

  IDebugControl* ptrIDebugControl = (IDebugControl*) env->GetLongField(obj,

                                                     ptrIDebugControl_ID);

  CHECK_EXCEPTION_(false);

  if (ptrIDebugControl->WaitForEvent(DEBUG_WAIT_DEFAULT, INFINITE) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: WaitForEvent failed!", false);

  }

  return true;

}

static bool addLoadObjects(JNIEnv* env, jobject obj) {

  IDebugSymbols* ptrIDebugSymbols = (IDebugSymbols*) env->GetLongField(obj,

                                                      ptrIDebugSymbols_ID);

  CHECK_EXCEPTION_(false);

  ULONG loaded = 0, unloaded = 0;

  if (ptrIDebugSymbols->GetNumberModules(&loaded, &unloaded) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: GetNumberModules failed!", false);

  }

  AutoArrayPtr<DEBUG_MODULE_PARAMETERS> params(new DEBUG_MODULE_PARAMETERS[loaded]);

  if (params.asPtr() == 0) {

      THROW_NEW_DEBUGGER_EXCEPTION_("out of memory to allocate debug module params!", false);

  }

  if (ptrIDebugSymbols->GetModuleParameters(loaded, 0, NULL, params.asPtr()) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: GetModuleParameters failed!", false);

  }

  for (int u = 0; u < (int)loaded; u++) {

     TCHAR imageName[MAX_PATH];

     if (ptrIDebugSymbols->GetModuleNames(DEBUG_ANY_ID, params.asPtr()[u].Base,

                                      imageName, MAX_PATH, NULL, NULL,

                                      0, NULL, NULL, 0, NULL) != S_OK) {

        THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: GetModuleNames failed!", false);

     }

     jstring strName = env->NewStringUTF(imageName);

     CHECK_EXCEPTION_(false);

     env->CallVoidMethod(obj, addLoadObject_ID, strName, (jlong) params.asPtr()[u].Size,

                               (jlong) params.asPtr()[u].Base);

     CHECK_EXCEPTION_(false);

  }

  return true;

}

static bool addThreads(JNIEnv* env, jobject obj) {

  IDebugSystemObjects* ptrIDebugSystemObjects = (IDebugSystemObjects*) env->GetLongField(obj,

                                                      ptrIDebugSystemObjects_ID);

  CHECK_EXCEPTION_(false);

  ULONG numThreads = 0;

  if (ptrIDebugSystemObjects->GetNumberThreads(&numThreads) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: GetNumberThreads failed!", false);

  }

  AutoArrayPtr<ULONG> ptrSysThreadIds = new ULONG[numThreads];

  if (ptrSysThreadIds.asPtr() == 0) {

     THROW_NEW_DEBUGGER_EXCEPTION_("out of memory to allocate thread ids!", false);

  }

  AutoArrayPtr<ULONG> ptrThreadIds = new ULONG[numThreads];

  if (ptrThreadIds.asPtr() == 0) {

     THROW_NEW_DEBUGGER_EXCEPTION_("out of memory to allocate thread ids!", false);

  }

  if (ptrIDebugSystemObjects->GetThreadIdsByIndex(0, numThreads,

                                      ptrThreadIds.asPtr(), ptrSysThreadIds.asPtr()) != S_OK) {

     THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: GetThreadIdsByIndex failed!", false);

  }

  IDebugAdvanced* ptrIDebugAdvanced = (IDebugAdvanced*) env->GetLongField(obj,

                                                      ptrIDebugAdvanced_ID);

  CHECK_EXCEPTION_(false);

  // for each thread, get register context and save it.

  for (ULONG t = 0; t < numThreads; t++) {

     if (ptrIDebugSystemObjects->SetCurrentThreadId(ptrThreadIds.asPtr()[t]) != S_OK) {

        THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: SetCurrentThread failed!", false);

     }

     jlongArray regs = env->NewLongArray(NPRGREG);

     CHECK_EXCEPTION_(false);

     jboolean isCopy = JNI_FALSE;

     jlong* ptrRegs = env->GetLongArrayElements(regs, &isCopy);

     CHECK_EXCEPTION_(false);

     // copy register values from the CONTEXT struct

     CONTEXT context;

     memset(&context, 0, sizeof(CONTEXT));

#undef REG_INDEX

#ifdef _M_IA64

     #define REG_INDEX(x) sun_jvm_hotspot_debugger_ia64_IA64ThreadContext_##x

     context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG;

     ptrIDebugAdvanced->GetThreadContext(&context, sizeof(CONTEXT));

     ptrRegs[REG_INDEX(GR0)]  = 0; // always 0

     ptrRegs[REG_INDEX(GR1)]  = context.IntGp;  // r1

     ptrRegs[REG_INDEX(GR2)]  = context.IntT0;  // r2-r3

     ptrRegs[REG_INDEX(GR3)]  = context.IntT1;

     ptrRegs[REG_INDEX(GR4)]  = context.IntS0;  // r4-r7

     ptrRegs[REG_INDEX(GR5)]  = context.IntS1;

     ptrRegs[REG_INDEX(GR6)]  = context.IntS2;

     ptrRegs[REG_INDEX(GR7)]  = context.IntS3;

     ptrRegs[REG_INDEX(GR8)]  = context.IntV0;  // r8

     ptrRegs[REG_INDEX(GR9)]  = context.IntT2;  // r9-r11

     ptrRegs[REG_INDEX(GR10)] = context.IntT3;

     ptrRegs[REG_INDEX(GR11)] = context.IntT4;

     ptrRegs[REG_INDEX(GR12)] = context.IntSp;  // r12 stack pointer

     ptrRegs[REG_INDEX(GR13)] = context.IntTeb; // r13 teb

     ptrRegs[REG_INDEX(GR14)] = context.IntT5;  // r14-r31

     ptrRegs[REG_INDEX(GR15)] = context.IntT6;

     ptrRegs[REG_INDEX(GR16)] = context.IntT7;

     ptrRegs[REG_INDEX(GR17)] = context.IntT8;

     ptrRegs[REG_INDEX(GR18)] = context.IntT9;

     ptrRegs[REG_INDEX(GR19)] = context.IntT10;

     ptrRegs[REG_INDEX(GR20)] = context.IntT11;

     ptrRegs[REG_INDEX(GR21)] = context.IntT12;

     ptrRegs[REG_INDEX(GR22)] = context.IntT13;

     ptrRegs[REG_INDEX(GR23)] = context.IntT14;

     ptrRegs[REG_INDEX(GR24)] = context.IntT15;

     ptrRegs[REG_INDEX(GR25)] = context.IntT16;

     ptrRegs[REG_INDEX(GR26)] = context.IntT17;

     ptrRegs[REG_INDEX(GR27)] = context.IntT18;

     ptrRegs[REG_INDEX(GR28)] = context.IntT19;