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     debugMonitorEnter(invokerLock);
 337     request = threadControl_getInvokeRequest(thread);
 338     if (request == NULL) {
 339         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
 340     }
 341 
 342     request->available = JNI_TRUE;
 343     debugMonitorExit(invokerLock);
 344 }
 345 





























 346 jvmtiError
 347 invoker_requestInvoke(jbyte invokeType, jbyte options, jint id,
 348                       jthread thread, jclass clazz, jmethodID method,
 349                       jobject instance,
 350                       jvalue *arguments, jint argumentCount)
 351 {
 352     JNIEnv *env = getEnv();
 353     InvokeRequest *request;
 354     jvmtiError error = JVMTI_ERROR_NONE;







 355 
 356     debugMonitorEnter(invokerLock);
 357     request = threadControl_getInvokeRequest(thread);
 358     if (request != NULL) {
 359         error = fillInvokeRequest(env, request, invokeType, options, id,
 360                                   thread, clazz, method, instance,
 361                                   arguments, argumentCount);
 362     }
 363     debugMonitorExit(invokerLock);
 364 
 365     if (error == JVMTI_ERROR_NONE) {
 366         if (options & JDWP_INVOKE_OPTIONS(SINGLE_THREADED) ) {
 367             /* true means it is okay to unblock the commandLoop thread */
 368             (void)threadControl_resumeThread(thread, JNI_TRUE);
 369         } else {
 370             (void)threadControl_resumeAll();
 371         }
 372     }
 373 
 374     return error;
 375 }
 376 
 377 static void
 378 invokeConstructor(JNIEnv *env, InvokeRequest *request)
 379 {
 380     jobject object;
 381 
 382     JDI_ASSERT_MSG(request->clazz, "Request clazz null");
 383     object = JNI_FUNC_PTR(env,NewObjectA)(env, request->clazz,
 384                                      request->method,
 385                                      request->arguments);
 386     request->returnValue.l = NULL;
 387     if (object != NULL) {
 388         saveGlobalRef(env, object, &(request->returnValue.l));
 389     }
 390 }
 391 
 392 static void
 393 invokeStatic(JNIEnv *env, InvokeRequest *request)
 394 {
 395     switch(returnTypeTag(request->methodSignature)) {
 396         case JDWP_TAG(OBJECT):
 397         case JDWP_TAG(ARRAY): {
 398             jobject object;
 399             JDI_ASSERT_MSG(request->clazz, "Request clazz null");
 400             object = JNI_FUNC_PTR(env,CallStaticObjectMethodA)(env,
 401                                        request->clazz,
 402                                        request->method,
 403                                        request->arguments);
 404             request->returnValue.l = NULL;
 405             if (object != NULL) {
 406                 saveGlobalRef(env, object, &(request->returnValue.l));
 407             }
 408             break;
 409         }
 410 
 411 
 412         case JDWP_TAG(BYTE):
 413             request->returnValue.b = JNI_FUNC_PTR(env,CallStaticByteMethodA)(env,
 414                                                        request->clazz,
 415                                                        request->method,
 416                                                        request->arguments);
 417             break;
 418 
 419         case JDWP_TAG(CHAR):
 420             request->returnValue.c = JNI_FUNC_PTR(env,CallStaticCharMethodA)(env,
 421                                                        request->clazz,
 422                                                        request->method,
 423                                                        request->arguments);
 424             break;
 425 
 426         case JDWP_TAG(FLOAT):
 427             request->returnValue.f = JNI_FUNC_PTR(env,CallStaticFloatMethodA)(env,
 428                                                        request->clazz,
 429                                                        request->method,
 430                                                        request->arguments);
 431             break;
 432 
 433         case JDWP_TAG(DOUBLE):
 434             request->returnValue.d = JNI_FUNC_PTR(env,CallStaticDoubleMethodA)(env,
 435                                                        request->clazz,
 436                                                        request->method,
 437                                                        request->arguments);
 438             break;
 439 
 440         case JDWP_TAG(INT):
 441             request->returnValue.i = JNI_FUNC_PTR(env,CallStaticIntMethodA)(env,
 442                                                        request->clazz,
 443                                                        request->method,
 444                                                        request->arguments);
 445             break;
 446 
 447         case JDWP_TAG(LONG):
 448             request->returnValue.j = JNI_FUNC_PTR(env,CallStaticLongMethodA)(env,
 449                                                        request->clazz,
 450                                                        request->method,
 451                                                        request->arguments);
 452             break;
 453 
 454         case JDWP_TAG(SHORT):
 455             request->returnValue.s = JNI_FUNC_PTR(env,CallStaticShortMethodA)(env,
 456                                                        request->clazz,
 457                                                        request->method,
 458                                                        request->arguments);
 459             break;
 460 
 461         case JDWP_TAG(BOOLEAN):
 462             request->returnValue.z = JNI_FUNC_PTR(env,CallStaticBooleanMethodA)(env,
 463                                                        request->clazz,
 464                                                        request->method,
 465                                                        request->arguments);
 466             break;
 467 
 468         case JDWP_TAG(VOID):
 469             JNI_FUNC_PTR(env,CallStaticVoidMethodA)(env,
 470                                           request->clazz,
 471                                           request->method,
 472                                           request->arguments);
 473             break;
 474 
 475         default:
 476             EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
 477             break;
 478     }
 479 }
 480 
 481 static void
 482 invokeVirtual(JNIEnv *env, InvokeRequest *request)
 483 {
 484     switch(returnTypeTag(request->methodSignature)) {
 485         case JDWP_TAG(OBJECT):
 486         case JDWP_TAG(ARRAY): {
 487             jobject object;
 488             JDI_ASSERT_MSG(request->instance, "Request instance null");
 489             object = JNI_FUNC_PTR(env,CallObjectMethodA)(env,
 490                                  request->instance,
 491                                  request->method,
 492                                  request->arguments);
 493             request->returnValue.l = NULL;
 494             if (object != NULL) {
 495                 saveGlobalRef(env, object, &(request->returnValue.l));
 496             }
 497             break;
 498         }
 499 
 500         case JDWP_TAG(BYTE):
 501             request->returnValue.b = JNI_FUNC_PTR(env,CallByteMethodA)(env,
 502                                                  request->instance,
 503                                                  request->method,
 504                                                  request->arguments);
 505             break;
 506 
 507         case JDWP_TAG(CHAR):
 508             request->returnValue.c = JNI_FUNC_PTR(env,CallCharMethodA)(env,
 509                                                  request->instance,
 510                                                  request->method,
 511                                                  request->arguments);
 512             break;
 513 
 514         case JDWP_TAG(FLOAT):
 515             request->returnValue.f = JNI_FUNC_PTR(env,CallFloatMethodA)(env,
 516                                                  request->instance,
 517                                                  request->method,
 518                                                  request->arguments);
 519             break;
 520 
 521         case JDWP_TAG(DOUBLE):
 522             request->returnValue.d = JNI_FUNC_PTR(env,CallDoubleMethodA)(env,
 523                                                  request->instance,
 524                                                  request->method,
 525                                                  request->arguments);
 526             break;
 527 
 528         case JDWP_TAG(INT):
 529             request->returnValue.i = JNI_FUNC_PTR(env,CallIntMethodA)(env,
 530                                                  request->instance,
 531                                                  request->method,
 532                                                  request->arguments);
 533             break;
 534 
 535         case JDWP_TAG(LONG):
 536             request->returnValue.j = JNI_FUNC_PTR(env,CallLongMethodA)(env,
 537                                                  request->instance,
 538                                                  request->method,
 539                                                  request->arguments);
 540             break;
 541 
 542         case JDWP_TAG(SHORT):
 543             request->returnValue.s = JNI_FUNC_PTR(env,CallShortMethodA)(env,
 544                                                  request->instance,
 545                                                  request->method,
 546                                                  request->arguments);
 547             break;
 548 
 549         case JDWP_TAG(BOOLEAN):
 550             request->returnValue.z = JNI_FUNC_PTR(env,CallBooleanMethodA)(env,
 551                                                  request->instance,
 552                                                  request->method,
 553                                                  request->arguments);
 554             break;
 555 
 556         case JDWP_TAG(VOID):
 557             JNI_FUNC_PTR(env,CallVoidMethodA)(env,
 558                                     request->instance,
 559                                     request->method,
 560                                     request->arguments);
 561             break;
 562 
 563         default:
 564             EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
 565             break;
 566     }
 567 }
 568 
 569 static void
 570 invokeNonvirtual(JNIEnv *env, InvokeRequest *request)
 571 {
 572     switch(returnTypeTag(request->methodSignature)) {
 573         case JDWP_TAG(OBJECT):
 574         case JDWP_TAG(ARRAY): {
 575             jobject object;
 576             JDI_ASSERT_MSG(request->clazz, "Request clazz null");
 577             JDI_ASSERT_MSG(request->instance, "Request instance null");
 578             object = JNI_FUNC_PTR(env,CallNonvirtualObjectMethodA)(env,
 579                                            request->instance,
 580                                            request->clazz,
 581                                            request->method,
 582                                            request->arguments);
 583             request->returnValue.l = NULL;
 584             if (object != NULL) {
 585                 saveGlobalRef(env, object, &(request->returnValue.l));
 586             }
 587             break;
 588         }
 589 
 590         case JDWP_TAG(BYTE):
 591             request->returnValue.b = JNI_FUNC_PTR(env,CallNonvirtualByteMethodA)(env,
 592                                                  request->instance,
 593                                                  request->clazz,
 594                                                  request->method,
 595                                                  request->arguments);
 596             break;
 597 
 598         case JDWP_TAG(CHAR):
 599             request->returnValue.c = JNI_FUNC_PTR(env,CallNonvirtualCharMethodA)(env,
 600                                                  request->instance,
 601                                                  request->clazz,
 602                                                  request->method,
 603                                                  request->arguments);
 604             break;
 605 
 606         case JDWP_TAG(FLOAT):
 607             request->returnValue.f = JNI_FUNC_PTR(env,CallNonvirtualFloatMethodA)(env,
 608                                                  request->instance,
 609                                                  request->clazz,
 610                                                  request->method,
 611                                                  request->arguments);
 612             break;
 613 
 614         case JDWP_TAG(DOUBLE):
 615             request->returnValue.d = JNI_FUNC_PTR(env,CallNonvirtualDoubleMethodA)(env,
 616                                                  request->instance,
 617                                                  request->clazz,
 618                                                  request->method,
 619                                                  request->arguments);
 620             break;
 621 
 622         case JDWP_TAG(INT):
 623             request->returnValue.i = JNI_FUNC_PTR(env,CallNonvirtualIntMethodA)(env,
 624                                                  request->instance,
 625                                                  request->clazz,
 626                                                  request->method,
 627                                                  request->arguments);
 628             break;
 629 
 630         case JDWP_TAG(LONG):
 631             request->returnValue.j = JNI_FUNC_PTR(env,CallNonvirtualLongMethodA)(env,
 632                                                  request->instance,
 633                                                  request->clazz,
 634                                                  request->method,
 635                                                  request->arguments);
 636             break;
 637 
 638         case JDWP_TAG(SHORT):
 639             request->returnValue.s = JNI_FUNC_PTR(env,CallNonvirtualShortMethodA)(env,
 640                                                  request->instance,
 641                                                  request->clazz,
 642                                                  request->method,
 643                                                  request->arguments);
 644             break;
 645 
 646         case JDWP_TAG(BOOLEAN):
 647             request->returnValue.z = JNI_FUNC_PTR(env,CallNonvirtualBooleanMethodA)(env,
 648                                                  request->instance,
 649                                                  request->clazz,
 650                                                  request->method,
 651                                                  request->arguments);
 652             break;
 653 
 654         case JDWP_TAG(VOID):
 655             JNI_FUNC_PTR(env,CallNonvirtualVoidMethodA)(env,
 656                                     request->instance,
 657                                     request->clazz,
 658                                     request->method,
 659                                     request->arguments);
 660             break;
 661 
 662         default:
 663             EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"Invalid method signature");
 664             break;
 665     }
 666 }
 667 
 668 jboolean
 669 invoker_doInvoke(jthread thread)
 670 {
 671     JNIEnv *env;
 672     jboolean startNow;
 673     InvokeRequest *request;
 674     jbyte options;
 675     jbyte invokeType;
 676 
 677     JDI_ASSERT(thread);
 678 
 679     debugMonitorEnter(invokerLock);
 680 
 681     request = threadControl_getInvokeRequest(thread);
 682     if (request == NULL) {
 683         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
 684     }
 685 
 686     request->available = JNI_FALSE;
 687     startNow = request->pending && !request->started;
 688 
 689     if (startNow) {
 690         request->started = JNI_TRUE;
 691     }
 692     options = request->options;
 693     invokeType = request->invokeType;
 694 
 695     debugMonitorExit(invokerLock);
 696 
 697     if (!startNow) {
 698         return JNI_FALSE;
 699     }
 700 
 701     env = getEnv();
 702 
 703     WITH_LOCAL_REFS(env, 2) {  /* 1 for obj return values, 1 for exception */
 704 
 705         jobject exception;
 706 
 707         JNI_FUNC_PTR(env,ExceptionClear)(env);
 708 
 709         switch (invokeType) {
 710             case INVOKE_CONSTRUCTOR:
 711                 invokeConstructor(env, request);
 712                 break;
 713             case INVOKE_STATIC:
 714                 invokeStatic(env, request);
 715                 break;
 716             case INVOKE_INSTANCE:
 717                 if (options & JDWP_INVOKE_OPTIONS(NONVIRTUAL) ) {
 718                     invokeNonvirtual(env, request);
 719                 } else {
 720                     invokeVirtual(env, request);
 721                 }
 722                 break;
 723             default:
 724                 JDI_ASSERT(JNI_FALSE);
 725         }
 726         request->exception = NULL;
 727         exception = JNI_FUNC_PTR(env,ExceptionOccurred)(env);
 728         if (exception != NULL) {
 729             JNI_FUNC_PTR(env,ExceptionClear)(env);
 730             saveGlobalRef(env, exception, &(request->exception));
 731         }
 732 
 733     } END_WITH_LOCAL_REFS(env);
 734 
 735     return JNI_TRUE;
 736 }
 737 
 738 void
 739 invoker_completeInvokeRequest(jthread thread)
 740 {
 741     JNIEnv *env = getEnv();
 742     PacketOutputStream out;
 743     jbyte tag;
 744     jobject exc;
 745     jvalue returnValue;
 746     jint id;
 747     InvokeRequest *request;
 748     jboolean detached;
 749 
 750     JDI_ASSERT(thread);
 751 
 752     /* Prevent gcc errors on uninitialized variables. */
 753     tag = 0;
 754     exc = NULL;
 755     id  = 0;
 756 
 757     eventHandler_lock(); /* for proper lock order */
 758     debugMonitorEnter(invokerLock);
 759 
 760     request = threadControl_getInvokeRequest(thread);
 761     if (request == NULL) {
 762         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
 763     }
 764 
 765     JDI_ASSERT(request->pending);
 766     JDI_ASSERT(request->started);
 767 
 768     request->pending = JNI_FALSE;
 769     request->started = JNI_FALSE;
 770     request->available = JNI_TRUE; /* For next time around */
 771 
 772     detached = request->detached;
 773     if (!detached) {
 774         if (request->options & JDWP_INVOKE_OPTIONS(SINGLE_THREADED)) {
 775             (void)threadControl_suspendThread(thread, JNI_FALSE);
 776         } else {
 777             (void)threadControl_suspendAll();
 778         }
 779 
 780         if (request->invokeType == INVOKE_CONSTRUCTOR) {
 781             /*
 782              * Although constructors technically have a return type of
 783              * void, we return the object created.
 784              */
 785             tag = specificTypeKey(env, request->returnValue.l);
 786         } else {
 787             tag = returnTypeTag(request->methodSignature);
 788         }
 789         id = request->id;
 790         exc = request->exception;
 791         returnValue = request->returnValue;
 792     }
 793 
 794     /*
 795      * At this time, there's no need to retain global references on
 796      * arguments since the reply is processed. No one will deal with
 797      * this request ID anymore, so we must call deleteGlobalArgumentRefs().
 798      *
 799      * We cannot delete saved exception or return value references
 800      * since otherwise a deleted handle would escape when writing
 801      * the response to the stream. Instead, we clean those refs up
 802      * after writing the respone.
 803      */
 804     deleteGlobalArgumentRefs(env, request);
 805 
 806     /*
 807      * Give up the lock before I/O operation
 808      */
 809     debugMonitorExit(invokerLock);
 810     eventHandler_unlock();
 811 
 812     if (!detached) {
 813         outStream_initReply(&out, id);
 814         (void)outStream_writeValue(env, &out, tag, returnValue);
 815         (void)outStream_writeObjectTag(env, &out, exc);
 816         (void)outStream_writeObjectRef(env, &out, exc);
 817         outStream_sendReply(&out);
 818     }
 819 
 820     /*
 821      * Delete potentially saved global references of return value
 822      * and exception
 823      */
 824     eventHandler_lock(); // for proper lock order
 825     debugMonitorEnter(invokerLock);
 826     deletePotentiallySavedGlobalRefs(env, request);
 827     debugMonitorExit(invokerLock);
 828     eventHandler_unlock();
 829 }
 830 
 831 jboolean
 832 invoker_isEnabled(jthread thread)
 833 {
 834     InvokeRequest *request;
 835     jboolean isEnabled;
 836 
 837     JDI_ASSERT(thread);
 838     debugMonitorEnter(invokerLock);
 839     request = threadControl_getInvokeRequest(thread);
 840     if (request == NULL) {
 841         EXIT_ERROR(AGENT_ERROR_INVALID_THREAD, "getting thread invoke request");
 842     }
 843     isEnabled = request->available;
 844     debugMonitorExit(invokerLock);
 845     return isEnabled;
 846 }
 847 
 848 void
 849 invoker_detach(InvokeRequest *request)
 850 {
 851     JDI_ASSERT(request);
 852     debugMonitorEnter(invokerLock);
 853     request->detached = JNI_TRUE;
 854     debugMonitorExit(invokerLock);
 855 }
--- EOF ---