/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c

Bug Summary

File:	jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c
Warning:	line 1393, column 13 Access to field 'thread' results in a dereference of a null pointer (loaded from variable 'node')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name threadControl.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -D JDWP_LOGGING -I /home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/unix/native/libjdwp -I /home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/jdk.jdwp.agent -I /home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/include -I /home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/export -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wno-unused -Wno-unused-function -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c
1/*
* Copyright (c) 1998, 2021, 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.  Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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.
*/

26#include "util.h"
27#include "eventHandler.h"
28#include "threadControl.h"
29#include "commonRef.h"
30#include "eventHelper.h"
31#include "stepControl.h"
32#include "invoker.h"
33#include "bag.h"

35#define HANDLING_EVENT(node)((node)->current_ei != 0) ((node)->current_ei != 0)

37/*
* Collection of info for properly handling co-located events.
* If the ei field is non-zero, then one of the possible
* co-located events has been posted and the other fields describe
* the event's location.
*
* See comment above deferEventReport() for an explanation of co-located events.
*/
45typedef struct CoLocatedEventInfo_ {
  EventIndex ei;
  jclass    clazz;
  jmethodID method;
  jlocation location;
50} CoLocatedEventInfo;

52/**
* The main data structure in threadControl is the ThreadNode.
* This is a per-thread structure that is allocated on the
* first event that occurs in a thread. It is freed after the
* thread's thread end event has completed processing. The
* structure contains state information on its thread including
* suspend counts. It also acts as a repository for other
* per-thread state such as the current method invocation or
* current step.
*
* suspendCount is the number of outstanding suspends
* from the debugger. suspends from the app itself are
* not included in this count.
*/
66typedef struct ThreadNode {
  jthread thread;
  unsigned int toBeResumed : 1;      /* true if this thread was successfully suspended. */
  unsigned int pendingInterrupt : 1; /* true if thread is interrupted while handling an event. */
  unsigned int isDebugThread : 1;    /* true if this is one of our debug agent threads. */
  unsigned int suspendOnStart : 1;   /* true for new threads if we are currently in a VM.suspend(). */
  unsigned int isStarted : 1;        /* THREAD_START or VIRTUAL_THREAD_SCHEDULED event received. */
  unsigned int popFrameEvent : 1;
  unsigned int popFrameProceed : 1;
  unsigned int popFrameThread : 1;
  unsigned int handlingAppResume : 1;
  EventIndex current_ei; /* Used to determine if we are currently handling an event on this thread. */
  jobject pendingStop;   /* Object we are throwing to stop the thread (ThreadReferenceImpl.stop). */
  jint suspendCount;
  jint resumeFrameDepth; /* !=0 => This thread is in a call to Thread.resume() */
  jvmtiEventMode instructionStepMode;
  StepRequest currentStep;
  InvokeRequest currentInvoke;
  struct bag *eventBag;       /* Accumulation of JDWP events to be sent as a reply. */
  CoLocatedEventInfo cleInfo; /* See comment above deferEventReport() for an explanation. */
  struct ThreadNode *next;
  struct ThreadNode *prev;
  jlong frameGeneration;    /* used to generate a unique frameID. Incremented whenever existing frameID
                               needs to be invalidated, such as when the thread is resumed. */
  struct ThreadList *list;  /* Tells us what list this thread is in. */
91#ifdef DEBUG_THREADNAME
  char name[256];
93#endif
94} ThreadNode;

96static jint suspendAllCount;

98typedef struct ThreadList {
  ThreadNode *first;
100} ThreadList;

102/*
* popFrameEventLock is used to notify that the event has been received
*/
105static jrawMonitorID popFrameEventLock = NULL((void*)0);

107/*
* popFrameProceedLock is used to assure that the event thread is
* re-suspended immediately after the event is acknowledged.
*/
111static jrawMonitorID popFrameProceedLock = NULL((void*)0);

113static jrawMonitorID threadLock;
114static jlocation resumeLocation;
115static HandlerNode *breakpointHandlerNode;
116static HandlerNode *framePopHandlerNode;
117static HandlerNode *catchHandlerNode;

119static jvmtiError threadControl_removeDebugThread(jthread thread);

121/*
* Threads which have issued thread start events and not yet issued thread
* end events are maintained in the "runningThreads" list. All other threads known
* to this module are kept in the "otherThreads" list.
*/
126static ThreadList runningThreads;
127static ThreadList otherThreads;

129#define MAX_DEBUG_THREADS10 10
130static int debugThreadCount;
131static jthread debugThreads[MAX_DEBUG_THREADS10];

133typedef struct DeferredEventMode {
  EventIndex ei;
  jvmtiEventMode mode;
  jthread thread;
  struct DeferredEventMode *next;
138} DeferredEventMode;

140typedef struct {
  DeferredEventMode *first;
  DeferredEventMode *last;
143} DeferredEventModeList;

145static DeferredEventModeList deferredEventModes;

147#ifdef DEBUG1
148static void dumpThreadList(ThreadList *list);
149static void dumpThread(ThreadNode *node);
150#endif

152static jint
153getStackDepth(jthread thread)
154{
  jint count = 0;
  jvmtiError error;

  error = JVMTI_FUNC_PTR(gdata->jvmti,GetFrameCount)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,158), log_message_end ("%s()","GetFrameCount")):((void)0)),(
gdata->jvmti))))->GetFrameCount))
                      (gdata->jvmti, thread, &count);
  if (error != JVMTI_ERROR_NONE) {
      EXIT_ERROR(error, "getting frame count"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)error), error, ("getting frame count"
==((void*)0)?"":"getting frame count"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 161); debugInit_exit((jvmtiError)error, "getting frame count"
); };
  }
  return count;
164}

166/* Get the state of the thread direct from JVMTI */
167static jvmtiError
168threadState(jthread thread, jint *pstate)
169{
  *pstate = 0;
  return JVMTI_FUNC_PTR(gdata->jvmti,GetThreadState)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,171), log_message_end ("%s()","GetThreadState")):((void)0)),
(gdata->jvmti))))->GetThreadState))
                      (gdata->jvmti, thread, pstate);
173}

175/* Set TLS on a specific jthread to the ThreadNode* */
176static void
177setThreadLocalStorage(jthread thread, ThreadNode *node)
178{
  jvmtiError  error;

  error = JVMTI_FUNC_PTR(gdata->jvmti,SetThreadLocalStorage)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,181), log_message_end ("%s()","SetThreadLocalStorage")):((void
)0)),(gdata->jvmti))))->SetThreadLocalStorage))
          (gdata->jvmti, thread, (void*)node);
  if ( error == JVMTI_ERROR_THREAD_NOT_ALIVE && node == NULL((void*)0)) {
      /* Just return. This can happen when clearing the TLS. */
      return;
  } else if ( error != JVMTI_ERROR_NONE ) {
      /* The jthread object must be valid, so this must be a fatal error */
      EXIT_ERROR(error, "cannot set thread local storage"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)error), error, ("cannot set thread local storage"
==((void*)0)?"":"cannot set thread local storage"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 188); debugInit_exit((jvmtiError)error, "cannot set thread local storage"
); };
  }
190}

192/* Get TLS on a specific jthread, which is the ThreadNode* */
193static ThreadNode *
194getThreadLocalStorage(jthread thread)
195{
  jvmtiError  error;
  ThreadNode *node;

  node = NULL((void*)0);
  error = JVMTI_FUNC_PTR(gdata->jvmti,GetThreadLocalStorage)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,200), log_message_end ("%s()","GetThreadLocalStorage")):((void
)0)),(gdata->jvmti))))->GetThreadLocalStorage))
          (gdata->jvmti, thread, (void**)&node);
  if ( error == JVMTI_ERROR_THREAD_NOT_ALIVE ) {
      /* Just return NULL, thread hasn't started yet */
      return NULL((void*)0);
  } else if ( error != JVMTI_ERROR_NONE ) {
      /* The jthread object must be valid, so this must be a fatal error */
      EXIT_ERROR(error, "cannot get thread local storage"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)error), error, ("cannot get thread local storage"
==((void*)0)?"":"cannot get thread local storage"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 207); debugInit_exit((jvmtiError)error, "cannot get thread local storage"
); };
  }
  return node;
210}

212/* Search list for nodes that don't have TLS set and match this thread.
*   It assumed that this logic is never dealing with terminated threads,
*   since the ThreadEnd events always delete the ThreadNode while the
*   jthread is still alive.  So we can only look at the ThreadNode's that
*   have never had their TLS set, making the search much faster.
*   But keep in mind, this kind of search should rarely be needed.
*/
219static ThreadNode *
220nonTlsSearch(JNIEnv *env, ThreadList *list, jthread thread)
221{
  ThreadNode *node;

  for (node = list->first; node != NULL((void*)0); node = node->next) {
      if (isSameObject(env, node->thread, thread)) {
          break;
      }
  }
  return node;
230}

232/*
* These functions maintain the linked list of currently running threads.
* All assume that the threadLock is held before calling.
*/

237/*
* Search for a thread on the list. If list==NULL, search all lists.
*/
240static ThreadNode *
241findThread(ThreadList *list, jthread thread)
242{
  ThreadNode *node;

  /* Get thread local storage for quick thread -> node access */
  node = getThreadLocalStorage(thread);

  if ( node == NULL((void*)0) ) {
      /*
       * If the thread was not yet started when the ThreadNode was created, then it
       * got added to the otherThreads list and its thread local storage was not set.
       * Search for it in the otherThreads list.
       */
      if ( list == NULL((void*)0) || list == &otherThreads ) {
          node = nonTlsSearch(getEnv(), &otherThreads, thread);
      }
      /*
       * Normally we can assume that a thread with no TLS will never be in the runningThreads
       * list. This is because we always set the TLS when adding to runningThreads.
       * However, when a thread exits, its TLS is automatically cleared. Normally this
       * is not a problem because the debug agent will first get a THREAD_END event,
       * and that will cause the thread to be removed from runningThreads, thus we
       * avoid this situation of having a thread in runningThreads, but with no TLS.
       *
       * However... there is one exception to this. While handling VM_DEATH, the first thing
       * the debug agent does is clear all the callbacks. This means we will no longer
       * get THREAD_END events as threads exit. This means we might find threads on
       * runningThreads with no TLS during VM_DEATH. Essentially the THREAD_END that
       * would normally have resulted in removing the thread from runningThreads is
       * missed, so the thread remains on runningThreads.
       *
       * The end result of all this is that if the TLS lookup failed, we still need to check
       * if the thread is on runningThreads, but only if JVMTI callbacks have been cleared.
       * Otherwise the thread should not be on the runningThreads.
       */
      if ( !gdata->jvmtiCallBacksCleared ) {
          /* The thread better not be on runningThreads if the TLS lookup failed. */
          JDI_ASSERT(!nonTlsSearch(getEnv(), &runningThreads, thread))do { if (gdata && gdata->assertOn && !(!nonTlsSearch
(getEnv(), &runningThreads, thread))) { jdiAssertionFailed
("/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 278, "!nonTlsSearch(getEnv(), &runningThreads, thread)"
); } } while (0);
      } else {
          /*
           * Search the runningThreads list. The TLS lookup may have failed because the
           * thread has terminated, but we never got the THREAD_END event.
           */
          if ( node == NULL((void*)0) ) {
              if ( list == NULL((void*)0) || list == &runningThreads ) {
                  node = nonTlsSearch(getEnv(), &runningThreads, thread);
              }
          }
      }
  }

  /* If a list is supplied, only return ones in this list */
  if ( node != NULL((void*)0) && list != NULL((void*)0) && node->list != list ) {
      return NULL((void*)0);
  }
  return node;
297}

