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 * JDWP internal interfaces. 18 */ 19 #ifndef _DALVIK_JDWP_JDWPPRIV 20 #define _DALVIK_JDWP_JDWPPRIV 21 22 #define LOG_TAG "jdwp" 23 24 #include "jdwp/Jdwp.h" 25 #include "jdwp/JdwpEvent.h" 26 #include "Debugger.h" 27 28 #include <pthread.h> 29 #include <sys/uio.h> 30 31 /* 32 * JDWP constants. 33 */ 34 #define kJDWPHeaderLen 11 35 #define kJDWPFlagReply 0x80 36 37 /* DDM support */ 38 #define kJDWPDdmCmdSet 199 /* 0xc7, or 'G'+128 */ 39 #define kJDWPDdmCmd 1 40 41 42 /* 43 * Transport-specific network status. 44 */ 45 struct JdwpNetState; 46 typedef struct JdwpNetState JdwpNetState; 47 48 struct JdwpState; 49 50 /* 51 * Transport functions. 52 */ 53 typedef struct JdwpTransport { 54 bool (*startup)(struct JdwpState* state, const JdwpStartupParams* pParams); 55 bool (*accept)(struct JdwpState* state); 56 bool (*establish)(struct JdwpState* state); 57 void (*close)(struct JdwpState* state); 58 void (*shutdown)(struct JdwpState* state); 59 void (*free)(struct JdwpState* state); 60 bool (*isConnected)(struct JdwpState* state); 61 bool (*awaitingHandshake)(struct JdwpState* state); 62 bool (*processIncoming)(struct JdwpState* state); 63 bool (*sendRequest)(struct JdwpState* state, ExpandBuf* pReq); 64 bool (*sendBufferedRequest)(struct JdwpState* state, 65 const struct iovec* iov, int iovcnt); 66 } JdwpTransport; 67 68 const JdwpTransport* dvmJdwpSocketTransport(); 69 const JdwpTransport* dvmJdwpAndroidAdbTransport(); 70 71 72 /* 73 * State for JDWP functions. 74 */ 75 struct JdwpState { 76 JdwpStartupParams params; 77 78 /* wait for creation of the JDWP thread */ 79 pthread_mutex_t threadStartLock; 80 pthread_cond_t threadStartCond; 81 82 int debugThreadStarted; 83 pthread_t debugThreadHandle; 84 ObjectId debugThreadId; 85 bool run; 86 87 const JdwpTransport* transport; 88 JdwpNetState* netState; 89 90 /* for wait-for-debugger */ 91 pthread_mutex_t attachLock; 92 pthread_cond_t attachCond; 93 94 /* time of last debugger activity, in milliseconds */ 95 s8 lastActivityWhen; 96 97 /* global counters and a mutex to protect them */ 98 u4 requestSerial; 99 u4 eventSerial; 100 pthread_mutex_t serialLock; 101 102 /* 103 * Events requested by the debugger (breakpoints, class prep, etc). 104 */ 105 int numEvents; /* #of elements in eventList */ 106 JdwpEvent* eventList; /* linked list of events */ 107 pthread_mutex_t eventLock; /* guards numEvents/eventList */ 108 109 /* 110 * Synchronize suspension of event thread (to avoid receiving "resume" 111 * events before the thread has finished suspending itself). 112 */ 113 pthread_mutex_t eventThreadLock; 114 pthread_cond_t eventThreadCond; 115 ObjectId eventThreadId; 116 117 /* 118 * DDM support. 119 */ 120 bool ddmActive; 121 }; 122 123 124 /* reset all session-specific data */ 125 void dvmJdwpResetState(JdwpState* state); 126 127 /* atomic ops to get next serial number */ 128 u4 dvmJdwpNextRequestSerial(JdwpState* state); 129 u4 dvmJdwpNextEventSerial(JdwpState* state); 130 131 /* get current time, in msec */ 132 s8 dvmJdwpGetNowMsec(void); 133 134 135 /* 136 * Transport functions. 137 */ 138 INLINE bool dvmJdwpNetStartup(JdwpState* state, 139 const JdwpStartupParams* pParams) 140 { 141 return (*state->transport->startup)(state, pParams); 142 } 143 INLINE bool dvmJdwpAcceptConnection(JdwpState* state) { 144 return (*state->transport->accept)(state); 145 } 146 INLINE bool dvmJdwpEstablishConnection(JdwpState* state) { 147 return (*state->transport->establish)(state); 148 } 149 INLINE void dvmJdwpCloseConnection(JdwpState* state) { 150 (*state->transport->close)(state); 151 } 152 INLINE void dvmJdwpNetShutdown(JdwpState* state) { 153 (*state->transport->shutdown)(state); 154 } 155 INLINE void dvmJdwpNetFree(JdwpState* state) { 156 (*state->transport->free)(state); 157 } 158 INLINE bool dvmJdwpIsTransportDefined(JdwpState* state) { 159 return state != NULL && state->transport != NULL; 160 } 161 INLINE bool dvmJdwpIsConnected(JdwpState* state) { 162 return state != NULL && (*state->transport->isConnected)(state); 163 } 164 INLINE bool dvmJdwpAwaitingHandshake(JdwpState* state) { 165 return (*state->transport->awaitingHandshake)(state); 166 } 167 INLINE bool dvmJdwpProcessIncoming(JdwpState* state) { 168 return (*state->transport->processIncoming)(state); 169 } 170 INLINE bool dvmJdwpSendRequest(JdwpState* state, ExpandBuf* pReq) { 171 return (*state->transport->sendRequest)(state, pReq); 172 } 173 INLINE bool dvmJdwpSendBufferedRequest(JdwpState* state, 174 const struct iovec* iov, int iovcnt) 175 { 176 return (*state->transport->sendBufferedRequest)(state, iov, iovcnt); 177 } 178 179 #endif /*_DALVIK_JDWP_JDWPPRIV*/ 180