Home | History | Annotate | Download | only in jdwp 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /*
     18  * JDWP initialization.
     19  */
     20 #include "jdwp/JdwpPriv.h"
     21 #include "Dalvik.h"
     22 #include "Atomic.h"
     23 
     24 #include <stdlib.h>
     25 #include <unistd.h>
     26 #include <sys/time.h>
     27 #include <time.h>
     28 #include <errno.h>
     29 
     30 
     31 static void* jdwpThreadStart(void* arg);
     32 
     33 
     34 /*
     35  * Initialize JDWP.
     36  *
     37  * Does not return until JDWP thread is running, but may return before
     38  * the thread is accepting network connections.
     39  */
     40 JdwpState* dvmJdwpStartup(const JdwpStartupParams* pParams)
     41 {
     42     JdwpState* state = NULL;
     43 
     44     /* comment this out when debugging JDWP itself */
     45     android_setMinPriority(LOG_TAG, ANDROID_LOG_DEBUG);
     46 
     47     state = (JdwpState*) calloc(1, sizeof(JdwpState));
     48 
     49     state->params = *pParams;
     50 
     51     state->requestSerial = 0x10000000;
     52     state->eventSerial = 0x20000000;
     53     dvmDbgInitMutex(&state->threadStartLock);
     54     dvmDbgInitMutex(&state->attachLock);
     55     dvmDbgInitMutex(&state->serialLock);
     56     dvmDbgInitMutex(&state->eventLock);
     57     state->eventThreadId = 0;
     58     dvmDbgInitMutex(&state->eventThreadLock);
     59     dvmDbgInitCond(&state->threadStartCond);
     60     dvmDbgInitCond(&state->attachCond);
     61     dvmDbgInitCond(&state->eventThreadCond);
     62 
     63     switch (pParams->transport) {
     64     case kJdwpTransportSocket:
     65         // LOGD("prepping for JDWP over TCP\n");
     66         state->transport = dvmJdwpSocketTransport();
     67         break;
     68     case kJdwpTransportAndroidAdb:
     69         // LOGD("prepping for JDWP over ADB\n");
     70         state->transport = dvmJdwpAndroidAdbTransport();
     71         /* TODO */
     72         break;
     73     default:
     74         LOGE("Unknown transport %d\n", pParams->transport);
     75         assert(false);
     76         goto fail;
     77     }
     78 
     79     if (!dvmJdwpNetStartup(state, pParams))
     80         goto fail;
     81 
     82     /*
     83      * Grab a mutex or two before starting the thread.  This ensures they
     84      * won't signal the cond var before we're waiting.
     85      */
     86     dvmDbgLockMutex(&state->threadStartLock);
     87     if (pParams->suspend)
     88         dvmDbgLockMutex(&state->attachLock);
     89 
     90     /*
     91      * We have bound to a port, or are trying to connect outbound to a
     92      * debugger.  Create the JDWP thread and let it continue the mission.
     93      */
     94     if (!dvmCreateInternalThread(&state->debugThreadHandle, "JDWP",
     95             jdwpThreadStart, state))
     96     {
     97         /* state is getting tossed, but unlock these anyway for cleanliness */
     98         dvmDbgUnlockMutex(&state->threadStartLock);
     99         if (pParams->suspend)
    100             dvmDbgUnlockMutex(&state->attachLock);
    101         goto fail;
    102     }
    103 
    104     /*
    105      * Wait until the thread finishes basic initialization.
    106      * TODO: cond vars should be waited upon in a loop
    107      */
    108     dvmDbgCondWait(&state->threadStartCond, &state->threadStartLock);
    109     dvmDbgUnlockMutex(&state->threadStartLock);
    110 
    111 
    112     /*
    113      * For suspend=y, wait for the debugger to connect to us or for us to
    114      * connect to the debugger.
    115      *
    116      * The JDWP thread will signal us when it connects successfully or
    117      * times out (for timeout=xxx), so we have to check to see what happened
    118      * when we wake up.
    119      */
    120     if (pParams->suspend) {
    121         dvmChangeStatus(NULL, THREAD_VMWAIT);
    122         dvmDbgCondWait(&state->attachCond, &state->attachLock);
    123         dvmDbgUnlockMutex(&state->attachLock);
    124         dvmChangeStatus(NULL, THREAD_RUNNING);
    125 
    126         if (!dvmJdwpIsActive(state)) {
    127             LOGE("JDWP connection failed\n");
    128             goto fail;
    129         }
    130 
    131         LOGI("JDWP connected\n");
    132 
    133         /*
    134          * Ordinarily we would pause briefly to allow the debugger to set
    135          * breakpoints and so on, but for "suspend=y" the VM init code will
    136          * pause the VM when it sends the VM_START message.
    137          */
    138     }
    139 
    140     return state;
    141 
    142 fail:
    143     dvmJdwpShutdown(state);     // frees state
    144     return NULL;
    145 }
    146 
    147 /*
    148  * Reset all session-related state.  There should not be an active connection
    149  * to the client at this point.  The rest of the VM still thinks there is
    150  * a debugger attached.
    151  *
    152  * This includes freeing up the debugger event list.
    153  */
    154 void dvmJdwpResetState(JdwpState* state)
    155 {
    156     /* could reset the serial numbers, but no need to */
    157 
    158     dvmJdwpUnregisterAll(state);
    159     assert(state->eventList == NULL);
    160 
    161     /*
    162      * Should not have one of these in progress.  If the debugger went away
    163      * mid-request, though, we could see this.
    164      */
    165     if (state->eventThreadId != 0) {
    166         LOGW("WARNING: resetting state while event in progress\n");
    167         assert(false);
    168     }
    169 }
    170 
    171 /*
    172  * Tell the JDWP thread to shut down.  Frees "state".
    173  */
    174 void dvmJdwpShutdown(JdwpState* state)
    175 {
    176     void* threadReturn;
    177 
    178     if (state == NULL)
    179         return;
    180 
    181     if (dvmJdwpIsTransportDefined(state)) {
    182         if (dvmJdwpIsConnected(state))
    183             dvmJdwpPostVMDeath(state);
    184 
    185         /*
    186          * Close down the network to inspire the thread to halt.
    187          */
    188         if (gDvm.verboseShutdown)
    189             LOGD("JDWP shutting down net...\n");
    190         dvmJdwpNetShutdown(state);
    191 
    192         if (state->debugThreadStarted) {
    193             state->run = false;
    194             if (pthread_join(state->debugThreadHandle, &threadReturn) != 0) {
    195                 LOGW("JDWP thread join failed\n");
    196             }
    197         }
    198 
    199         if (gDvm.verboseShutdown)
    200             LOGD("JDWP freeing netstate...\n");
    201         dvmJdwpNetFree(state);
    202         state->netState = NULL;
    203     }
    204     assert(state->netState == NULL);
    205 
    206     dvmJdwpResetState(state);
    207     free(state);
    208 }
    209 
    210 /*
    211  * Are we talking to a debugger?
    212  */
    213 bool dvmJdwpIsActive(JdwpState* state)
    214 {
    215     return dvmJdwpIsConnected(state);
    216 }
    217 
    218 /*
    219  * Entry point for JDWP thread.  The thread was created through the VM
    220  * mechanisms, so there is a java/lang/Thread associated with us.
    221  */
    222 static void* jdwpThreadStart(void* arg)
    223 {
    224     JdwpState* state = (JdwpState*) arg;
    225 
    226     LOGV("JDWP: thread running\n");
    227 
    228     /*
    229      * Finish initializing "state", then notify the creating thread that
    230      * we're running.
    231      */
    232     state->debugThreadHandle = dvmThreadSelf()->handle;
    233     state->run = true;
    234     android_atomic_release_store(true, &state->debugThreadStarted);
    235 
    236     dvmDbgLockMutex(&state->threadStartLock);
    237     dvmDbgCondBroadcast(&state->threadStartCond);
    238     dvmDbgUnlockMutex(&state->threadStartLock);
    239 
    240     /* set the thread state to VMWAIT so GCs don't wait for us */
    241     dvmDbgThreadWaiting();
    242 
    243     /*
    244      * Loop forever if we're in server mode, processing connections.  In
    245      * non-server mode, we bail out of the thread when the debugger drops
    246      * us.
    247      *
    248      * We broadcast a notification when a debugger attaches, after we
    249      * successfully process the handshake.
    250      */
    251     while (state->run) {
    252         bool first;
    253 
    254         if (state->params.server) {
    255             /*
    256              * Block forever, waiting for a connection.  To support the
    257              * "timeout=xxx" option we'll need to tweak this.
    258              */
    259             if (!dvmJdwpAcceptConnection(state))
    260                 break;
    261         } else {
    262             /*
    263              * If we're not acting as a server, we need to connect out to the
    264              * debugger.  To support the "timeout=xxx" option we need to
    265              * have a timeout if the handshake reply isn't received in a
    266              * reasonable amount of time.
    267              */
    268             if (!dvmJdwpEstablishConnection(state)) {
    269                 /* wake anybody who was waiting for us to succeed */
    270                 dvmDbgLockMutex(&state->attachLock);
    271                 dvmDbgCondBroadcast(&state->attachCond);
    272                 dvmDbgUnlockMutex(&state->attachLock);
    273                 break;
    274             }
    275         }
    276 
    277         /* prep debug code to handle the new connection */
    278         dvmDbgConnected();
    279 
    280         /* process requests until the debugger drops */
    281         first = true;
    282         while (true) {
    283             // sanity check -- shouldn't happen?
    284             if (dvmThreadSelf()->status != THREAD_VMWAIT) {
    285                 LOGE("JDWP thread no longer in VMWAIT (now %d); resetting\n",
    286                     dvmThreadSelf()->status);
    287                 dvmDbgThreadWaiting();
    288             }
    289 
    290             if (!dvmJdwpProcessIncoming(state))     /* blocking read */
    291                 break;
    292 
    293             if (first && !dvmJdwpAwaitingHandshake(state)) {
    294                 /* handshake worked, tell the interpreter that we're active */
    295                 first = false;
    296 
    297                 /* set thread ID; requires object registry to be active */
    298                 state->debugThreadId = dvmDbgGetThreadSelfId();
    299 
    300                 /* wake anybody who's waiting for us */
    301                 dvmDbgLockMutex(&state->attachLock);
    302                 dvmDbgCondBroadcast(&state->attachCond);
    303                 dvmDbgUnlockMutex(&state->attachLock);
    304             }
    305         }
    306 
    307         dvmJdwpCloseConnection(state);
    308 
    309         if (state->ddmActive) {
    310             state->ddmActive = false;
    311 
    312             /* broadcast the disconnect; must be in RUNNING state */
    313             dvmDbgThreadRunning();
    314             dvmDbgDdmDisconnected();
    315             dvmDbgThreadWaiting();
    316         }
    317 
    318         /* release session state, e.g. remove breakpoint instructions */
    319         dvmJdwpResetState(state);
    320 
    321         /* tell the interpreter that the debugger is no longer around */
    322         dvmDbgDisconnected();
    323 
    324         /* if we had threads suspended, resume them now */
    325         dvmUndoDebuggerSuspensions();
    326 
    327         /* if we connected out, this was a one-shot deal */
    328         if (!state->params.server)
    329             state->run = false;
    330     }
    331 
    332     /* back to running, for thread shutdown */
    333     dvmDbgThreadRunning();
    334 
    335     LOGV("JDWP: thread exiting\n");
    336     return NULL;
    337 }
    338 
    339 
    340 /*
    341  * Return the thread handle, or (pthread_t)0 if the debugger isn't running.
    342  */
    343 pthread_t dvmJdwpGetDebugThread(JdwpState* state)
    344 {
    345     if (state == NULL)
    346         return 0;
    347 
    348     return state->debugThreadHandle;
    349 }
    350 
    351 
    352 /*
    353  * Support routines for waitForDebugger().
    354  *
    355  * We can't have a trivial "waitForDebugger" function that returns the
    356  * instant the debugger connects, because we run the risk of executing code
    357  * before the debugger has had a chance to configure breakpoints or issue
    358  * suspend calls.  It would be nice to just sit in the suspended state, but
    359  * most debuggers don't expect any threads to be suspended when they attach.
    360  *
    361  * There's no JDWP event we can post to tell the debugger, "we've stopped,
    362  * and we like it that way".  We could send a fake breakpoint, which should
    363  * cause the debugger to immediately send a resume, but the debugger might
    364  * send the resume immediately or might throw an exception of its own upon
    365  * receiving a breakpoint event that it didn't ask for.
    366  *
    367  * What we really want is a "wait until the debugger is done configuring
    368  * stuff" event.  We can approximate this with a "wait until the debugger
    369  * has been idle for a brief period".
    370  */
    371 
    372 /*
    373  * Get a notion of the current time, in milliseconds.
    374  */
    375 s8 dvmJdwpGetNowMsec(void)
    376 {
    377 #ifdef HAVE_POSIX_CLOCKS
    378     struct timespec now;
    379     clock_gettime(CLOCK_MONOTONIC, &now);
    380     return now.tv_sec * 1000LL + now.tv_nsec / 1000000LL;
    381 #else
    382     struct timeval now;
    383     gettimeofday(&now, NULL);
    384     return now.tv_sec * 1000LL + now.tv_usec / 1000LL;
    385 #endif
    386 }
    387 
    388 /*
    389  * Return the time, in milliseconds, since the last debugger activity.
    390  *
    391  * Returns -1 if no debugger is attached, or 0 if we're in the middle of
    392  * processing a debugger request.
    393  */
    394 s8 dvmJdwpLastDebuggerActivity(JdwpState* state)
    395 {
    396     if (!gDvm.debuggerActive) {
    397         LOGD("dvmJdwpLastDebuggerActivity: no active debugger\n");
    398         return -1;
    399     }
    400 
    401     s8 last = dvmQuasiAtomicRead64(&state->lastActivityWhen);
    402 
    403     /* initializing or in the middle of something? */
    404     if (last == 0) {
    405         LOGV("+++ last=busy\n");
    406         return 0;
    407     }
    408 
    409     /* now get the current time */
    410     s8 now = dvmJdwpGetNowMsec();
    411     assert(now > last);
    412 
    413     LOGV("+++ debugger interval=%lld\n", now - last);
    414     return now - last;
    415 }
    416