299/* Remove a ThreadNode from a ThreadList */
300static void
301removeNode(ThreadList *list, ThreadNode *node)
302{
  ThreadNode *prev;
  ThreadNode *next;

  prev = node->prev;
  next = node->next;
  if ( prev != NULL((void*)0) ) {
      prev->next = next;
  }
  if ( next != NULL((void*)0) ) {
      next->prev = prev;
  }
  if ( prev == NULL((void*)0) ) {
      list->first = next;
  }
  node->next = NULL((void*)0);
  node->prev = NULL((void*)0);
  node->list = NULL((void*)0);
320}

322/* Add a ThreadNode to a ThreadList */
323static void
324addNode(ThreadList *list, ThreadNode *node)
325{
  node->next = NULL((void*)0);
  node->prev = NULL((void*)0);
  node->list = NULL((void*)0);
  if ( list->first == NULL((void*)0) ) {
      list->first = node;
  } else {
      list->first->prev = node;
      node->next = list->first;
      list->first = node;
  }
  node->list = list;
337}

339static ThreadNode *
340insertThread(JNIEnv *env, ThreadList *list, jthread thread)
341{
  ThreadNode *node;
  struct bag *eventBag;

  node = findThread(list, thread);
  if (node == NULL((void*)0)) {
      node = jvmtiAllocate(sizeof(*node));
      if (node == NULL((void*)0)) {
          EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"thread table entry"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+8))), ((jvmtiError)(JVMTI_ERROR_MAX+64+8)), ("thread table entry"
==((void*)0)?"":"thread table entry"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 349); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+8)), "thread table entry"); };
          return NULL((void*)0);
      }
      (void)memset(node, 0, sizeof(*node));
      eventBag = eventHelper_createEventBag();
      if (eventBag == NULL((void*)0)) {
          jvmtiDeallocate(node);
          EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"thread table entry"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+8))), ((jvmtiError)(JVMTI_ERROR_MAX+64+8)), ("thread table entry"
==((void*)0)?"":"thread table entry"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 356); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+8)), "thread table entry"); };
          return NULL((void*)0);
      }

      /*
       * Init all flags false, all refs NULL, all counts 0
       */

      saveGlobalRef(env, thread, &(node->thread));
      if (node->thread == NULL((void*)0)) {
          jvmtiDeallocate(node);
          bagDestroyBag(eventBag);
          EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"thread table entry"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+8))), ((jvmtiError)(JVMTI_ERROR_MAX+64+8)), ("thread table entry"
==((void*)0)?"":"thread table entry"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 368); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+8)), "thread table entry"); };
          return NULL((void*)0);
      }
      /*
       * Remember if it is a debug thread
       */
      if (threadControl_isDebugThread(node->thread)) {
          node->isDebugThread = JNI_TRUE1;
      } else if (suspendAllCount > 0){
          /*
           * If there is a pending suspendAll, all new threads should
           * be initialized as if they were suspended by the suspendAll,
           * and the thread will need to be suspended when it starts.
           */
          node->suspendCount = suspendAllCount;
          node->suspendOnStart = JNI_TRUE1;
      }
      node->current_ei = 0;
      node->instructionStepMode = JVMTI_DISABLE;
      node->eventBag = eventBag;
      addNode(list, node);

390#ifdef DEBUG_THREADNAME
      {
          /* Set the thread name */
          jvmtiThreadInfo info;
          jvmtiError error;

          memset(&info, 0, sizeof(info));
          error = JVMTI_FUNC_PTR(gdata->jvmti,GetThreadInfo)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,397), log_message_end ("%s()","GetThreadInfo")):((void)0)),(
gdata->jvmti))))->GetThreadInfo))
                  (gdata->jvmti, node->thread, &info);
          if (info.name != NULL((void*)0)) {
              strncpy(node->name, info.name, sizeof(node->name) - 1);
              jvmtiDeallocate(info.name);
          }
      }
404#endif

      /* Set thread local storage for quick thread -> node access.
       *   Threads that are not yet started do not allow setting of TLS. These
       *   threads go on the otherThreads list and have their TLS set
       *   when moved to the runningThreads list. findThread() knows to look
       *   on otherThreads when the TLS lookup fails.
       */
      if (list != &otherThreads) {
          setThreadLocalStorage(node->thread, (void*)node);
      }
  }

  return node;
418}

420static void
421clearThread(JNIEnv *env, ThreadNode *node)
422{
  if (node->pendingStop != NULL((void*)0)) {
      tossGlobalRef(env, &(node->pendingStop));
  }
  stepControl_clearRequest(node->thread, &node->currentStep);
  if (node->isDebugThread) {
      (void)threadControl_removeDebugThread(node->thread);
  }
  /* Clear out TLS on this thread (just a cleanup action) */
  setThreadLocalStorage(node->thread, NULL((void*)0));
  tossGlobalRef(env, &(node->thread));
  bagDestroyBag(node->eventBag);
  jvmtiDeallocate(node);
435}

437static void
438removeThread(JNIEnv *env, ThreadList *list, jthread thread)
439{
  ThreadNode *node;

  node = findThread(list, thread);
  if (node != NULL((void*)0)) {
      removeNode(list, node);
      clearThread(env, node);
  }
447}

449static void
450removeResumed(JNIEnv *env, ThreadList *list)
451{
  ThreadNode *node;

  node = list->first;
  while (node != NULL((void*)0)) {
      ThreadNode *temp = node->next;
      if (node->suspendCount == 0) {
          removeThread(env, list, node->thread);
      }
      node = temp;
  }
462}

464static void
465moveNode(ThreadList *source, ThreadList *dest, ThreadNode *node)
466{
  removeNode(source, node);
  JDI_ASSERT(findThread(dest, node->thread) == NULL)do { if (gdata && gdata->assertOn && !(findThread
(dest, node->thread) == ((void*)0))) { jdiAssertionFailed(
"/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 468, "findThread(dest, node->thread) == NULL"); } } while
 (0);
  addNode(dest, node);
470}

472typedef jvmtiError (*ThreadEnumerateFunction)(JNIEnv *, ThreadNode *, void *);

474static jvmtiError
475enumerateOverThreadList(JNIEnv *env, ThreadList *list,
                      ThreadEnumerateFunction function, void *arg)
477{
  ThreadNode *node;
  jvmtiError error = JVMTI_ERROR_NONE;

  for (node = list->first; node != NULL((void*)0); node = node->next) {
      error = (*function)(env, node, arg);
      if ( error != JVMTI_ERROR_NONE ) {
          break;
      }
  }
  return error;
488}

490static void
491insertEventMode(DeferredEventModeList *list, DeferredEventMode *eventMode)
492{
  if (list->last != NULL((void*)0)) {
      list->last->next = eventMode;
  } else {
      list->first = eventMode;
  }
  list->last = eventMode;
499}

501static void
502removeEventMode(DeferredEventModeList *list, DeferredEventMode *eventMode, DeferredEventMode *prev)
503{
  if (prev == NULL((void*)0)) {
      list->first = eventMode->next;
  } else {
      prev->next = eventMode->next;
  }
  if (eventMode->next == NULL((void*)0)) {
      list->last = prev;
  }
512}

514static jvmtiError
515addDeferredEventMode(JNIEnv *env, jvmtiEventMode mode, EventIndex ei, jthread thread)
516{
  DeferredEventMode *eventMode;

  /*LINTED*/
  eventMode = jvmtiAllocate((jint)sizeof(DeferredEventMode));
  if (eventMode == NULL((void*)0)) {
      return AGENT_ERROR_OUT_OF_MEMORY((jvmtiError)(JVMTI_ERROR_MAX+64+8));
  }
  eventMode->thread = NULL((void*)0);
  saveGlobalRef(env, thread, &(eventMode->thread));
  eventMode->mode = mode;
  eventMode->ei = ei;
  eventMode->next = NULL((void*)0);
  insertEventMode(&deferredEventModes, eventMode);
  return JVMTI_ERROR_NONE;
531}

533static void
534freeDeferredEventModes(JNIEnv *env)
535{
  DeferredEventMode *eventMode;
  eventMode = deferredEventModes.first;
  while (eventMode != NULL((void*)0)) {
      DeferredEventMode *next;
      next = eventMode->next;
      tossGlobalRef(env, &(eventMode->thread));
      jvmtiDeallocate(eventMode);
      eventMode = next;
  }
  deferredEventModes.first = NULL((void*)0);
  deferredEventModes.last = NULL((void*)0);
547}

549static jvmtiError
550threadSetEventNotificationMode(ThreadNode *node,
      jvmtiEventMode mode, EventIndex ei, jthread thread)
552{
  jvmtiError error;

  /* record single step mode */
  if (ei == EI_SINGLE_STEP) {
      node->instructionStepMode = mode;
  }
  error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventNotificationMode)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,559), log_message_end ("%s()","SetEventNotificationMode")):(
(void)0)),(gdata->jvmti))))->SetEventNotificationMode))
      (gdata->jvmti, mode, eventIndex2jvmti(ei), thread);
  return error;
562}

564static void
565processDeferredEventModes(JNIEnv *env, jthread thread, ThreadNode *node)
566{
  jvmtiError error;
  DeferredEventMode *eventMode;
  DeferredEventMode *prev;

  prev = NULL((void*)0);
  eventMode = deferredEventModes.first;
  while (eventMode != NULL((void*)0)) {
      DeferredEventMode *next = eventMode->next;
      if (isSameObject(env, thread, eventMode->thread)) {
          error = threadSetEventNotificationMode(node,
                  eventMode->mode, eventMode->ei, eventMode->thread);
          if (error != JVMTI_ERROR_NONE) {
              EXIT_ERROR(error, "cannot process deferred thread event notifications at thread start"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)error), error, ("cannot process deferred thread event notifications at thread start"
==((void*)0)?"":"cannot process deferred thread event notifications at thread start"
), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 579); debugInit_exit((jvmtiError)error, "cannot process deferred thread event notifications at thread start"
); };
          }
          removeEventMode(&deferredEventModes, eventMode, prev);
          tossGlobalRef(env, &(eventMode->thread));
          jvmtiDeallocate(eventMode);
      } else {
          prev = eventMode;
      }
      eventMode = next;
  }
589}

591static void
592getLocks(void)
593{
  /*
   * Anything which might be locked as part of the handling of
   * a JVMTI event (which means: might be locked by an application
   * thread) needs to be grabbed here. This allows thread control
   * code to safely suspend and resume the application threads
   * while ensuring they don't hold a critical lock.
   */

  eventHandler_lock();
  invoker_lock();
  eventHelper_lock();
  stepControl_lock();
  commonRef_lock();
  debugMonitorEnter(threadLock);

609}

611static void
612releaseLocks(void)
613{
  debugMonitorExit(threadLock);
  commonRef_unlock();
  stepControl_unlock();
  eventHelper_unlock();
  invoker_unlock();
  eventHandler_unlock();
620}

