1 //===-- GDBRemoteClientBase.cpp -------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "GDBRemoteClientBase.h" 10 11 #include "llvm/ADT/StringExtras.h" 12 13 #include "lldb/Target/UnixSignals.h" 14 #include "lldb/Utility/LLDBAssert.h" 15 16 #include "ProcessGDBRemoteLog.h" 17 18 using namespace lldb; 19 using namespace lldb_private; 20 using namespace lldb_private::process_gdb_remote; 21 using namespace std::chrono; 22 23 // When we've sent a continue packet and are waiting for the target to stop, 24 // we wake up the wait with this interval to make sure the stub hasn't gone 25 // away while we were waiting. 26 static const seconds kWakeupInterval(5); 27 28 ///////////////////////// 29 // GDBRemoteClientBase // 30 ///////////////////////// 31 32 GDBRemoteClientBase::ContinueDelegate::~ContinueDelegate() = default; 33 34 GDBRemoteClientBase::GDBRemoteClientBase(const char *comm_name, 35 const char *listener_name) 36 : GDBRemoteCommunication(comm_name, listener_name), m_async_count(0), 37 m_is_running(false), m_should_stop(false) {} 38 39 StateType GDBRemoteClientBase::SendContinuePacketAndWaitForResponse( 40 ContinueDelegate &delegate, const UnixSignals &signals, 41 llvm::StringRef payload, std::chrono::seconds interrupt_timeout, 42 StringExtractorGDBRemote &response) { 43 Log *log = GetLog(GDBRLog::Process); 44 response.Clear(); 45 46 { 47 std::lock_guard<std::mutex> lock(m_mutex); 48 m_continue_packet = std::string(payload); 49 m_should_stop = false; 50 } 51 ContinueLock cont_lock(*this); 52 if (!cont_lock) 53 return eStateInvalid; 54 OnRunPacketSent(true); 55 // The main ReadPacket loop wakes up at computed_timeout intervals, just to 56 // check that the connection hasn't dropped. When we wake up we also check 57 // whether there is an interrupt request that has reached its endpoint. 58 // If we want a shorter interrupt timeout that kWakeupInterval, we need to 59 // choose the shorter interval for the wake up as well. 60 std::chrono::seconds computed_timeout = std::min(interrupt_timeout, 61 kWakeupInterval); 62 for (;;) { 63 PacketResult read_result = ReadPacket(response, computed_timeout, false); 64 // Reset the computed_timeout to the default value in case we are going 65 // round again. 66 computed_timeout = std::min(interrupt_timeout, kWakeupInterval); 67 switch (read_result) { 68 case PacketResult::ErrorReplyTimeout: { 69 std::lock_guard<std::mutex> lock(m_mutex); 70 if (m_async_count == 0) { 71 continue; 72 } 73 auto cur_time = steady_clock::now(); 74 if (cur_time >= m_interrupt_endpoint) 75 return eStateInvalid; 76 else { 77 // We woke up and found an interrupt is in flight, but we haven't 78 // exceeded the interrupt wait time. So reset the wait time to the 79 // time left till the interrupt timeout. But don't wait longer 80 // than our wakeup timeout. 81 auto new_wait = m_interrupt_endpoint - cur_time; 82 computed_timeout = std::min(kWakeupInterval, 83 std::chrono::duration_cast<std::chrono::seconds>(new_wait)); 84 continue; 85 } 86 break; 87 } 88 case PacketResult::Success: 89 break; 90 default: 91 LLDB_LOGF(log, "GDBRemoteClientBase::%s () ReadPacket(...) => false", 92 __FUNCTION__); 93 return eStateInvalid; 94 } 95 if (response.Empty()) 96 return eStateInvalid; 97 98 const char stop_type = response.GetChar(); 99 LLDB_LOGF(log, "GDBRemoteClientBase::%s () got packet: %s", __FUNCTION__, 100 response.GetStringRef().data()); 101 102 switch (stop_type) { 103 case 'W': 104 case 'X': 105 return eStateExited; 106 case 'E': 107 // ERROR 108 return eStateInvalid; 109 default: 110 LLDB_LOGF(log, "GDBRemoteClientBase::%s () unrecognized async packet", 111 __FUNCTION__); 112 return eStateInvalid; 113 case 'O': { 114 std::string inferior_stdout; 115 response.GetHexByteString(inferior_stdout); 116 delegate.HandleAsyncStdout(inferior_stdout); 117 break; 118 } 119 case 'A': 120 delegate.HandleAsyncMisc( 121 llvm::StringRef(response.GetStringRef()).substr(1)); 122 break; 123 case 'J': 124 delegate.HandleAsyncStructuredDataPacket(response.GetStringRef()); 125 break; 126 case 'T': 127 case 'S': 128 // Do this with the continue lock held. 129 const bool should_stop = ShouldStop(signals, response); 130 response.SetFilePos(0); 131 132 // The packet we should resume with. In the future we should check our 133 // thread list and "do the right thing" for new threads that show up 134 // while we stop and run async packets. Setting the packet to 'c' to 135 // continue all threads is the right thing to do 99.99% of the time 136 // because if a thread was single stepping, and we sent an interrupt, we 137 // will notice above that we didn't stop due to an interrupt but stopped 138 // due to stepping and we would _not_ continue. This packet may get 139 // modified by the async actions (e.g. to send a signal). 140 m_continue_packet = 'c'; 141 cont_lock.unlock(); 142 143 delegate.HandleStopReply(); 144 if (should_stop) 145 return eStateStopped; 146 147 switch (cont_lock.lock()) { 148 case ContinueLock::LockResult::Success: 149 break; 150 case ContinueLock::LockResult::Failed: 151 return eStateInvalid; 152 case ContinueLock::LockResult::Cancelled: 153 return eStateStopped; 154 } 155 OnRunPacketSent(false); 156 break; 157 } 158 } 159 } 160 161 bool GDBRemoteClientBase::SendAsyncSignal( 162 int signo, std::chrono::seconds interrupt_timeout) { 163 Lock lock(*this, interrupt_timeout); 164 if (!lock || !lock.DidInterrupt()) 165 return false; 166 167 m_continue_packet = 'C'; 168 m_continue_packet += llvm::hexdigit((signo / 16) % 16); 169 m_continue_packet += llvm::hexdigit(signo % 16); 170 return true; 171 } 172 173 bool GDBRemoteClientBase::Interrupt(std::chrono::seconds interrupt_timeout) { 174 Lock lock(*this, interrupt_timeout); 175 if (!lock.DidInterrupt()) 176 return false; 177 m_should_stop = true; 178 return true; 179 } 180 181 GDBRemoteCommunication::PacketResult 182 GDBRemoteClientBase::SendPacketAndWaitForResponse( 183 llvm::StringRef payload, StringExtractorGDBRemote &response, 184 std::chrono::seconds interrupt_timeout) { 185 Lock lock(*this, interrupt_timeout); 186 if (!lock) { 187 if (Log *log = GetLog(GDBRLog::Process)) 188 LLDB_LOGF(log, 189 "GDBRemoteClientBase::%s failed to get mutex, not sending " 190 "packet '%.*s'", 191 __FUNCTION__, int(payload.size()), payload.data()); 192 return PacketResult::ErrorSendFailed; 193 } 194 195 return SendPacketAndWaitForResponseNoLock(payload, response); 196 } 197 198 GDBRemoteCommunication::PacketResult 199 GDBRemoteClientBase::SendPacketAndReceiveResponseWithOutputSupport( 200 llvm::StringRef payload, StringExtractorGDBRemote &response, 201 std::chrono::seconds interrupt_timeout, 202 llvm::function_ref<void(llvm::StringRef)> output_callback) { 203 Lock lock(*this, interrupt_timeout); 204 if (!lock) { 205 if (Log *log = GetLog(GDBRLog::Process)) 206 LLDB_LOGF(log, 207 "GDBRemoteClientBase::%s failed to get mutex, not sending " 208 "packet '%.*s'", 209 __FUNCTION__, int(payload.size()), payload.data()); 210 return PacketResult::ErrorSendFailed; 211 } 212 213 PacketResult packet_result = SendPacketNoLock(payload); 214 if (packet_result != PacketResult::Success) 215 return packet_result; 216 217 return ReadPacketWithOutputSupport(response, GetPacketTimeout(), true, 218 output_callback); 219 } 220 221 GDBRemoteCommunication::PacketResult 222 GDBRemoteClientBase::SendPacketAndWaitForResponseNoLock( 223 llvm::StringRef payload, StringExtractorGDBRemote &response) { 224 PacketResult packet_result = SendPacketNoLock(payload); 225 if (packet_result != PacketResult::Success) 226 return packet_result; 227 228 const size_t max_response_retries = 3; 229 for (size_t i = 0; i < max_response_retries; ++i) { 230 packet_result = ReadPacket(response, GetPacketTimeout(), true); 231 // Make sure we received a response 232 if (packet_result != PacketResult::Success) 233 return packet_result; 234 // Make sure our response is valid for the payload that was sent 235 if (response.ValidateResponse()) 236 return packet_result; 237 // Response says it wasn't valid 238 Log *log = GetLog(GDBRLog::Packets); 239 LLDB_LOGF( 240 log, 241 "error: packet with payload \"%.*s\" got invalid response \"%s\": %s", 242 int(payload.size()), payload.data(), response.GetStringRef().data(), 243 (i == (max_response_retries - 1)) 244 ? "using invalid response and giving up" 245 : "ignoring response and waiting for another"); 246 } 247 return packet_result; 248 } 249 250 bool GDBRemoteClientBase::ShouldStop(const UnixSignals &signals, 251 StringExtractorGDBRemote &response) { 252 std::lock_guard<std::mutex> lock(m_mutex); 253 254 if (m_async_count == 0) 255 return true; // We were not interrupted. The process stopped on its own. 256 257 // Older debugserver stubs (before April 2016) can return two stop-reply 258 // packets in response to a ^C packet. Additionally, all debugservers still 259 // return two stop replies if the inferior stops due to some other reason 260 // before the remote stub manages to interrupt it. We need to wait for this 261 // additional packet to make sure the packet sequence does not get skewed. 262 StringExtractorGDBRemote extra_stop_reply_packet; 263 ReadPacket(extra_stop_reply_packet, milliseconds(100), false); 264 265 // Interrupting is typically done using SIGSTOP or SIGINT, so if the process 266 // stops with some other signal, we definitely want to stop. 267 const uint8_t signo = response.GetHexU8(UINT8_MAX); 268 if (signo != signals.GetSignalNumberFromName("SIGSTOP") && 269 signo != signals.GetSignalNumberFromName("SIGINT")) 270 return true; 271 272 // We probably only stopped to perform some async processing, so continue 273 // after that is done. 274 // TODO: This is not 100% correct, as the process may have been stopped with 275 // SIGINT or SIGSTOP that was not caused by us (e.g. raise(SIGINT)). This will 276 // normally cause a stop, but if it's done concurrently with a async 277 // interrupt, that stop will get eaten (llvm.org/pr20231). 278 return false; 279 } 280 281 void GDBRemoteClientBase::OnRunPacketSent(bool first) { 282 if (first) 283 BroadcastEvent(eBroadcastBitRunPacketSent, nullptr); 284 } 285 286 /////////////////////////////////////// 287 // GDBRemoteClientBase::ContinueLock // 288 /////////////////////////////////////// 289 290 GDBRemoteClientBase::ContinueLock::ContinueLock(GDBRemoteClientBase &comm) 291 : m_comm(comm), m_acquired(false) { 292 lock(); 293 } 294 295 GDBRemoteClientBase::ContinueLock::~ContinueLock() { 296 if (m_acquired) 297 unlock(); 298 } 299 300 void GDBRemoteClientBase::ContinueLock::unlock() { 301 lldbassert(m_acquired); 302 { 303 std::unique_lock<std::mutex> lock(m_comm.m_mutex); 304 m_comm.m_is_running = false; 305 } 306 m_comm.m_cv.notify_all(); 307 m_acquired = false; 308 } 309 310 GDBRemoteClientBase::ContinueLock::LockResult 311 GDBRemoteClientBase::ContinueLock::lock() { 312 Log *log = GetLog(GDBRLog::Process); 313 LLDB_LOGF(log, "GDBRemoteClientBase::ContinueLock::%s() resuming with %s", 314 __FUNCTION__, m_comm.m_continue_packet.c_str()); 315 316 lldbassert(!m_acquired); 317 std::unique_lock<std::mutex> lock(m_comm.m_mutex); 318 m_comm.m_cv.wait(lock, [this] { return m_comm.m_async_count == 0; }); 319 if (m_comm.m_should_stop) { 320 m_comm.m_should_stop = false; 321 LLDB_LOGF(log, "GDBRemoteClientBase::ContinueLock::%s() cancelled", 322 __FUNCTION__); 323 return LockResult::Cancelled; 324 } 325 if (m_comm.SendPacketNoLock(m_comm.m_continue_packet) != 326 PacketResult::Success) 327 return LockResult::Failed; 328 329 lldbassert(!m_comm.m_is_running); 330 m_comm.m_is_running = true; 331 m_acquired = true; 332 return LockResult::Success; 333 } 334 335 /////////////////////////////// 336 // GDBRemoteClientBase::Lock // 337 /////////////////////////////// 338 339 GDBRemoteClientBase::Lock::Lock(GDBRemoteClientBase &comm, 340 std::chrono::seconds interrupt_timeout) 341 : m_async_lock(comm.m_async_mutex, std::defer_lock), m_comm(comm), 342 m_interrupt_timeout(interrupt_timeout), m_acquired(false), 343 m_did_interrupt(false) { 344 SyncWithContinueThread(); 345 if (m_acquired) 346 m_async_lock.lock(); 347 } 348 349 void GDBRemoteClientBase::Lock::SyncWithContinueThread() { 350 Log *log = GetLog(GDBRLog::Process); 351 std::unique_lock<std::mutex> lock(m_comm.m_mutex); 352 if (m_comm.m_is_running && m_interrupt_timeout == std::chrono::seconds(0)) 353 return; // We were asked to avoid interrupting the sender. Lock is not 354 // acquired. 355 356 ++m_comm.m_async_count; 357 if (m_comm.m_is_running) { 358 if (m_comm.m_async_count == 1) { 359 // The sender has sent the continue packet and we are the first async 360 // packet. Let's interrupt it. 361 const char ctrl_c = '\x03'; 362 ConnectionStatus status = eConnectionStatusSuccess; 363 size_t bytes_written = m_comm.Write(&ctrl_c, 1, status, nullptr); 364 if (bytes_written == 0) { 365 --m_comm.m_async_count; 366 LLDB_LOGF(log, "GDBRemoteClientBase::Lock::Lock failed to send " 367 "interrupt packet"); 368 return; 369 } 370 m_comm.m_interrupt_endpoint = steady_clock::now() + m_interrupt_timeout; 371 if (log) 372 log->PutCString("GDBRemoteClientBase::Lock::Lock sent packet: \\x03"); 373 } 374 m_comm.m_cv.wait(lock, [this] { return !m_comm.m_is_running; }); 375 m_did_interrupt = true; 376 } 377 m_acquired = true; 378 } 379 380 GDBRemoteClientBase::Lock::~Lock() { 381 if (!m_acquired) 382 return; 383 { 384 std::unique_lock<std::mutex> lock(m_comm.m_mutex); 385 --m_comm.m_async_count; 386 } 387 m_comm.m_cv.notify_one(); 388 } 389