Home | History | Annotate | Download | only in back 
      1 /*
      2  * Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved.
      3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
      4  *
      5  * This code is free software; you can redistribute it and/or modify it
      6  * under the terms of the GNU General Public License version 2 only, as
      7  * published by the Free Software Foundation.  Oracle designates this
      8  * particular file as subject to the "Classpath" exception as provided
      9  * by Oracle in the LICENSE file that accompanied this code.
     10  *
     11  * This code is distributed in the hope that it will be useful, but WITHOUT
     12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
     14  * version 2 for more details (a copy is included in the LICENSE file that
     15  * accompanied this code).
     16  *
     17  * You should have received a copy of the GNU General Public License version
     18  * 2 along with this work; if not, write to the Free Software Foundation,
     19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
     20  *
     21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
     22  * or visit www.oracle.com if you need additional information or have any
     23  * questions.
     24  */
     25 
     26 #include "util.h"
     27 #include "invoker.h"
     28 #include "eventHandler.h"
     29 #include "threadControl.h"
     30 #include "outStream.h"
     31 
     32 static jrawMonitorID invokerLock;
     33 
     34 void
     35 invoker_initialize(void)
     36 {
     37     invokerLock = debugMonitorCreate("JDWP Invocation Lock");
     38 }
     39 
     40 void
     41 invoker_reset(void)
     42 {
     43 }
     44 
     45 void invoker_lock(void)
     46 {
     47     debugMonitorEnter(invokerLock);
     48 }
     49 
     50 void invoker_unlock(void)
     51 {
     52     debugMonitorExit(invokerLock);
     53 }
     54 
     55 static jbyte
     56 returnTypeTag(char *signature)
     57 {
     58     char *tagPtr = strchr(signature, SIGNATURE_END_ARGS);
     59     JDI_ASSERT(tagPtr);
     60     tagPtr++;    /* 1st character after the end of args */
     61     return (jbyte)*tagPtr;
     62 }
     63 
     64 static jbyte
     65 nextArgumentTypeTag(void **cursor)
     66 {
     67     char *tagPtr = *cursor;
     68     jbyte argumentTag = (jbyte)*tagPtr;
     69 
     70     if (*tagPtr != SIGNATURE_END_ARGS) {
     71         /* Skip any array modifiers */
     72         while (*tagPtr == JDWP_TAG(ARRAY)) {
     73             tagPtr++;
     74         }
     75         /* Skip class name */
     76         if (*tagPtr == JDWP_TAG(OBJECT)) {
     77             tagPtr = strchr(tagPtr, SIGNATURE_END_CLASS) + 1;
     78             JDI_ASSERT(tagPtr);
     79         } else {
     80             /* Skip primitive sig */
     81             tagPtr++;
     82         }
     83     }
     84 
     85     *cursor = tagPtr;
     86     return argumentTag;
     87 }
     88 
     89 static jbyte
     90 firstArgumentTypeTag(char *signature, void **cursor)
     91 {
     92     JDI_ASSERT(signature[0] == SIGNATURE_BEGIN_ARGS);
     93     *cursor = signature + 1; /* skip to the first arg */
     94     return nextArgumentTypeTag(cursor);
     95 }
     96 
     97 
     98 /*
     99  * Note: argument refs may be destroyed on out-of-memory error
    100  */
    101 static jvmtiError
    102 createGlobalRefs(JNIEnv *env, InvokeRequest *request)
    103 {
    104     jvmtiError error;
    105     jclass clazz = NULL;
    106     jobject instance = NULL;
    107     jint argIndex;
    108     jbyte argumentTag;
    109     jvalue *argument;
    110     void *cursor;
    111     jobject *argRefs = NULL;
    112 
    113     error = JVMTI_ERROR_NONE;
    114 
    115     if ( request->argumentCount > 0 ) {
    116         /*LINTED*/
    117         argRefs = jvmtiAllocate((jint)(request->argumentCount*sizeof(jobject)));
    118         if ( argRefs==NULL ) {
    119             error = AGENT_ERROR_OUT_OF_MEMORY;
    120         } else {
    121             /*LINTED*/
    122             (void)memset(argRefs, 0, request->argumentCount*sizeof(jobject));
    123         }
    124     }
    125 
    126     if ( error == JVMTI_ERROR_NONE ) {
    127         saveGlobalRef(env, request->clazz, &clazz);
    128         if (clazz == NULL) {
    129             error = AGENT_ERROR_OUT_OF_MEMORY;
    130         }
    131     }
    132 
    133     if ( error == JVMTI_ERROR_NONE && request->instance != NULL ) {
    134         saveGlobalRef(env, request->instance, &instance);
    135         if (instance == NULL) {
    136             error = AGENT_ERROR_OUT_OF_MEMORY;
    137         }
    138     }
    139 
    140     if ( error == JVMTI_ERROR_NONE && argRefs!=NULL ) {
    141         argIndex = 0;
    142         argumentTag = firstArgumentTypeTag(request->methodSignature, &cursor);
    143         argument = request->arguments;
    144         while (argumentTag != SIGNATURE_END_ARGS) {
    145             if ( argIndex > request->argumentCount ) {
    146                 break;
    147             }
    148             if ((argumentTag == JDWP_TAG(OBJECT)) ||
    149                 (argumentTag == JDWP_TAG(ARRAY))) {
    150                 /* Create a global ref for any non-null argument */
    151                 if (argument->l != NULL) {
    152                     saveGlobalRef(env, argument->l, &argRefs[argIndex]);
    153                     if (argRefs[argIndex] == NULL) {
    154                         error = AGENT_ERROR_OUT_OF_MEMORY;
    155                         break;
    156                     }
    157                 }
    158             }
    159             argument++;
    160             argIndex++;
    161             argumentTag = nextArgumentTypeTag(&cursor);
    162         }
    163     }
    164 
    165 #ifdef FIXUP /* Why isn't this an error? */
    166     /* Make sure the argument count matches */
    167     if ( error == JVMTI_ERROR_NONE && argIndex != request->argumentCount ) {
    168         error = AGENT_ERROR_INVALID_COUNT;
    169     }
    170 #endif
    171 
    172     /* Finally, put the global refs into the request if no errors */
    173     if ( error == JVMTI_ERROR_NONE ) {
    174         request->clazz = clazz;
    175         request->instance = instance;
    176         if ( argRefs!=NULL ) {
    177             argIndex = 0;
    178             argumentTag = firstArgumentTypeTag(request->methodSignature, &cursor);
    179             argument = request->arguments;
    180             while ( argIndex < request->argumentCount ) {
    181                 if ((argumentTag == JDWP_TAG(OBJECT)) ||
    182                     (argumentTag == JDWP_TAG(ARRAY))) {
    183                     argument->l = argRefs[argIndex];
    184                 }
    185                 argument++;
    186                 argIndex++;
    187                 argumentTag = nextArgumentTypeTag(&cursor);
    188             }
    189             jvmtiDeallocate(argRefs);
    190         }
    191         return JVMTI_ERROR_NONE;
    192 
    193     } else {
    194         /* Delete global references */
    195         if ( clazz != NULL ) {
    196             tossGlobalRef(env, &clazz);
    197         }
    198         if ( instance != NULL ) {
    199             tossGlobalRef(env, &instance);
    200         }
    201         if ( argRefs!=NULL ) {
    202             for ( argIndex=0; argIndex < request->argumentCount; argIndex++ ) {
    203                 if ( argRefs[argIndex] != NULL ) {
    204                     tossGlobalRef(env, &argRefs[argIndex]);
    205                 }
    206             }
    207             jvmtiDeallocate(argRefs);
    208         }
    209     }
    210 
    211     return error;
    212 }
    213 
    214 /*
    215  * Delete saved global references - if any - for:
    216  * - a potentially thrown Exception
    217  * - a returned refernce/array value
    218  * See invoker_doInvoke() and invoke* methods where global references
    219  * are being saved.
    220  */
    221 static void
    222 deletePotentiallySavedGlobalRefs(JNIEnv *env, InvokeRequest *request)
    223 {
    224     /* Delete potentially saved return value */
    225     if ((request->invokeType == INVOKE_CONSTRUCTOR) ||
    226         (returnTypeTag(request->methodSignature) == JDWP_TAG(OBJECT)) ||
    227         (returnTypeTag(request->methodSignature) == JDWP_TAG(ARRAY))) {
    228         if (request->returnValue.l != NULL) {
    229             tossGlobalRef(env, &(request->returnValue.l));
    230         }
    231     }
    232     /* Delete potentially saved exception */
    233     if (request->exception != NULL) {
    234         tossGlobalRef(env, &(request->exception));
    235     }
    236 }
    237 
    238 /*
    239  * Delete global argument references from the request which got put there before a
    240  * invoke request was carried out. See fillInvokeRequest().
    241  */
    242 static void
    243 deleteGlobalArgumentRefs(JNIEnv *env, InvokeRequest *request)
    244 {
    245     void *cursor;
    246     jint argIndex = 0;
    247     jvalue *argument = request->arguments;
    248     jbyte argumentTag = firstArgumentTypeTag(request->methodSignature, &cursor);
    249 
    250     if (request->clazz != NULL) {
    251         tossGlobalRef(env, &(request->clazz));
    252     }
    253     if (request->instance != NULL) {
    254         tossGlobalRef(env, &(request->instance));
    255     }
    256     /* Delete global argument references */
    257     while (argIndex < request->argumentCount) {
    258         if ((argumentTag == JDWP_TAG(OBJECT)) ||
    259             (argumentTag == JDWP_TAG(ARRAY))) {
    260             if (argument->l != NULL) {
    261                 tossGlobalRef(env, &(argument->l));
    262             }
    263         }
    264         argument++;
    265         argIndex++;
    266         argumentTag = nextArgumentTypeTag(&cursor);
    267     }
    268 }
    269 
    270 static jvmtiError
    271 fillInvokeRequest(JNIEnv *env, InvokeRequest *request,
    272                   jbyte invokeType, jbyte options, jint id,
    273                   jthread thread, jclass clazz, jmethodID method,
    274                   jobject instance,
    275                   jvalue *arguments, jint argumentCount)
    276 {
    277     jvmtiError error;
    278     if (!request->available) {
    279         /*
    280          * Thread is not at a point where it can invoke.
    281          */
    282         return AGENT_ERROR_INVALID_THREAD;
    283     }
    284     if (request->pending) {
    285         /*
    286          * Pending invoke
    287          */
    288         return AGENT_ERROR_ALREADY_INVOKING;
    289     }
    290 
    291     request->invokeType = invokeType;
    292     request->options = options;
    293     request->detached = JNI_FALSE;
    294     request->id = id;
    295     request->clazz = clazz;
    296     request->method = method;
    297     request->instance = instance;
    298     request->arguments = arguments;
    299     request->arguments = arguments;
    300     request->argumentCount = argumentCount;
    301 
    302     request->returnValue.j = 0;
    303     request->exception = 0;
    304 
    305     /*
    306      * Squirrel away the method signature
    307      */
    308     error = methodSignature(method, NULL, &request->methodSignature,  NULL);
    309     if (error != JVMTI_ERROR_NONE) {
    310         return error;
    311     }
    312 
    313     /*
    314      * The given references for class and instance are not guaranteed
    315      * to be around long enough for invocation, so create new ones
    316      * here.
    317      */
    318     error = createGlobalRefs(env, request);
    319     if (error != JVMTI_ERROR_NONE) {
    320         jvmtiDeallocate(request->methodSignature);
    321         return error;
    322     }
    323 
    324     request->pending = JNI_TRUE;
    325     request->available = JNI_FALSE;
    326     return JVMTI_ERROR_NONE;
    327 }
    328 
    329 void
    330 invoker_enableInvokeRequests(jthread thread)
    331 {
    332     InvokeRequest *request;
    333 
    334     JDI_ASSERT(thread);
    335 
    336     request = threadControl_getInvokeRequest(thread);
    337     if (request == NULL) {
    338         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    339     }
    340 
    341     request->available = JNI_TRUE;
    342 }
    343 
    344 jvmtiError
    345 invoker_requestInvoke(jbyte invokeType, jbyte options, jint id,
    346                       jthread thread, jclass clazz, jmethodID method,
    347                       jobject instance,
    348                       jvalue *arguments, jint argumentCount)
    349 {
    350     JNIEnv *env = getEnv();
    351     InvokeRequest *request;
    352     jvmtiError error = JVMTI_ERROR_NONE;
    353 
    354     debugMonitorEnter(invokerLock);
    355     request = threadControl_getInvokeRequest(thread);
    356     if (request != NULL) {
    357         error = fillInvokeRequest(env, request, invokeType, options, id,
    358                                   thread, clazz, method, instance,
    359                                   arguments, argumentCount);
    360     }
    361     debugMonitorExit(invokerLock);
    362 
    363     if (error == JVMTI_ERROR_NONE) {
    364         if (options & JDWP_INVOKE_OPTIONS(SINGLE_THREADED) ) {
    365             /* true means it is okay to unblock the commandLoop thread */
    366             (void)threadControl_resumeThread(thread, JNI_TRUE);
    367         } else {
    368             (void)threadControl_resumeAll();
    369         }
    370     }
    371 
    372     return error;
    373 }
    374 
    375 static void
    376 invokeConstructor(JNIEnv *env, InvokeRequest *request)
    377 {
    378     jobject object;
    379 
    380     JDI_ASSERT_MSG(request->clazz, "Request clazz null");
    381     object = JNI_FUNC_PTR(env,NewObjectA)(env, request->clazz,
    382                                      request->method,
    383                                      request->arguments);
    384     request->returnValue.l = NULL;
    385     if (object != NULL) {
    386         saveGlobalRef(env, object, &(request->returnValue.l));
    387     }
    388 }
    389 
    390 static void
    391 invokeStatic(JNIEnv *env, InvokeRequest *request)
    392 {
    393     switch(returnTypeTag(request->methodSignature)) {
    394         case JDWP_TAG(OBJECT):
    395         case JDWP_TAG(ARRAY): {
    396             jobject object;
    397             JDI_ASSERT_MSG(request->clazz, "Request clazz null");
    398             object = JNI_FUNC_PTR(env,CallStaticObjectMethodA)(env,
    399                                        request->clazz,
    400                                        request->method,
    401                                        request->arguments);
    402             request->returnValue.l = NULL;
    403             if (object != NULL) {
    404                 saveGlobalRef(env, object, &(request->returnValue.l));
    405             }
    406             break;
    407         }
    408 
    409 
    410         case JDWP_TAG(BYTE):
    411             request->returnValue.b = JNI_FUNC_PTR(env,CallStaticByteMethodA)(env,
    412                                                        request->clazz,
    413                                                        request->method,
    414                                                        request->arguments);
    415             break;
    416 
    417         case JDWP_TAG(CHAR):
    418             request->returnValue.c = JNI_FUNC_PTR(env,CallStaticCharMethodA)(env,
    419                                                        request->clazz,
    420                                                        request->method,
    421                                                        request->arguments);
    422             break;
    423 
    424         case JDWP_TAG(FLOAT):
    425             request->returnValue.f = JNI_FUNC_PTR(env,CallStaticFloatMethodA)(env,
    426                                                        request->clazz,
    427                                                        request->method,
    428                                                        request->arguments);
    429             break;
    430 
    431         case JDWP_TAG(DOUBLE):
    432             request->returnValue.d = JNI_FUNC_PTR(env,CallStaticDoubleMethodA)(env,
    433                                                        request->clazz,
    434                                                        request->method,
    435                                                        request->arguments);
    436             break;
    437 
    438         case JDWP_TAG(INT):
    439             request->returnValue.i = JNI_FUNC_PTR(env,CallStaticIntMethodA)(env,
    440                                                        request->clazz,
    441                                                        request->method,
    442                                                        request->arguments);
    443             break;
    444 
    445         case JDWP_TAG(LONG):
    446             request->returnValue.j = JNI_FUNC_PTR(env,CallStaticLongMethodA)(env,
    447                                                        request->clazz,
    448                                                        request->method,
    449                                                        request->arguments);
    450             break;
    451 
    452         case JDWP_TAG(SHORT):
    453             request->returnValue.s = JNI_FUNC_PTR(env,CallStaticShortMethodA)(env,
    454                                                        request->clazz,
    455                                                        request->method,
    456                                                        request->arguments);
    457             break;
    458 
    459         case JDWP_TAG(BOOLEAN):
    460             request->returnValue.z = JNI_FUNC_PTR(env,CallStaticBooleanMethodA)(env,
    461                                                        request->clazz,
    462                                                        request->method,
    463                                                        request->arguments);
    464             break;
    465 
    466         case JDWP_TAG(VOID):
    467             JNI_FUNC_PTR(env,CallStaticVoidMethodA)(env,
    468                                           request->clazz,
    469                                           request->method,
    470                                           request->arguments);
    471             break;
    472 
    473         default:
    474             EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
    475             break;
    476     }
    477 }
    478 
    479 static void
    480 invokeVirtual(JNIEnv *env, InvokeRequest *request)
    481 {
    482     switch(returnTypeTag(request->methodSignature)) {
    483         case JDWP_TAG(OBJECT):
    484         case JDWP_TAG(ARRAY): {
    485             jobject object;
    486             JDI_ASSERT_MSG(request->instance, "Request instance null");
    487             object = JNI_FUNC_PTR(env,CallObjectMethodA)(env,
    488                                  request->instance,
    489                                  request->method,
    490                                  request->arguments);
    491             request->returnValue.l = NULL;
    492             if (object != NULL) {
    493                 saveGlobalRef(env, object, &(request->returnValue.l));
    494             }
    495             break;
    496         }
    497 
    498         case JDWP_TAG(BYTE):
    499             request->returnValue.b = JNI_FUNC_PTR(env,CallByteMethodA)(env,
    500                                                  request->instance,
    501                                                  request->method,
    502                                                  request->arguments);
    503             break;
    504 
    505         case JDWP_TAG(CHAR):
    506             request->returnValue.c = JNI_FUNC_PTR(env,CallCharMethodA)(env,
    507                                                  request->instance,
    508                                                  request->method,
    509                                                  request->arguments);
    510             break;
    511 
    512         case JDWP_TAG(FLOAT):
    513             request->returnValue.f = JNI_FUNC_PTR(env,CallFloatMethodA)(env,
    514                                                  request->instance,
    515                                                  request->method,
    516                                                  request->arguments);
    517             break;
    518 
    519         case JDWP_TAG(DOUBLE):
    520             request->returnValue.d = JNI_FUNC_PTR(env,CallDoubleMethodA)(env,
    521                                                  request->instance,
    522                                                  request->method,
    523                                                  request->arguments);
    524             break;
    525 
    526         case JDWP_TAG(INT):
    527             request->returnValue.i = JNI_FUNC_PTR(env,CallIntMethodA)(env,
    528                                                  request->instance,
    529                                                  request->method,
    530                                                  request->arguments);
    531             break;
    532 
    533         case JDWP_TAG(LONG):
    534             request->returnValue.j = JNI_FUNC_PTR(env,CallLongMethodA)(env,
    535                                                  request->instance,
    536                                                  request->method,
    537                                                  request->arguments);
    538             break;
    539 
    540         case JDWP_TAG(SHORT):
    541             request->returnValue.s = JNI_FUNC_PTR(env,CallShortMethodA)(env,
    542                                                  request->instance,
    543                                                  request->method,
    544                                                  request->arguments);
    545             break;
    546 
    547         case JDWP_TAG(BOOLEAN):
    548             request->returnValue.z = JNI_FUNC_PTR(env,CallBooleanMethodA)(env,
    549                                                  request->instance,
    550                                                  request->method,
    551                                                  request->arguments);
    552             break;
    553 
    554         case JDWP_TAG(VOID):
    555             JNI_FUNC_PTR(env,CallVoidMethodA)(env,
    556                                     request->instance,
    557                                     request->method,
    558                                     request->arguments);
    559             break;
    560 
    561         default:
    562             EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
    563             break;
    564     }
    565 }
    566 
    567 static void
    568 invokeNonvirtual(JNIEnv *env, InvokeRequest *request)
    569 {
    570     switch(returnTypeTag(request->methodSignature)) {
    571         case JDWP_TAG(OBJECT):
    572         case JDWP_TAG(ARRAY): {
    573             jobject object;
    574             JDI_ASSERT_MSG(request->clazz, "Request clazz null");
    575             JDI_ASSERT_MSG(request->instance, "Request instance null");
    576             object = JNI_FUNC_PTR(env,CallNonvirtualObjectMethodA)(env,
    577                                            request->instance,
    578                                            request->clazz,
    579                                            request->method,
    580                                            request->arguments);
    581             request->returnValue.l = NULL;
    582             if (object != NULL) {
    583                 saveGlobalRef(env, object, &(request->returnValue.l));
    584             }
    585             break;
    586         }
    587 
    588         case JDWP_TAG(BYTE):
    589             request->returnValue.b = JNI_FUNC_PTR(env,CallNonvirtualByteMethodA)(env,
    590                                                  request->instance,
    591                                                  request->clazz,
    592                                                  request->method,
    593                                                  request->arguments);
    594             break;
    595 
    596         case JDWP_TAG(CHAR):
    597             request->returnValue.c = JNI_FUNC_PTR(env,CallNonvirtualCharMethodA)(env,
    598                                                  request->instance,
    599                                                  request->clazz,
    600                                                  request->method,
    601                                                  request->arguments);
    602             break;
    603 
    604         case JDWP_TAG(FLOAT):
    605             request->returnValue.f = JNI_FUNC_PTR(env,CallNonvirtualFloatMethodA)(env,
    606                                                  request->instance,
    607                                                  request->clazz,
    608                                                  request->method,
    609                                                  request->arguments);
    610             break;
    611 
    612         case JDWP_TAG(DOUBLE):
    613             request->returnValue.d = JNI_FUNC_PTR(env,CallNonvirtualDoubleMethodA)(env,
    614                                                  request->instance,
    615                                                  request->clazz,
    616                                                  request->method,
    617                                                  request->arguments);
    618             break;
    619 
    620         case JDWP_TAG(INT):
    621             request->returnValue.i = JNI_FUNC_PTR(env,CallNonvirtualIntMethodA)(env,
    622                                                  request->instance,
    623                                                  request->clazz,
    624                                                  request->method,
    625                                                  request->arguments);
    626             break;
    627 
    628         case JDWP_TAG(LONG):
    629             request->returnValue.j = JNI_FUNC_PTR(env,CallNonvirtualLongMethodA)(env,
    630                                                  request->instance,
    631                                                  request->clazz,
    632                                                  request->method,
    633                                                  request->arguments);
    634             break;
    635 
    636         case JDWP_TAG(SHORT):
    637             request->returnValue.s = JNI_FUNC_PTR(env,CallNonvirtualShortMethodA)(env,
    638                                                  request->instance,
    639                                                  request->clazz,
    640                                                  request->method,
    641                                                  request->arguments);
    642             break;
    643 
    644         case JDWP_TAG(BOOLEAN):
    645             request->returnValue.z = JNI_FUNC_PTR(env,CallNonvirtualBooleanMethodA)(env,
    646                                                  request->instance,
    647                                                  request->clazz,
    648                                                  request->method,
    649                                                  request->arguments);
    650             break;
    651 
    652         case JDWP_TAG(VOID):
    653             JNI_FUNC_PTR(env,CallNonvirtualVoidMethodA)(env,
    654                                     request->instance,
    655                                     request->clazz,
    656                                     request->method,
    657                                     request->arguments);
    658             break;
    659 
    660         default:
    661             EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
    662             break;
    663     }
    664 }
    665 
    666 jboolean
    667 invoker_doInvoke(jthread thread)
    668 {
    669     JNIEnv *env;
    670     jboolean startNow;
    671     InvokeRequest *request;
    672     jbyte options;
    673     jbyte invokeType;
    674 
    675     JDI_ASSERT(thread);
    676 
    677     debugMonitorEnter(invokerLock);
    678 
    679     request = threadControl_getInvokeRequest(thread);
    680     if (request == NULL) {
    681         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    682     }
    683 
    684     request->available = JNI_FALSE;
    685     startNow = request->pending && !request->started;
    686 
    687     if (startNow) {
    688         request->started = JNI_TRUE;
    689     }
    690     options = request->options;
    691     invokeType = request->invokeType;
    692 
    693     debugMonitorExit(invokerLock);
    694 
    695     if (!startNow) {
    696         return JNI_FALSE;
    697     }
    698 
    699     env = getEnv();
    700 
    701     WITH_LOCAL_REFS(env, 2) {  /* 1 for obj return values, 1 for exception */
    702 
    703         jobject exception;
    704 
    705         JNI_FUNC_PTR(env,ExceptionClear)(env);
    706 
    707         switch (invokeType) {
    708             case INVOKE_CONSTRUCTOR:
    709                 invokeConstructor(env, request);
    710                 break;
    711             case INVOKE_STATIC:
    712                 invokeStatic(env, request);
    713                 break;
    714             case INVOKE_INSTANCE:
    715                 if (options & JDWP_INVOKE_OPTIONS(NONVIRTUAL) ) {
    716                     invokeNonvirtual(env, request);
    717                 } else {
    718                     invokeVirtual(env, request);
    719                 }
    720                 break;
    721             default:
    722                 JDI_ASSERT(JNI_FALSE);
    723         }
    724         request->exception = NULL;
    725         exception = JNI_FUNC_PTR(env,ExceptionOccurred)(env);
    726         if (exception != NULL) {
    727             JNI_FUNC_PTR(env,ExceptionClear)(env);
    728             saveGlobalRef(env, exception, &(request->exception));
    729         }
    730 
    731     } END_WITH_LOCAL_REFS(env);
    732 
    733     return JNI_TRUE;
    734 }
    735 
    736 void
    737 invoker_completeInvokeRequest(jthread thread)
    738 {
    739     JNIEnv *env = getEnv();
    740     PacketOutputStream out;
    741     jbyte tag;
    742     jobject exc;
    743     jvalue returnValue;
    744     jint id;
    745     InvokeRequest *request;
    746     jboolean detached;
    747 
    748     JDI_ASSERT(thread);
    749 
    750     /* Prevent gcc errors on uninitialized variables. */
    751     tag = 0;
    752     exc = NULL;
    753     id  = 0;
    754 
    755     eventHandler_lock(); /* for proper lock order */
    756     debugMonitorEnter(invokerLock);
    757 
    758     request = threadControl_getInvokeRequest(thread);
    759     if (request == NULL) {
    760         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    761     }
    762 
    763     JDI_ASSERT(request->pending);
    764     JDI_ASSERT(request->started);
    765 
    766     request->pending = JNI_FALSE;
    767     request->started = JNI_FALSE;
    768     request->available = JNI_TRUE; /* For next time around */
    769 
    770     detached = request->detached;
    771     if (!detached) {
    772         if (request->options & JDWP_INVOKE_OPTIONS(SINGLE_THREADED)) {
    773             (void)threadControl_suspendThread(thread, JNI_FALSE);
    774         } else {
    775             (void)threadControl_suspendAll();
    776         }
    777 
    778         if (request->invokeType == INVOKE_CONSTRUCTOR) {
    779             /*
    780              * Although constructors technically have a return type of
    781              * void, we return the object created.
    782              */
    783             tag = specificTypeKey(env, request->returnValue.l);
    784         } else {
    785             tag = returnTypeTag(request->methodSignature);
    786         }
    787         id = request->id;
    788         exc = request->exception;
    789         returnValue = request->returnValue;
    790     }
    791 
    792     /*
    793      * At this time, there's no need to retain global references on
    794      * arguments since the reply is processed. No one will deal with
    795      * this request ID anymore, so we must call deleteGlobalArgumentRefs().
    796      *
    797      * We cannot delete saved exception or return value references
    798      * since otherwise a deleted handle would escape when writing
    799      * the response to the stream. Instead, we clean those refs up
    800      * after writing the respone.
    801      */
    802     deleteGlobalArgumentRefs(env, request);
    803 
    804     /*
    805      * Give up the lock before I/O operation
    806      */
    807     debugMonitorExit(invokerLock);
    808     eventHandler_unlock();
    809 
    810     if (!detached) {
    811         outStream_initReply(&out, id);
    812         (void)outStream_writeValue(env, &out, tag, returnValue);
    813         (void)outStream_writeObjectTag(env, &out, exc);
    814         (void)outStream_writeObjectRef(env, &out, exc);
    815         outStream_sendReply(&out);
    816     }
    817 
    818     /*
    819      * Delete potentially saved global references of return value
    820      * and exception
    821      */
    822     eventHandler_lock(); // for proper lock order
    823     debugMonitorEnter(invokerLock);
    824     deletePotentiallySavedGlobalRefs(env, request);
    825     debugMonitorExit(invokerLock);
    826     eventHandler_unlock();
    827 }
    828 
    829 jboolean
    830 invoker_isPending(jthread thread)
    831 {
    832     InvokeRequest *request;
    833 
    834     JDI_ASSERT(thread);
    835     request = threadControl_getInvokeRequest(thread);
    836     if (request == NULL) {
    837         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    838     }
    839     return request->pending;
    840 }
    841 
    842 jboolean
    843 invoker_isEnabled(jthread thread)
    844 {
    845     InvokeRequest *request;
    846 
    847     JDI_ASSERT(thread);
    848     request = threadControl_getInvokeRequest(thread);
    849     if (request == NULL) {
    850         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
    851     }
    852     return request->available;
    853 }
    854 
    855 void
    856 invoker_detach(InvokeRequest *request)
    857 {
    858     JDI_ASSERT(request);
    859     debugMonitorEnter(invokerLock);
    860     request->detached = JNI_TRUE;
    861     debugMonitorExit(invokerLock);
    862 }
    863