622void
623threadControl_initialize(void)
624{
  jlocation unused;
  jvmtiError error;

  suspendAllCount = 0;
  runningThreads.first = NULL((void*)0);
  otherThreads.first = NULL((void*)0);
  debugThreadCount = 0;
  threadLock = debugMonitorCreate("JDWP Thread Lock");
  if (gdata->threadClass==NULL((void*)0)) {
      EXIT_ERROR(AGENT_ERROR_NULL_POINTER, "no java.lang.thread class"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+21))), ((jvmtiError)(JVMTI_ERROR_MAX+64+21)), ("no java.lang.thread class"
==((void*)0)?"":"no java.lang.thread class"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 634); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+21)), "no java.lang.thread class"); };
  }
  if (gdata->threadResume==0) {
      EXIT_ERROR(AGENT_ERROR_NULL_POINTER, "cannot resume thread"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+21))), ((jvmtiError)(JVMTI_ERROR_MAX+64+21)), ("cannot resume thread"
==((void*)0)?"":"cannot resume thread"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 637); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+21)), "cannot resume thread"); };
  }
  /* Get the java.lang.Thread.resume() method beginning location */
  error = methodLocation(gdata->threadResume, &resumeLocation, &unused);
  if (error != JVMTI_ERROR_NONE) {
      EXIT_ERROR(error, "getting method location"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)error), error, ("getting method location"
==((void*)0)?"":"getting method location"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 642); debugInit_exit((jvmtiError)error, "getting method location"
); };
  }
644}

646static jthread
647getResumee(jthread resumingThread)
648{
  jthread resumee = NULL((void*)0);
  jvmtiError error;
  jobject object;
  FrameNumber fnum = 0;

  error = JVMTI_FUNC_PTR(gdata->jvmti,GetLocalObject)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,654), log_message_end ("%s()","GetLocalObject")):((void)0)),
(gdata->jvmti))))->GetLocalObject))
                  (gdata->jvmti, resumingThread, fnum, 0, &object);
  if (error == JVMTI_ERROR_NONE) {
      resumee = object;
  }
  return resumee;
660}


663static jboolean
664pendingAppResume(jboolean includeSuspended)
665{
  ThreadList *list;
  ThreadNode *node;

  list = &runningThreads;
  node = list->first;
  while (node != NULL((void*)0)) {
      if (node->resumeFrameDepth > 0) {
          if (includeSuspended) {
              return JNI_TRUE1;
          } else {
              jvmtiError error;
              jint       state;

              error = threadState(node->thread, &state);
              if (error != JVMTI_ERROR_NONE) {
                  EXIT_ERROR(error, "getting thread state"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)error), error, ("getting thread state"
==((void*)0)?"":"getting thread state"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 681); debugInit_exit((jvmtiError)error, "getting thread state"
); };
              }
              /* !node->handlingAppResume && resumeFrameDepth > 0
               * means the thread has entered Thread.resume() */
              if (!(state & JVMTI_THREAD_STATE_SUSPENDED) &&
                  !node->handlingAppResume) {
                  return JNI_TRUE1;
              }
          }
      }
      node = node->next;
  }
  return JNI_FALSE0;
694}

696static void
697notifyAppResumeComplete(void)
698{
  debugMonitorNotifyAll(threadLock);
  if (!pendingAppResume(JNI_TRUE1)) {
      if (framePopHandlerNode != NULL((void*)0)) {
          (void)eventHandler_free(framePopHandlerNode);
          framePopHandlerNode = NULL((void*)0);
      }
      if (catchHandlerNode != NULL((void*)0)) {
          (void)eventHandler_free(catchHandlerNode);
          catchHandlerNode = NULL((void*)0);
      }
  }
710}

712/*
* Event handler for FRAME_POP and EXCEPTION_CATCH when in Thread.resume()
* so we can detect its completion.
*/
716static void
717handleAppResumeCompletion(JNIEnv *env, EventInfo *evinfo,
                        HandlerNode *handlerNode,
                        struct bag *eventBag)
720{
  ThreadNode *node;
  jthread     thread;

  thread = evinfo->thread;

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0)) {
      if (node->resumeFrameDepth > 0) {
          jint compareDepth = getStackDepth(thread);
          if (evinfo->ei == EI_FRAME_POP) {
              compareDepth--;
          }
          if (compareDepth < node->resumeFrameDepth) {
              node->resumeFrameDepth = 0;
              notifyAppResumeComplete();
          }
      }
  }

  debugMonitorExit(threadLock);
743}

745static void
746blockOnDebuggerSuspend(jthread thread)
747{
  ThreadNode *node;

  node = findThread(NULL((void*)0), thread);
  if (node != NULL((void*)0)) {
      while (node && node->suspendCount > 0) {
          debugMonitorWait(threadLock);
          node = findThread(NULL((void*)0), thread);
      }
  }
757}

759/*
* The caller is expected to hold threadLock and handlerLock.
* eventHandler_createInternalThreadOnly() can deadlock because of
* wrong lock ordering if the caller does not hold handlerLock.
*/
764static void
765trackAppResume(jthread thread)
766{
  jvmtiError  error;
  FrameNumber fnum;
  ThreadNode *node;

  fnum = 0;
  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0)) {
      JDI_ASSERT(node->resumeFrameDepth == 0)do { if (gdata && gdata->assertOn && !(node
->resumeFrameDepth == 0)) { jdiAssertionFailed("/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 774, "node->resumeFrameDepth == 0"); } } while (0);
      error = JVMTI_FUNC_PTR(gdata->jvmti,NotifyFramePop)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,775), log_message_end ("%s()","NotifyFramePop")):((void)0)),
(gdata->jvmti))))->NotifyFramePop))
                      (gdata->jvmti, thread, fnum);
      if (error == JVMTI_ERROR_NONE) {
          jint frameDepth = getStackDepth(thread);
          if ((frameDepth > 0) && (framePopHandlerNode == NULL((void*)0))) {
              framePopHandlerNode = eventHandler_createInternalThreadOnly(
                                         EI_FRAME_POP,
                                         handleAppResumeCompletion,
                                         thread);
              catchHandlerNode = eventHandler_createInternalThreadOnly(
                                         EI_EXCEPTION_CATCH,
                                         handleAppResumeCompletion,
                                         thread);
              if ((framePopHandlerNode == NULL((void*)0)) ||
                  (catchHandlerNode == NULL((void*)0))) {
                  (void)eventHandler_free(framePopHandlerNode);
                  framePopHandlerNode = NULL((void*)0);
                  (void)eventHandler_free(catchHandlerNode);
                  catchHandlerNode = NULL((void*)0);
              }
          }
          if ((framePopHandlerNode != NULL((void*)0)) &&
              (catchHandlerNode != NULL((void*)0)) &&
              (frameDepth > 0)) {
              node->resumeFrameDepth = frameDepth;
          }
      }
  }
803}

805/* Global breakpoint handler for Thread.resume() */
806static void
807handleAppResumeBreakpoint(JNIEnv *env, EventInfo *evinfo,
                        HandlerNode *handlerNode,
                        struct bag *eventBag)
810{
  jthread resumer = evinfo->thread;

  debugMonitorEnter(threadLock);

  /*
   * Actual handling has to be deferred. We cannot block right here if the
   * target of the resume call is suspended by the debugger since we are
   * holding handlerLock which must not be released. See doPendingTasks().
   */
  if (resumer != NULL((void*)0)) {
      ThreadNode* node = findThread(&runningThreads, resumer);
      if (node != NULL((void*)0)) {
          node->handlingAppResume = JNI_TRUE1;
      }
  }

  debugMonitorExit(threadLock);
828}

830void
831threadControl_onConnect(void)
832{
  breakpointHandlerNode = eventHandler_createInternalBreakpoint(
               handleAppResumeBreakpoint, NULL((void*)0),
               gdata->threadClass, gdata->threadResume, resumeLocation);
836}

838void
839threadControl_onDisconnect(void)
840{
  if (breakpointHandlerNode != NULL((void*)0)) {
      (void)eventHandler_free(breakpointHandlerNode);
      breakpointHandlerNode = NULL((void*)0);
  }
  if (framePopHandlerNode != NULL((void*)0)) {
      (void)eventHandler_free(framePopHandlerNode);
      framePopHandlerNode = NULL((void*)0);
  }
  if (catchHandlerNode != NULL((void*)0)) {
      (void)eventHandler_free(catchHandlerNode);
      catchHandlerNode = NULL((void*)0);
  }
853}

855void
856threadControl_onHook(void)
857{
  /*
   * As soon as the event hook is in place, we need to initialize
   * the thread list with already-existing threads. The threadLock
   * has been held since initialize, so we don't need to worry about
   * insertions or deletions from the event handlers while we do this
   */
  JNIEnv *env;

  env = getEnv();

  /*
   * Prevent any event processing until OnHook has been called
   */
  debugMonitorEnter(threadLock);

  WITH_LOCAL_REFS(env, 1)createLocalRefSpace(env, 1); { {

      jint threadCount;
      jthread *threads;

      threads = allThreads(&threadCount);
      if (threads == NULL((void*)0)) {
          EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"thread table"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+8))), ((jvmtiError)(JVMTI_ERROR_MAX+64+8)), ("thread table"==
((void*)0)?"":"thread table"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 880); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+8)), "thread table"); };
      } else {

          int i;

          for (i = 0; i < threadCount; i++) {
              ThreadNode *node;
              jthread thread = threads[i];
              node = insertThread(env, &runningThreads, thread);

              /*
               * This is a tiny bit risky. We have to assume that the
               * pre-existing threads have been started because we
               * can't rely on a thread start event for them. The chances
               * of a problem related to this are pretty slim though, and
               * there's really no choice because without setting this flag
               * there is no way to enable stepping and other events on
               * the threads that already exist (e.g. the finalizer thread).
               */
              node->isStarted = JNI_TRUE1;
          }
          jvmtiDeallocate(threads);
      }

  } END_WITH_LOCAL_REFS(env)(*((*((((gdata->log_flags & (0x00000002)) ?(log_message_begin
("JNI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,904), log_message_end ("%s()","PopLocalFrame")):((void)0)), (
env))))->PopLocalFrame))(env, ((void*)0)); }

  debugMonitorExit(threadLock);
907}

909static jvmtiError
910commonSuspendByNode(ThreadNode *node)
911{
  jvmtiError error;

  LOG_MISC(("thread=%p suspended", node->thread))((gdata->log_flags & (0x00000008)) ?(log_message_begin
("MISC","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,914), log_message_end ("thread=%p suspended", node->thread
)):((void)0));
  error = JVMTI_FUNC_PTR(gdata->jvmti,SuspendThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,915), log_message_end ("%s()","SuspendThread")):((void)0)),(
gdata->jvmti))))->SuspendThread))
              (gdata->jvmti, node->thread);

  /*
   * Mark for resume only if suspend succeeded
   */
  if (error == JVMTI_ERROR_NONE) {
      node->toBeResumed = JNI_TRUE1;
  }

  /*
   * If the thread was suspended by another app thread,
   * do nothing and report no error (we won't resume it later).
   */
   if (error == JVMTI_ERROR_THREAD_SUSPENDED) {
      error = JVMTI_ERROR_NONE;
   }

   return error;
934}

936/*
* Deferred suspends happen when the suspend is attempted on a thread
* that is not started. Bookkeeping (suspendCount,etc.)
* is handled by the original request, and once the thread actually
* starts, an actual suspend is attempted. This function does the
* deferred suspend without changing the bookkeeping that is already
* in place.
*/
944static jint
945deferredSuspendThreadByNode(ThreadNode *node)
946{
  jvmtiError error;

  error = JVMTI_ERROR_NONE;
  if (node->isDebugThread) {
      /* Ignore requests for suspending debugger threads */
      return JVMTI_ERROR_NONE;
  }

  /*
   * Do the actual suspend only if a subsequent resume hasn't
   * made it irrelevant.
   */
  if (node->suspendCount > 0) {
      error = commonSuspendByNode(node);

      /*
       * Attempt to clean up from any error by decrementing the
       * suspend count. This compensates for the increment that
       * happens when suspendOnStart is set to true.
       */
      if (error != JVMTI_ERROR_NONE) {
          node->suspendCount--;
      }
  }

  node->suspendOnStart = JNI_FALSE0;

  debugMonitorNotifyAll(threadLock);

  return error;
977}

979static jvmtiError
980suspendThreadByNode(ThreadNode *node)
981{
  jvmtiError error = JVMTI_ERROR_NONE;
  if (node->isDebugThread) {
      /* Ignore requests for suspending debugger threads */
      return JVMTI_ERROR_NONE;
  }

  /*
   * Just increment the suspend count if we are waiting
   * for a deferred suspend.
   */
  if (node->suspendOnStart) {
      node->suspendCount++;
      return JVMTI_ERROR_NONE;
  }

  if (node->suspendCount == 0) {
      error = commonSuspendByNode(node);

      if (error == JVMTI_ERROR_THREAD_NOT_ALIVE) {
          /*
           * This error means that the thread is either a zombie or not yet
           * started. In either case, we ignore the error. If the thread
           * is a zombie, suspend/resume are no-ops. If the thread is not
           * started, it will be suspended for real during the processing
           * of its thread start event.
           */
          node->suspendOnStart = JNI_TRUE1;
          error = JVMTI_ERROR_NONE;
      }
  }

  if (error == JVMTI_ERROR_NONE) {
      node->suspendCount++;
  }

  debugMonitorNotifyAll(threadLock);

  return error;
1020}

1022static jvmtiError
1023resumeThreadByNode(ThreadNode *node)
1024{
  jvmtiError error = JVMTI_ERROR_NONE;

  if (node->isDebugThread) {
      /* never suspended by debugger => don't ever try to resume */
      return JVMTI_ERROR_NONE;
  }
  if (node->suspendCount > 0) {
      node->suspendCount--;
      debugMonitorNotifyAll(threadLock);
      if ((node->suspendCount == 0) && node->toBeResumed &&
          !node->suspendOnStart) {
          LOG_MISC(("thread=%p resumed", node->thread))((gdata->log_flags & (0x00000008)) ?(log_message_begin
("MISC","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1036), log_message_end ("thread=%p resumed", node->thread
)):((void)0));
          error = JVMTI_FUNC_PTR(gdata->jvmti,ResumeThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1037), log_message_end ("%s()","ResumeThread")):((void)0)),(
gdata->jvmti))))->ResumeThread))
                      (gdata->jvmti, node->thread);
          node->frameGeneration++; /* Increment on each resume */
          node->toBeResumed = JNI_FALSE0;
          if (error == JVMTI_ERROR_THREAD_NOT_ALIVE && !node->isStarted) {
              /*
               * We successfully "suspended" this thread, but
               * we never received a THREAD_START event for it.
               * Since the thread never ran, we can ignore our
               * failure to resume the thread.
               */
              error = JVMTI_ERROR_NONE;
          }
      }
  }

  return error;
1054}

1056/*
* Functions which respond to user requests to suspend/resume
* threads.
* Suspends and resumes add and subtract from a count respectively.
* The thread is only suspended when the count goes from 0 to 1 and
* resumed only when the count goes from 1 to 0.
*
* These functions suspend and resume application threads
* without changing the
* state of threads that were already suspended beforehand.
* They must not be called from an application thread because
* that thread may be suspended somewhere in the  middle of things.
*/
1069static void
1070preSuspend(void)
1071{
  getLocks();                     /* Avoid debugger deadlocks */

  /*
   * Delay any suspend while a call to java.lang.Thread.resume is in
   * progress (not including those in suspended threads). The wait is
   * timed because the threads suspended through
   * java.lang.Thread.suspend won't result in a notify even though
   * it may change the result of pendingAppResume()
   */
  while (pendingAppResume(JNI_FALSE0)) {
      /*
       * This is ugly but we need to release the locks from getLocks
       * or else the notify will never happen. The locks must be
       * released and reacquired in the right order. else deadlocks
       * can happen. It is possible that, during this dance, the
       * notify will be missed, but since the wait needs to be timed
       * anyway, it won't be a disaster. Note that this code will
       * execute only on very rare occasions anyway.
       */
      releaseLocks();

      debugMonitorEnter(threadLock);
      debugMonitorTimedWait(threadLock, 1000);
      debugMonitorExit(threadLock);

      getLocks();
  }
1099}

1101static void
1102postSuspend(void)
1103{
  releaseLocks();
1105}

1107/*
* This function must be called after preSuspend and before postSuspend.
*/
1110static jvmtiError
1111commonSuspend(JNIEnv *env, jthread thread, jboolean deferred)
1112{
  ThreadNode *node;

  /*
   * If the thread is not between its start and end events, we should
   * still suspend it. To keep track of things, add the thread
   * to a separate list of threads so that we'll resume it later.
   */
  node = findThread(&runningThreads, thread);
1121#if 0
  tty_message("commonSuspend: node(%p) suspendCount(%d) %s", node, node->suspendCount, node->name);
1123#endif
  if (node == NULL((void*)0)) {
      node = insertThread(env, &otherThreads, thread);
  }

  if ( deferred ) {
      return deferredSuspendThreadByNode(node);
  } else {
      return suspendThreadByNode(node);
  }
1133}


1136static jvmtiError
1137resumeCopyHelper(JNIEnv *env, ThreadNode *node, void *arg)
1138{
  if (node->isDebugThread) {
      /* never suspended by debugger => don't ever try to resume */
      return JVMTI_ERROR_NONE;
  }

  if (node->suspendCount > 1) {
      node->suspendCount--;
      /* nested suspend so just undo one level */
      return JVMTI_ERROR_NONE;
  }

  /*
   * This thread was marked for suspension since its THREAD_START
   * event came in during a suspendAll, but the helper hasn't
   * completed the job yet. We decrement the count so the helper
   * won't suspend this thread after we are done with the resumeAll.
   * Another case to be handled here is when the debugger suspends
   * the thread while the app has it suspended. In this case,
   * the toBeResumed flag has been cleared indicating that
   * the thread should not be resumed when the debugger does a resume.
   * In this case, we also have to decrement the suspend count.
   * If we don't then when the app resumes the thread and our Thread.resume
   * bkpt handler is called, blockOnDebuggerSuspend will not resume
   * the thread because suspendCount will be 1 meaning that the
   * debugger has the thread suspended.  See bug 6224859.
   */
  if (node->suspendCount == 1 && (!node->toBeResumed || node->suspendOnStart)) {
      node->suspendCount--;
      return JVMTI_ERROR_NONE;
  }

  if (arg == NULL((void*)0)) {
      /* nothing to hard resume so we're done */
      return JVMTI_ERROR_NONE;
  }

  /*
   * This is tricky. A suspendCount of 1 and toBeResumed means that
   * JVM/DI SuspendThread() or JVM/DI SuspendThreadList() was called
   * on this thread. The check for !suspendOnStart is paranoia that
   * we inherited from resumeThreadByNode().
   */
  if (node->suspendCount == 1 && node->toBeResumed && !node->suspendOnStart) {
      jthread **listPtr = (jthread **)arg;

      **listPtr = node->thread;
      (*listPtr)++;
  }
  return JVMTI_ERROR_NONE;
1188}


1191static jvmtiError
1192resumeCountHelper(JNIEnv *env, ThreadNode *node, void *arg)
1193{
  if (node->isDebugThread) {
      /* never suspended by debugger => don't ever try to resume */
      return JVMTI_ERROR_NONE;
  }

  /*
   * This is tricky. A suspendCount of 1 and toBeResumed means that
   * JVM/DI SuspendThread() or JVM/DI SuspendThreadList() was called
   * on this thread. The check for !suspendOnStart is paranoia that
   * we inherited from resumeThreadByNode().
   */
  if (node->suspendCount == 1 && node->toBeResumed && !node->suspendOnStart) {
      jint *counter = (jint *)arg;

      (*counter)++;
  }
  return JVMTI_ERROR_NONE;
1211}

1213static void *
1214newArray(jint length, size_t nbytes)
1215{
  void *ptr;
  ptr = jvmtiAllocate(length*(jint)nbytes);
  if ( ptr != NULL((void*)0) ) {
      (void)memset(ptr, 0, length*nbytes);
  }
  return ptr;
1222}

1224static void
1225deleteArray(void *ptr)
1226{
  jvmtiDeallocate(ptr);
1228}

1230/*
* This function must be called with the threadLock held.
*
* Two facts conspire to make this routine complicated:
*
* 1) the VM doesn't support nested external suspend
* 2) the original resumeAll code structure doesn't retrieve the
*    entire thread list from JVMTI so we use the runningThreads
*    list and two helpers to get the job done.
*
* Because we hold the threadLock, state seen by resumeCountHelper()
* is the same state seen in resumeCopyHelper(). resumeCountHelper()
* just counts up the number of threads to be hard resumed.
* resumeCopyHelper() does the accounting for nested suspends and
* special cases and, finally, populates the list of hard resume
* threads to be passed to ResumeThreadList().
*
* At first glance, you might think that the accounting could be done
* in resumeCountHelper(), but then resumeCopyHelper() would see
* "post-resume" state in the accounting values (suspendCount and
* toBeResumed) and would not be able to distinguish between a thread
* that needs a hard resume versus a thread that is already running.
*/
1253static jvmtiError
1254commonResumeList(JNIEnv *env)
1255{
  jvmtiError   error;
  jint         i;
  jint         reqCnt;
  jthread     *reqList;
  jthread     *reqPtr;
  jvmtiError  *results;

  reqCnt = 0;

  /* count number of threads to hard resume */
  (void) enumerateOverThreadList(env, &runningThreads, resumeCountHelper,
                                 &reqCnt);
  if (reqCnt == 0) {
      /* nothing to hard resume so do just the accounting part */
      (void) enumerateOverThreadList(env, &runningThreads, resumeCopyHelper,
                                     NULL((void*)0));
      return JVMTI_ERROR_NONE;
  }

  /*LINTED*/
  reqList = newArray(reqCnt, sizeof(jthread));
  if (reqList == NULL((void*)0)) {
      EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"resume request list"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+8))), ((jvmtiError)(JVMTI_ERROR_MAX+64+8)), ("resume request list"
==((void*)0)?"":"resume request list"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1278); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+8)), "resume request list"); };
  }
  /*LINTED*/
  results = newArray(reqCnt, sizeof(jvmtiError));
  if (results == NULL((void*)0)) {
      EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"resume list"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+8))), ((jvmtiError)(JVMTI_ERROR_MAX+64+8)), ("resume list"==
((void*)0)?"":"resume list"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1283); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+8)), "resume list"); };
  }

  /* copy the jthread values for threads to hard resume */
  reqPtr = reqList;
  (void) enumerateOverThreadList(env, &runningThreads, resumeCopyHelper,
                                 &reqPtr);

  error = JVMTI_FUNC_PTR(gdata->jvmti,ResumeThreadList)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1291), log_message_end ("%s()","ResumeThreadList")):((void)0
)),(gdata->jvmti))))->ResumeThreadList))
              (gdata->jvmti, reqCnt, reqList, results);
  for (i = 0; i < reqCnt; i++) {
      ThreadNode *node;

      node = findThread(&runningThreads, reqList[i]);
      if (node == NULL((void*)0)) {
          EXIT_ERROR(AGENT_ERROR_INVALID_THREAD,"missing entry in running thread table"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+23))), ((jvmtiError)(JVMTI_ERROR_MAX+64+23)), ("missing entry in running thread table"
==((void*)0)?"":"missing entry in running thread table"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1298); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+23)), "missing entry in running thread table"); };
      }
      LOG_MISC(("thread=%p resumed as part of list", node->thread))((gdata->log_flags & (0x00000008)) ?(log_message_begin
("MISC","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1300), log_message_end ("thread=%p resumed as part of list",
 node->thread)):((void)0));

      /*
       * resumeThreadByNode() assumes that JVM/DI ResumeThread()
       * always works and does all the accounting updates. We do
       * the same here. We also don't clear the error.
       */
      node->suspendCount--;
      node->toBeResumed = JNI_FALSE0;
      node->frameGeneration++; /* Increment on each resume */
  }
  deleteArray(results);
  deleteArray(reqList);

  debugMonitorNotifyAll(threadLock);

  return error;
1317}


1320/*
* This function must be called after preSuspend and before postSuspend.
*/
1323static jvmtiError
1324commonSuspendList(JNIEnv *env, jint initCount, jthread *initList)
1325{
  jvmtiError  error;
  jint        i;
  jint        reqCnt;
  jthread    *reqList;

  error   = JVMTI_ERROR_NONE;
  reqCnt  = 0;
  reqList = newArray(initCount, sizeof(jthread));
  if (reqList3.1
'reqList' is not equal to NULL
 == NULL((void*)0)) {
4
←
Taking false branch→
      EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"request list"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+8))), ((jvmtiError)(JVMTI_ERROR_MAX+64+8)), ("request list"==
((void*)0)?"":"request list"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1335); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+8)), "request list"); };
  }

  /*
   * Go through the initial list and see if we have anything to suspend.
   */
  for (i = 0; i < initCount; i++) {
5
←
Assuming 'i' is < 'initCount'→
6
←
Loop condition is true.  Entering loop body→
16
←
Assuming 'i' is >= 'initCount'→
17
←
Loop condition is false. Execution continues on line 1374→
      ThreadNode *node;

      /*
       * If the thread is not between its start and end events, we should
       * still suspend it. To keep track of things, add the thread
       * to a separate list of threads so that we'll resume it later.
       */
      node = findThread(&runningThreads, initList[i]);
      if (node == NULL((void*)0)) {
7
←
Assuming 'node' is not equal to NULL→
8
←
Taking false branch→
          node = insertThread(env, &otherThreads, initList[i]);
      }

      if (node->isDebugThread) {
9
←
Assuming field 'isDebugThread' is 0→
10
←
Taking false branch→
          /* Ignore requests for suspending debugger threads */
          continue;
      }

      /*
       * Just increment the suspend count if we are waiting
       * for a deferred suspend or if this is a nested suspend.
       */
      if (node->suspendOnStart || node->suspendCount > 0) {
11
←
Assuming field 'suspendOnStart' is 0→
12
←
Assuming field 'suspendCount' is <= 0→
13
←
Taking false branch→
          node->suspendCount++;
          continue;
      }

      if (node->suspendCount == 0) {
14
←
Assuming field 'suspendCount' is equal to 0→
15
←
Taking true branch→
          /* thread is not suspended yet so put it on the request list */
          reqList[reqCnt++] = initList[i];
      }
  }

  if (reqCnt17.1
'reqCnt' is > 0
 > 0) {
18
←
Taking true branch→
      jvmtiError *results = newArray(reqCnt, sizeof(jvmtiError));

      if (results18.1
'results' is not equal to NULL
 == NULL((void*)0)) {
19
←
Taking false branch→
          EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"suspend list results"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+8))), ((jvmtiError)(JVMTI_ERROR_MAX+64+8)), ("suspend list results"
==((void*)0)?"":"suspend list results"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1378); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+8)), "suspend list results"); };
      }

      /*
       * We have something to suspend so try to do it.
       */
      error = JVMTI_FUNC_PTR(gdata->jvmti,SuspendThreadList)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1384), log_message_end ("%s()","SuspendThreadList")):((void)
0)),(gdata->jvmti))))->SuspendThreadList))
20
←
Assuming the condition is false→
21
←
'?' condition is false→
                      (gdata->jvmti, reqCnt, reqList, results);
      for (i = 0; i < reqCnt; i++) {
22
←
Loop condition is true.  Entering loop body→
          ThreadNode *node;

          node = findThread(NULL((void*)0), reqList[i]);
23
←
Value assigned to 'node'→
          if (node == NULL((void*)0)) {
24
←
Assuming 'node' is equal to NULL→
25
←
Taking true branch→
              EXIT_ERROR(AGENT_ERROR_INVALID_THREAD,"missing entry in thread tables"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+23))), ((jvmtiError)(JVMTI_ERROR_MAX+64+23)), ("missing entry in thread tables"
==((void*)0)?"":"missing entry in thread tables"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1391); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+23)), "missing entry in thread tables"); };
26
←
'?' condition is false→
          }
          LOG_MISC(("thread=%p suspended as part of list", node->thread))((gdata->log_flags & (0x00000008)) ?(log_message_begin
("MISC","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1393), log_message_end ("thread=%p suspended as part of list"
, node->thread)):((void)0));
27
←
Assuming the condition is true→
28
←
'?' condition is true→
29
←
Access to field 'thread' results in a dereference of a null pointer (loaded from variable 'node')

          if (results[i] == JVMTI_ERROR_NONE) {
              /* thread was suspended as requested */
              node->toBeResumed = JNI_TRUE1;
          } else if (results[i] == JVMTI_ERROR_THREAD_SUSPENDED) {
              /*
               * If the thread was suspended by another app thread,
               * do nothing and report no error (we won't resume it later).
               */
              results[i] = JVMTI_ERROR_NONE;
          } else if (results[i] == JVMTI_ERROR_THREAD_NOT_ALIVE) {
              /*
               * This error means that the suspend request failed
               * because the thread is either a zombie or not yet
               * started. In either case, we ignore the error. If the
               * thread is a zombie, suspend/resume are no-ops. If the
               * thread is not started, it will be suspended for real
               * during the processing of its thread start event.
               */
              node->suspendOnStart = JNI_TRUE1;
              results[i] = JVMTI_ERROR_NONE;
          }

          /* count real, app and deferred (suspendOnStart) suspensions */
          if (results[i] == JVMTI_ERROR_NONE) {
              node->suspendCount++;
          }
      }
      deleteArray(results);
  }
  deleteArray(reqList);

  debugMonitorNotifyAll(threadLock);

  return error;
1429}

1431static jvmtiError
1432commonResume(jthread thread)
1433{
  jvmtiError  error;
  ThreadNode *node;

  /*
   * The thread is normally between its start and end events, but if
   * not, check the auxiliary list used by threadControl_suspendThread.
   */
  node = findThread(NULL((void*)0), thread);
1442#if 0
  tty_message("commonResume: node(%p) suspendCount(%d) %s", node, node->suspendCount, node->name);
1444#endif

  /*
   * If the node is in neither list, the debugger never suspended
   * this thread, so do nothing.
   */
  error = JVMTI_ERROR_NONE;
  if (node != NULL((void*)0)) {
      error = resumeThreadByNode(node);
  }
  return error;
1455}


1458jvmtiError
1459threadControl_suspendThread(jthread thread, jboolean deferred)
1460{
  jvmtiError error;
  JNIEnv    *env;

  env = getEnv();

  log_debugee_location("threadControl_suspendThread()", thread, NULL((void*)0), 0);

  preSuspend();
  error = commonSuspend(env, thread, deferred);
  postSuspend();

  return error;
1473}

1475jvmtiError
1476threadControl_resumeThread(jthread thread, jboolean do_unblock)
1477{
  jvmtiError error;
  JNIEnv    *env;

  env = getEnv();

  log_debugee_location("threadControl_resumeThread()", thread, NULL((void*)0), 0);

  eventHandler_lock(); /* for proper lock order */
  debugMonitorEnter(threadLock);
  error = commonResume(thread);
  removeResumed(env, &otherThreads);
  debugMonitorExit(threadLock);
  eventHandler_unlock();

  if (do_unblock) {
      /* let eventHelper.c: commandLoop() know we resumed one thread */
      unblockCommandLoop();
  }

  return error;
1498}

1500jvmtiError
1501threadControl_suspendCount(jthread thread, jint *count)
1502{
  jvmtiError  error;
  ThreadNode *node;

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node == NULL((void*)0)) {
      node = findThread(&otherThreads, thread);
  }

  error = JVMTI_ERROR_NONE;
  if (node != NULL((void*)0)) {
      *count = node->suspendCount;
  } else {
      /*
       * If the node is in neither list, the debugger never suspended
       * this thread, so the suspend count is 0.
       */
      *count = 0;
  }

  debugMonitorExit(threadLock);

  return error;
1527}

1529static jboolean
1530contains(JNIEnv *env, jthread *list, jint count, jthread item)
1531{
  int i;

  for (i = 0; i < count; i++) {
      if (isSameObject(env, list[i], item)) {
          return JNI_TRUE1;
      }
  }
  return JNI_FALSE0;
1540}


1543typedef struct {
  jthread *list;
  jint count;
1546} SuspendAllArg;

1548static jvmtiError
1549suspendAllHelper(JNIEnv *env, ThreadNode *node, void *arg)
1550{
  SuspendAllArg *saArg = (SuspendAllArg *)arg;
  jvmtiError error = JVMTI_ERROR_NONE;
  jthread *list = saArg->list;
  jint count = saArg->count;
  if (!contains(env, list, count, node->thread)) {
      error = commonSuspend(env, node->thread, JNI_FALSE0);
  }
  return error;
1559}

1561jvmtiError
1562threadControl_suspendAll(void)
1563{
  jvmtiError error;
  JNIEnv    *env;
1566#if 0
  tty_message("threadControl_suspendAll: suspendAllCount(%d)", suspendAllCount);
1568#endif

  env = getEnv();

  log_debugee_location("threadControl_suspendAll()", NULL((void*)0), NULL((void*)0), 0);

  preSuspend();

  /*
   * Get a list of all threads and suspend them.
   */
  WITH_LOCAL_REFS(env, 1)createLocalRefSpace(env, 1); { {

      jthread *threads;
      jint count;

      threads = allThreads(&count);
      if (threads == NULL((void*)0)) {
1
Assuming 'threads' is not equal to NULL→
2
←
Taking false branch→
          error = AGENT_ERROR_OUT_OF_MEMORY((jvmtiError)(JVMTI_ERROR_MAX+64+8));
          goto err;
      }
      error = commonSuspendList(env, count, threads);
3
←
Calling 'commonSuspendList'→
      if (error != JVMTI_ERROR_NONE) {
          goto err;
      }

      /*
       * Update the suspend count of any threads not yet (or no longer)
       * in the thread list above.
       */
      {
          SuspendAllArg arg;
          arg.list = threads;
          arg.count = count;
          error = enumerateOverThreadList(env, &otherThreads,
                                          suspendAllHelper, &arg);
      }

      if (error == JVMTI_ERROR_NONE) {
          /*
           * Pin all objects to prevent objects from being
           * garbage collected while the VM is suspended.
           */
          commonRef_pinAll();

          suspendAllCount++;
      }

  err:
      jvmtiDeallocate(threads);

  } END_WITH_LOCAL_REFS(env)(*((*((((gdata->log_flags & (0x00000002)) ?(log_message_begin
("JNI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1619), log_message_end ("%s()","PopLocalFrame")):((void)0)),
 (env))))->PopLocalFrame))(env, ((void*)0)); }

  postSuspend();

  return error;
1624}

1626static jvmtiError
1627resumeHelper(JNIEnv *env, ThreadNode *node, void *ignored)
1628{
  /*
   * Since this helper is called with the threadLock held, we
   * don't need to recheck to see if the node is still on one
   * of the two thread lists.
   */
  return resumeThreadByNode(node);
1635}

1637jvmtiError
1638threadControl_resumeAll(void)
1639{
  jvmtiError error;
  JNIEnv    *env;
1642#if 0
  tty_message("threadControl_resumeAll: suspendAllCount(%d)", suspendAllCount);
1644#endif

  env = getEnv();

  log_debugee_location("threadControl_resumeAll()", NULL((void*)0), NULL((void*)0), 0);

  eventHandler_lock(); /* for proper lock order */
  debugMonitorEnter(threadLock);

  /*
   * Resume only those threads that the debugger has suspended. All
   * such threads must have a node in one of the thread lists, so there's
   * no need to get the whole thread list from JVMTI (unlike
   * suspendAll).
   */
  error = commonResumeList(env);
  if ((error == JVMTI_ERROR_NONE) && (otherThreads.first != NULL((void*)0))) {
      error = enumerateOverThreadList(env, &otherThreads,
                                      resumeHelper, NULL((void*)0));
      removeResumed(env, &otherThreads);
  }

  if (suspendAllCount > 0) {
      /*
       * Unpin all objects.
       */
      commonRef_unpinAll();

      suspendAllCount--;
  }

  debugMonitorExit(threadLock);
  eventHandler_unlock();
  /* let eventHelper.c: commandLoop() know we are resuming */
  unblockCommandLoop();

  return error;
1681}


1684StepRequest *
1685threadControl_getStepRequest(jthread thread)
1686{
  ThreadNode  *node;
  StepRequest *step;

  step = NULL((void*)0);

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0)) {
      step = &node->currentStep;
  }

  debugMonitorExit(threadLock);

  return step;
1702}

1704InvokeRequest *
1705threadControl_getInvokeRequest(jthread thread)
1706{
  ThreadNode    *node;
  InvokeRequest *request;

  request = NULL((void*)0);

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0)) {
       request = &node->currentInvoke;
  }

  debugMonitorExit(threadLock);

  return request;
1722}

1724jvmtiError
1725threadControl_addDebugThread(jthread thread)
1726{
  jvmtiError error;

  debugMonitorEnter(threadLock);
  if (debugThreadCount >= MAX_DEBUG_THREADS10) {
      error = AGENT_ERROR_OUT_OF_MEMORY((jvmtiError)(JVMTI_ERROR_MAX+64+8));
  } else {
      JNIEnv    *env;

      env = getEnv();
      debugThreads[debugThreadCount] = NULL((void*)0);
      saveGlobalRef(env, thread, &(debugThreads[debugThreadCount]));
      if (debugThreads[debugThreadCount] == NULL((void*)0)) {
          error = AGENT_ERROR_OUT_OF_MEMORY((jvmtiError)(JVMTI_ERROR_MAX+64+8));
      } else {
          debugThreadCount++;
          error = JVMTI_ERROR_NONE;
      }
  }
  debugMonitorExit(threadLock);
  return error;
1747}

1749static jvmtiError
1750threadControl_removeDebugThread(jthread thread)
1751{
  jvmtiError error;
  JNIEnv    *env;
  int        i;

  error = AGENT_ERROR_INVALID_THREAD((jvmtiError)(JVMTI_ERROR_MAX+64+23));
  env   = getEnv();

  debugMonitorEnter(threadLock);
  for (i = 0; i< debugThreadCount; i++) {
      if (isSameObject(env, thread, debugThreads[i])) {
          int j;

          tossGlobalRef(env, &(debugThreads[i]));
          for (j = i+1; j < debugThreadCount; j++) {
              debugThreads[j-1] = debugThreads[j];
          }
          debugThreadCount--;
          error = JVMTI_ERROR_NONE;
          break;
      }
  }
  debugMonitorExit(threadLock);
  return error;
1775}

1777jboolean
1778threadControl_isDebugThread(jthread thread)
1779{
  int      i;
  jboolean rc;
  JNIEnv  *env;

  rc  = JNI_FALSE0;
  env = getEnv();

  debugMonitorEnter(threadLock);
  for (i = 0; i < debugThreadCount; i++) {
      if (isSameObject(env, thread, debugThreads[i])) {
          rc = JNI_TRUE1;
          break;
      }
  }
  debugMonitorExit(threadLock);
  return rc;
1796}

1798static void
1799initLocks(void)
1800{
  if (popFrameEventLock == NULL((void*)0)) {
      popFrameEventLock = debugMonitorCreate("JDWP PopFrame Event Lock");
      popFrameProceedLock = debugMonitorCreate("JDWP PopFrame Proceed Lock");
  }
1805}

1807static jboolean
1808getPopFrameThread(jthread thread)
1809{
  jboolean popFrameThread;

  debugMonitorEnter(threadLock);
  {
      ThreadNode *node;

      node = findThread(NULL((void*)0), thread);
      if (node == NULL((void*)0)) {
          popFrameThread = JNI_FALSE0;
      } else {
          popFrameThread = node->popFrameThread;
      }
  }
  debugMonitorExit(threadLock);

  return popFrameThread;
1826}

1828static void
1829setPopFrameThread(jthread thread, jboolean value)
1830{
  debugMonitorEnter(threadLock);
  {
      ThreadNode *node;

      node = findThread(NULL((void*)0), thread);
      if (node == NULL((void*)0)) {
          EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+21))), ((jvmtiError)(JVMTI_ERROR_MAX+64+21)), ("entry in thread table"
==((void*)0)?"":"entry in thread table"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1837); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+21)), "entry in thread table"); };
      } else {
          node->popFrameThread = value;
      }
  }
  debugMonitorExit(threadLock);
1843}

1845static jboolean
1846getPopFrameEvent(jthread thread)
1847{
  jboolean popFrameEvent;

  debugMonitorEnter(threadLock);
  {
      ThreadNode *node;

      node = findThread(NULL((void*)0), thread);
      if (node == NULL((void*)0)) {
          popFrameEvent = JNI_FALSE0;
          EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+21))), ((jvmtiError)(JVMTI_ERROR_MAX+64+21)), ("entry in thread table"
==((void*)0)?"":"entry in thread table"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1857); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+21)), "entry in thread table"); };
      } else {
          popFrameEvent = node->popFrameEvent;
      }
  }
  debugMonitorExit(threadLock);

  return popFrameEvent;
1865}

1867static void
1868setPopFrameEvent(jthread thread, jboolean value)
1869{
  debugMonitorEnter(threadLock);
  {
      ThreadNode *node;

      node = findThread(NULL((void*)0), thread);
      if (node == NULL((void*)0)) {
          EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+21))), ((jvmtiError)(JVMTI_ERROR_MAX+64+21)), ("entry in thread table"
==((void*)0)?"":"entry in thread table"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1876); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+21)), "entry in thread table"); };
      } else {
          node->popFrameEvent = value;
          node->frameGeneration++; /* Increment on each resume */
      }
  }
  debugMonitorExit(threadLock);
1883}

1885static jboolean
1886getPopFrameProceed(jthread thread)
1887{
  jboolean popFrameProceed;

  debugMonitorEnter(threadLock);
  {
      ThreadNode *node;

      node = findThread(NULL((void*)0), thread);
      if (node == NULL((void*)0)) {
          popFrameProceed = JNI_FALSE0;
          EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+21))), ((jvmtiError)(JVMTI_ERROR_MAX+64+21)), ("entry in thread table"
==((void*)0)?"":"entry in thread table"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1897); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+21)), "entry in thread table"); };
      } else {
          popFrameProceed = node->popFrameProceed;
      }
  }
  debugMonitorExit(threadLock);

  return popFrameProceed;
1905}

1907static void
1908setPopFrameProceed(jthread thread, jboolean value)
1909{
  debugMonitorEnter(threadLock);
  {
      ThreadNode *node;

      node = findThread(NULL((void*)0), thread);
      if (node == NULL((void*)0)) {
          EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+21))), ((jvmtiError)(JVMTI_ERROR_MAX+64+21)), ("entry in thread table"
==((void*)0)?"":"entry in thread table"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 1916); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+21)), "entry in thread table"); };
      } else {
          node->popFrameProceed = value;
      }
  }
  debugMonitorExit(threadLock);
1922}

1924/**
* Special event handler for events on the popped thread
* that occur during the pop operation.
*/
1928static void
1929popFrameCompleteEvent(jthread thread)
1930{
    debugMonitorEnter(popFrameProceedLock);
    {
        /* notify that we got the event */
        debugMonitorEnter(popFrameEventLock);
        {
            setPopFrameEvent(thread, JNI_TRUE1);
            debugMonitorNotify(popFrameEventLock);
        }
        debugMonitorExit(popFrameEventLock);

        /* make sure we get suspended again */
        setPopFrameProceed(thread, JNI_FALSE0);
        while (getPopFrameProceed(thread) == JNI_FALSE0) {
            debugMonitorWait(popFrameProceedLock);
        }
    }
    debugMonitorExit(popFrameProceedLock);
1948}

1950/**
* Pop one frame off the stack of thread.
* popFrameEventLock is already held
*/
1954static jvmtiError
1955popOneFrame(jthread thread)
1956{
  jvmtiError error;

  error = JVMTI_FUNC_PTR(gdata->jvmti,PopFrame)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1959), log_message_end ("%s()","PopFrame")):((void)0)),(gdata
->jvmti))))->PopFrame))(gdata->jvmti, thread);
  if (error != JVMTI_ERROR_NONE) {
      return error;
  }

  /* resume the popped thread so that the pop occurs and so we */
  /* will get the event (step or method entry) after the pop */
  LOG_MISC(("thread=%p resumed in popOneFrame", thread))((gdata->log_flags & (0x00000008)) ?(log_message_begin
("MISC","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1966), log_message_end ("thread=%p resumed in popOneFrame", thread
)):((void)0));
  error = JVMTI_FUNC_PTR(gdata->jvmti,ResumeThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1967), log_message_end ("%s()","ResumeThread")):((void)0)),(
gdata->jvmti))))->ResumeThread))(gdata->jvmti, thread);
  if (error != JVMTI_ERROR_NONE) {
      return error;
  }

  /* wait for the event to occur */
  setPopFrameEvent(thread, JNI_FALSE0);
  while (getPopFrameEvent(thread) == JNI_FALSE0) {
      debugMonitorWait(popFrameEventLock);
  }

  /* make sure not to suspend until the popped thread is on the wait */
  debugMonitorEnter(popFrameProceedLock);
  {
      /* return popped thread to suspended state */
      LOG_MISC(("thread=%p suspended in popOneFrame", thread))((gdata->log_flags & (0x00000008)) ?(log_message_begin
("MISC","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1982), log_message_end ("thread=%p suspended in popOneFrame"
, thread)):((void)0));
      error = JVMTI_FUNC_PTR(gdata->jvmti,SuspendThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,1983), log_message_end ("%s()","SuspendThread")):((void)0)),
(gdata->jvmti))))->SuspendThread))(gdata->jvmti, thread);

      /* notify popped thread so it can proceed when resumed */
      setPopFrameProceed(thread, JNI_TRUE1);
      debugMonitorNotify(popFrameProceedLock);
  }
  debugMonitorExit(popFrameProceedLock);

  return error;
1992}

1994/**
* pop frames of the stack of 'thread' until 'frame' is popped.
*/
1997jvmtiError
1998threadControl_popFrames(jthread thread, FrameNumber fnum)
1999{
  jvmtiError error;
  jvmtiEventMode prevStepMode;
  jint framesPopped = 0;
  jint popCount;
  jboolean prevInvokeRequestMode;

  log_debugee_location("threadControl_popFrames()", thread, NULL((void*)0), 0);

  initLocks();

  /* compute the number of frames to pop */
  popCount = fnum+1;
  if (popCount < 1) {
      return AGENT_ERROR_NO_MORE_FRAMES((jvmtiError)(JVMTI_ERROR_MAX+64+26));
  }

  /* enable instruction level single step, but first note prev value */
  prevStepMode = threadControl_getInstructionStepMode(thread);

  /*
   * Fix bug 6517249.  The pop processing will disable invokes,
   * so remember if invokes are enabled now and restore
   * that state after we finish popping.
   */
  prevInvokeRequestMode = invoker_isEnabled(thread);

  error = threadControl_setEventMode(JVMTI_ENABLE,
                                     EI_SINGLE_STEP, thread);
  if (error != JVMTI_ERROR_NONE) {
      return error;
  }

  /* Inform eventHandler logic we are in a popFrame for this thread */
  debugMonitorEnter(popFrameEventLock);
  {
      setPopFrameThread(thread, JNI_TRUE1);
      /* pop frames using single step */
      while (framesPopped++ < popCount) {
          error = popOneFrame(thread);
          if (error != JVMTI_ERROR_NONE) {
              break;
          }
      }
      setPopFrameThread(thread, JNI_FALSE0);
  }
  debugMonitorExit(popFrameEventLock);

  /*  Reset StepRequest info (fromLine and stackDepth) after popframes
   *  only if stepping is enabled.
   */
  if (prevStepMode == JVMTI_ENABLE) {
      stepControl_resetRequest(thread);
  }

  if (prevInvokeRequestMode) {
      invoker_enableInvokeRequests(thread);
  }

  /* restore state */
  (void)threadControl_setEventMode(prevStepMode,
                             EI_SINGLE_STEP, thread);

  return error;
2063}

2065/* Check to see if any events are being consumed by a popFrame(). */
2066static jboolean
2067checkForPopFrameEvents(JNIEnv *env, EventIndex ei, jthread thread)
2068{
  if ( getPopFrameThread(thread) ) {
      switch (ei) {
          case EI_THREAD_START:
              /* Excuse me? */
              EXIT_ERROR(AGENT_ERROR_INTERNAL, "thread start during pop frame"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+1))), ((jvmtiError)(JVMTI_ERROR_MAX+64+1)), ("thread start during pop frame"
==((void*)0)?"":"thread start during pop frame"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 2073); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+1)), "thread start during pop frame"); };
              break;
          case EI_THREAD_END:
              /* Thread wants to end? let it. */
              setPopFrameThread(thread, JNI_FALSE0);
              popFrameCompleteEvent(thread);
              break;
          case EI_SINGLE_STEP:
              /* This is an event we requested to mark the */
              /*        completion of the pop frame */
              popFrameCompleteEvent(thread);
              return JNI_TRUE1;
          case EI_BREAKPOINT:
          case EI_EXCEPTION:
          case EI_FIELD_ACCESS:
          case EI_FIELD_MODIFICATION:
          case EI_METHOD_ENTRY:
          case EI_METHOD_EXIT:
              /* Tell event handler to assume event has been consumed. */
              return JNI_TRUE1;
          default:
              break;
      }
  }
  /* Pretend we were never called */
  return JNI_FALSE0;
2099}

2101struct bag *
2102threadControl_onEventHandlerEntry(jbyte sessionID, EventInfo *evinfo, jobject currentException)
2103{
  ThreadNode *node;
  JNIEnv     *env;
  struct bag *eventBag;
  jthread     threadToSuspend;
  jboolean    consumed;
  EventIndex  ei = evinfo->ei;
  jthread     thread = evinfo->thread;

  env             = getEnv();
  threadToSuspend = NULL((void*)0);

  log_debugee_location("threadControl_onEventHandlerEntry()", thread, NULL((void*)0), 0);

  /* Events during pop commands may need to be ignored here. */
  consumed = checkForPopFrameEvents(env, ei, thread);
  if ( consumed ) {
      /* Always restore any exception (see below). */
      if (currentException != NULL((void*)0)) {
          JNI_FUNC_PTR(env,Throw)(*((*((((gdata->log_flags & (0x00000002)) ?(log_message_begin
("JNI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2122), log_message_end ("%s()","Throw")):((void)0)), (env)))
)->Throw))(env, currentException);
      } else {
          JNI_FUNC_PTR(env,ExceptionClear)(*((*((((gdata->log_flags & (0x00000002)) ?(log_message_begin
("JNI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2124), log_message_end ("%s()","ExceptionClear")):((void)0))
, (env))))->ExceptionClear))(env);
      }
      return NULL((void*)0);
  }

  debugMonitorEnter(threadLock);

  /*
   * Check the list of unknown threads maintained by suspend
   * and resume. If this thread is currently present in the
   * list, it should be
   * moved to the runningThreads list, since it is a
   * well-known thread now.
   */
  node = findThread(&otherThreads, thread);
  if (node != NULL((void*)0)) {
      moveNode(&otherThreads, &runningThreads, node);
      /* Now that we know the thread has started, we can set its TLS.*/
      setThreadLocalStorage(thread, (void*)node);
  } else {
      /*
       * Get a thread node for the reporting thread. For thread start
       * events, or if this event precedes a thread start event,
       * the thread node may need to be created.
       *
       * It is possible for certain events (notably method entry/exit)
       * to precede thread start for some VM implementations.
       */
      node = insertThread(env, &runningThreads, thread);
  }

  if (ei == EI_THREAD_START) {
      node->isStarted = JNI_TRUE1;
      processDeferredEventModes(env, thread, node);
  }

  node->current_ei = ei;
  eventBag = node->eventBag;
  if (node->suspendOnStart) {
      threadToSuspend = node->thread;
  }
  debugMonitorExit(threadLock);

  if (threadToSuspend != NULL((void*)0)) {
      /*
       * An attempt was made to suspend this thread before it started.
       * We must suspend it now, before it starts to run. This must
       * be done with no locks held.
       */
      eventHelper_suspendThread(sessionID, threadToSuspend);
  }

  return eventBag;
2177}

2179static void
2180doPendingTasks(JNIEnv *env, ThreadNode *node)
2181{
  /* Deferred breakpoint handling for Thread.resume() */
  if (node->handlingAppResume) {
      jthread resumer = node->thread;
      jthread resumee = getResumee(resumer);

      if (resumer != NULL((void*)0)) {
          /*
           * trackAppResume indirectly aquires handlerLock. For proper lock
           * ordering handlerLock has to be acquired before threadLock.
           */
          debugMonitorExit(threadLock);
          eventHandler_lock();
          debugMonitorEnter(threadLock);

          /*
           * Track the resuming thread by marking it as being within
           * a resume and by setting up for notification on
           * a frame pop or exception. We won't allow the debugger
           * to suspend threads while any thread is within a
           * call to resume. This (along with the block below)
           * ensures that when the debugger
           * suspends a thread it will remain suspended.
           */
          trackAppResume(resumer);

          /*
           * handlerLock is not needed anymore. We must release it before calling
           * blockOnDebuggerSuspend() because it is required for resumes done by
           * the debugger. If resumee is currently suspended by the debugger, then
           * blockOnDebuggerSuspend() will block until a debugger resume is done.
           * If it blocks while holding the handlerLock, then the resume will deadlock.
           */
          eventHandler_unlock();
      }

      if (resumee != NULL((void*)0)) {
          /*
           * Hold up any attempt to resume as long as the debugger
           * has suspended the resumee.
           */
          blockOnDebuggerSuspend(resumee);
      }

      node->handlingAppResume = JNI_FALSE0;

      /*
       * The blocks exit condition: resumee's suspendCount == 0.
       *
       * Debugger suspends are blocked if any thread is executing
       * Thread.resume(), i.e. !handlingAppResume && frameDepth > 0.
       */
  }

  /*
   * Take care of any pending interrupts/stops, and clear out
   * info on pending interrupts/stops.
   */
  if (node->pendingInterrupt) {
      JVMTI_FUNC_PTR(gdata->jvmti,InterruptThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2240), log_message_end ("%s()","InterruptThread")):((void)0)
),(gdata->jvmti))))->InterruptThread))
                      (gdata->jvmti, node->thread);
      /*
       * TO DO: Log error
       */
      node->pendingInterrupt = JNI_FALSE0;
  }

  if (node->pendingStop != NULL((void*)0)) {
      JVMTI_FUNC_PTR(gdata->jvmti,StopThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2249), log_message_end ("%s()","StopThread")):((void)0)),(gdata
->jvmti))))->StopThread))
                      (gdata->jvmti, node->thread, node->pendingStop);
      /*
       * TO DO: Log error
       */
      tossGlobalRef(env, &(node->pendingStop));
  }
2256}

2258void
2259threadControl_onEventHandlerExit(EventIndex ei, jthread thread,
                               struct bag *eventBag)
2261{
  ThreadNode *node;

  log_debugee_location("threadControl_onEventHandlerExit()", thread, NULL((void*)0), 0);

  if (ei == EI_THREAD_END) {
      eventHandler_lock(); /* for proper lock order */
  }
  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node == NULL((void*)0)) {
      EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"thread list corrupted"){ print_message(stderr, "JDWP exit error ", "\n", "%s(%d): %s [%s:%d]"
, jvmtiErrorText((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX+64
+21))), ((jvmtiError)(JVMTI_ERROR_MAX+64+21)), ("thread list corrupted"
==((void*)0)?"":"thread list corrupted"), "/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 2273); debugInit_exit((jvmtiError)((jvmtiError)(JVMTI_ERROR_MAX
+64+21)), "thread list corrupted"); };
  } else {
      JNIEnv *env;

      env = getEnv();
      if (ei == EI_THREAD_END) {
          jboolean inResume = (node->resumeFrameDepth > 0);
          removeThread(env, &runningThreads, thread);
          node = NULL((void*)0);   /* has been freed */

          /*
           * Clean up mechanism used to detect end of
           * resume.
           */
          if (inResume) {
              notifyAppResumeComplete();
          }
      } else {
          /* No point in doing this if the thread is about to die.*/
          doPendingTasks(env, node);
          node->eventBag = eventBag;
          node->current_ei = 0;
      }
  }

  debugMonitorExit(threadLock);
  if (ei == EI_THREAD_END) {
      eventHandler_unlock();
  }
2302}

2304/* Returns JDWP flavored status and status flags. */
2305jvmtiError
2306threadControl_applicationThreadStatus(jthread thread,
                      jdwpThreadStatus *pstatus, jint *statusFlags)
2308{
  ThreadNode *node;
  jvmtiError  error;
  jint        state;

  log_debugee_location("threadControl_applicationThreadStatus()", thread, NULL((void*)0), 0);

  debugMonitorEnter(threadLock);

  error = threadState(thread, &state);
  *pstatus = map2jdwpThreadStatus(state);
  *statusFlags = map2jdwpSuspendStatus(state);

  if (error == JVMTI_ERROR_NONE) {
      node = findThread(&runningThreads, thread);
      if ((node != NULL((void*)0)) && HANDLING_EVENT(node)((node)->current_ei != 0)) {
          /*
           * While processing an event, an application thread is always
           * considered to be running even if its handler happens to be
           * cond waiting on an internal debugger monitor, etc.
           *
           * Leave suspend status untouched since it is not possible
           * to distinguish debugger suspends from app suspends.
           */
          *pstatus = JDWP_THREAD_STATUS(RUNNING)1;
      }
  }

  debugMonitorExit(threadLock);

  return error;
2339}

2341jvmtiError
2342threadControl_interrupt(jthread thread)
2343{
  ThreadNode *node;
  jvmtiError  error;

  error = JVMTI_ERROR_NONE;

  log_debugee_location("threadControl_interrupt()", thread, NULL((void*)0), 0);

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if ((node == NULL((void*)0)) || !HANDLING_EVENT(node)((node)->current_ei != 0)) {
      error = JVMTI_FUNC_PTR(gdata->jvmti,InterruptThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2355), log_message_end ("%s()","InterruptThread")):((void)0)
),(gdata->jvmti))))->InterruptThread))
                      (gdata->jvmti, thread);
  } else {
      /*
       * Hold any interrupts until after the event is processed.
       */
      node->pendingInterrupt = JNI_TRUE1;
  }

  debugMonitorExit(threadLock);

  return error;
2367}

2369void
2370threadControl_clearCLEInfo(JNIEnv *env, jthread thread)
2371{
  ThreadNode *node;

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0)) {
      node->cleInfo.ei = 0;
      if (node->cleInfo.clazz != NULL((void*)0)) {
          tossGlobalRef(env, &(node->cleInfo.clazz));
      }
  }

  debugMonitorExit(threadLock);
2385}

2387jboolean
2388threadControl_cmpCLEInfo(JNIEnv *env, jthread thread, jclass clazz,
                       jmethodID method, jlocation location)
2390{
  ThreadNode *node;
  jboolean    result;

  result = JNI_FALSE0;

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0) && node->cleInfo.ei != 0 &&
      node->cleInfo.method == method &&
      node->cleInfo.location == location &&
      (isSameObject(env, node->cleInfo.clazz, clazz))) {
      result = JNI_TRUE1; /* we have a match */
  }

  debugMonitorExit(threadLock);

  return result;
2409}

2411void
2412threadControl_saveCLEInfo(JNIEnv *env, jthread thread, EventIndex ei,
                        jclass clazz, jmethodID method, jlocation location)
2414{
  ThreadNode *node;

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0)) {
      node->cleInfo.ei = ei;
      /* Create a class ref that will live beyond */
      /* the end of this call */
      saveGlobalRef(env, clazz, &(node->cleInfo.clazz));
      /* if returned clazz is NULL, we just won't match */
      node->cleInfo.method    = method;
      node->cleInfo.location  = location;
  }

  debugMonitorExit(threadLock);
2431}

2433void
2434threadControl_setPendingInterrupt(jthread thread)
2435{
  ThreadNode *node;

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0)) {
      node->pendingInterrupt = JNI_TRUE1;
  }

  debugMonitorExit(threadLock);
2446}

2448jvmtiError
2449threadControl_stop(jthread thread, jobject throwable)
2450{
  ThreadNode *node;
  jvmtiError  error;

  error = JVMTI_ERROR_NONE;

  log_debugee_location("threadControl_stop()", thread, NULL((void*)0), 0);

  debugMonitorEnter(threadLock);

  node = findThread(&runningThreads, thread);
  if ((node == NULL((void*)0)) || !HANDLING_EVENT(node)((node)->current_ei != 0)) {
      error = JVMTI_FUNC_PTR(gdata->jvmti,StopThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2462), log_message_end ("%s()","StopThread")):((void)0)),(gdata
->jvmti))))->StopThread))
                      (gdata->jvmti, thread, throwable);
  } else {
      JNIEnv *env;

      /*
       * Hold any stops until after the event is processed.
       */
      env = getEnv();
      saveGlobalRef(env, throwable, &(node->pendingStop));
  }

  debugMonitorExit(threadLock);

  return error;
2477}

2479static jvmtiError
2480detachHelper(JNIEnv *env, ThreadNode *node, void *arg)
2481{
  invoker_detach(&node->currentInvoke);
  return JVMTI_ERROR_NONE;
2484}

2486void
2487threadControl_detachInvokes(void)
2488{
  JNIEnv *env;

  env = getEnv();
  invoker_lock(); /* for proper lock order */
  debugMonitorEnter(threadLock);
  (void)enumerateOverThreadList(env, &runningThreads, detachHelper, NULL((void*)0));
  debugMonitorExit(threadLock);
  invoker_unlock();
2497}

2499static jvmtiError
2500resetHelper(JNIEnv *env, ThreadNode *node, void *arg)
2501{
  if (node->toBeResumed) {
      LOG_MISC(("thread=%p resumed", node->thread))((gdata->log_flags & (0x00000008)) ?(log_message_begin
("MISC","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2503), log_message_end ("thread=%p resumed", node->thread
)):((void)0));
      (void)JVMTI_FUNC_PTR(gdata->jvmti,ResumeThread)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2504), log_message_end ("%s()","ResumeThread")):((void)0)),(
gdata->jvmti))))->ResumeThread))(gdata->jvmti, node->thread);
      node->frameGeneration++; /* Increment on each resume */
  }
  stepControl_clearRequest(node->thread, &node->currentStep);
  node->toBeResumed = JNI_FALSE0;
  node->suspendCount = 0;
  node->suspendOnStart = JNI_FALSE0;

  return JVMTI_ERROR_NONE;
2513}

2515void
2516threadControl_reset(void)
2517{
  JNIEnv *env;

  env = getEnv();
  eventHandler_lock(); /* for proper lock order */
  debugMonitorEnter(threadLock);
  (void)enumerateOverThreadList(env, &runningThreads, resetHelper, NULL((void*)0));
  (void)enumerateOverThreadList(env, &otherThreads, resetHelper, NULL((void*)0));

  removeResumed(env, &otherThreads);

  freeDeferredEventModes(env);

  suspendAllCount = 0;

  /* Everything should have been resumed */
  JDI_ASSERT(otherThreads.first == NULL)do { if (gdata && gdata->assertOn && !(otherThreads
.first == ((void*)0))) { jdiAssertionFailed("/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
, 2533, "otherThreads.first == NULL"); } } while (0);

  /* Threads could be waiting in blockOnDebuggerSuspend */
  debugMonitorNotifyAll(threadLock);
  debugMonitorExit(threadLock);
  eventHandler_unlock();
2539}

2541jvmtiEventMode
2542threadControl_getInstructionStepMode(jthread thread)
2543{
  ThreadNode    *node;
  jvmtiEventMode mode;

  mode = JVMTI_DISABLE;

  debugMonitorEnter(threadLock);
  node = findThread(&runningThreads, thread);
  if (node != NULL((void*)0)) {
      mode = node->instructionStepMode;
  }
  debugMonitorExit(threadLock);
  return mode;
2556}

2558jvmtiError
2559threadControl_setEventMode(jvmtiEventMode mode, EventIndex ei, jthread thread)
2560{
  jvmtiError error;

  /* Global event */
  if ( thread == NULL((void*)0) ) {
      error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventNotificationMode)(*((*((((gdata->log_flags & (0x00000004))?(log_message_begin
("JVMTI","/home/daniel/Projects/java/jdk/src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c"
,2565), log_message_end ("%s()","SetEventNotificationMode")):
((void)0)),(gdata->jvmti))))->SetEventNotificationMode)
)
                  (gdata->jvmti, mode, eventIndex2jvmti(ei), thread);
  } else {
      /* Thread event */
      ThreadNode *node;

      debugMonitorEnter(threadLock);
      {
          node = findThread(&runningThreads, thread);
          if ((node == NULL((void*)0)) || (!node->isStarted)) {
              JNIEnv *env;

              env = getEnv();
              error = addDeferredEventMode(env, mode, ei, thread);
          } else {
              error = threadSetEventNotificationMode(node,
                      mode, ei, thread);
          }
      }
      debugMonitorExit(threadLock);

  }
  return error;
2588}

2590/*
* Returns the current thread, if the thread has generated at least
* one event, and has not generated a thread end event.
*/
2594jthread
2595threadControl_currentThread(void)
2596{
  jthread thread;

  debugMonitorEnter(threadLock);
  {
      ThreadNode *node;

      node = findThread(&runningThreads, NULL((void*)0));
      thread = (node == NULL((void*)0)) ? NULL((void*)0) : node->thread;
  }
  debugMonitorExit(threadLock);

  return thread;
2609}

2611jlong
2612threadControl_getFrameGeneration(jthread thread)
2613{
  jlong frameGeneration = -1;

  debugMonitorEnter(threadLock);
  {
      ThreadNode *node;

      node = findThread(NULL((void*)0), thread);

      if (node != NULL((void*)0)) {
          frameGeneration = node->frameGeneration;
      }
  }
  debugMonitorExit(threadLock);

  return frameGeneration;
2629}

2631/***** debugging *****/

2633#ifdef DEBUG1

2635void
2636threadControl_dumpAllThreads()
2637{
  tty_message("Dumping runningThreads:\n");
  dumpThreadList(&runningThreads);
  tty_message("Dumping otherThreads:\n");
  dumpThreadList(&otherThreads);
2642}

2644void
2645threadControl_dumpThread(jthread thread)
2646{
  ThreadNode* node = findThread(NULL((void*)0), thread);
  if (node == NULL((void*)0)) {
      tty_message("Thread not found");
  } else {
      dumpThread(node);
  }
2653}

2655static void
2656dumpThreadList(ThreadList *list)
2657{
  ThreadNode *node;
  for (node = list->first; node != NULL((void*)0); node = node->next) {
      if (!node->isDebugThread) {
          dumpThread(node);
      }
  }
2664}

2666static void
2667dumpThread(ThreadNode *node) {
  tty_message("  Thread: node = %p, jthread = %p", node, node->thread);
2669#ifdef DEBUG_THREADNAME
  tty_message("\tname: %s", node->name);
2671#endif
  // More fields can be printed here when needed. The amount of output is intentionlly
  // kept small so it doesn't generate too much output.
  tty_message("\tsuspendCount: %d", node->suspendCount);
2675}

2677#endif /* DEBUG */