1 //===-- NativeProcessLinux.cpp -------------------------------- -*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/lldb-python.h" 11 12 #include "NativeProcessLinux.h" 13 14 // C Includes 15 #include <errno.h> 16 #include <poll.h> 17 #include <string.h> 18 #include <stdint.h> 19 #include <unistd.h> 20 #include <linux/unistd.h> 21 #if defined(__ANDROID_NDK__) && defined (__arm__) 22 #include <linux/personality.h> 23 #include <linux/user.h> 24 #else 25 #include <sys/personality.h> 26 #include <sys/user.h> 27 #endif 28 #ifndef __ANDROID__ 29 #include <sys/procfs.h> 30 #endif 31 #include <sys/ptrace.h> 32 #include <sys/uio.h> 33 #include <sys/socket.h> 34 #include <sys/syscall.h> 35 #include <sys/types.h> 36 #include <sys/wait.h> 37 38 #if defined (__arm64__) || defined (__aarch64__) 39 // NT_PRSTATUS and NT_FPREGSET definition 40 #include <elf.h> 41 #endif 42 43 // C++ Includes 44 #include <fstream> 45 #include <string> 46 47 // Other libraries and framework includes 48 #include "lldb/Core/Debugger.h" 49 #include "lldb/Core/Error.h" 50 #include "lldb/Core/Module.h" 51 #include "lldb/Core/ModuleSpec.h" 52 #include "lldb/Core/RegisterValue.h" 53 #include "lldb/Core/Scalar.h" 54 #include "lldb/Core/State.h" 55 #include "lldb/Host/Host.h" 56 #include "lldb/Host/HostInfo.h" 57 #include "lldb/Host/ThreadLauncher.h" 58 #include "lldb/Symbol/ObjectFile.h" 59 #include "lldb/Target/NativeRegisterContext.h" 60 #include "lldb/Target/ProcessLaunchInfo.h" 61 #include "lldb/Utility/PseudoTerminal.h" 62 63 #include "Host/common/NativeBreakpoint.h" 64 #include "Utility/StringExtractor.h" 65 66 #include "Plugins/Process/Utility/LinuxSignals.h" 67 #include "NativeThreadLinux.h" 68 #include "ProcFileReader.h" 69 #include "ThreadStateCoordinator.h" 70 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h" 71 72 #ifdef __ANDROID__ 73 #define __ptrace_request int 74 #define PT_DETACH PTRACE_DETACH 75 #endif 76 77 #define DEBUG_PTRACE_MAXBYTES 20 78 79 // Support ptrace extensions even when compiled without required kernel support 80 #ifndef PT_GETREGS 81 #ifndef PTRACE_GETREGS 82 #define PTRACE_GETREGS 12 83 #endif 84 #endif 85 #ifndef PT_SETREGS 86 #ifndef PTRACE_SETREGS 87 #define PTRACE_SETREGS 13 88 #endif 89 #endif 90 #ifndef PT_GETFPREGS 91 #ifndef PTRACE_GETFPREGS 92 #define PTRACE_GETFPREGS 14 93 #endif 94 #endif 95 #ifndef PT_SETFPREGS 96 #ifndef PTRACE_SETFPREGS 97 #define PTRACE_SETFPREGS 15 98 #endif 99 #endif 100 #ifndef PTRACE_GETREGSET 101 #define PTRACE_GETREGSET 0x4204 102 #endif 103 #ifndef PTRACE_SETREGSET 104 #define PTRACE_SETREGSET 0x4205 105 #endif 106 #ifndef PTRACE_GET_THREAD_AREA 107 #define PTRACE_GET_THREAD_AREA 25 108 #endif 109 #ifndef PTRACE_ARCH_PRCTL 110 #define PTRACE_ARCH_PRCTL 30 111 #endif 112 #ifndef ARCH_GET_FS 113 #define ARCH_SET_GS 0x1001 114 #define ARCH_SET_FS 0x1002 115 #define ARCH_GET_FS 0x1003 116 #define ARCH_GET_GS 0x1004 117 #endif 118 119 #define LLDB_PERSONALITY_GET_CURRENT_SETTINGS 0xffffffff 120 121 // Support hardware breakpoints in case it has not been defined 122 #ifndef TRAP_HWBKPT 123 #define TRAP_HWBKPT 4 124 #endif 125 126 // Try to define a macro to encapsulate the tgkill syscall 127 // fall back on kill() if tgkill isn't available 128 #define tgkill(pid, tid, sig) syscall(SYS_tgkill, pid, tid, sig) 129 130 // We disable the tracing of ptrace calls for integration builds to 131 // avoid the additional indirection and checks. 132 #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION 133 #define PTRACE(req, pid, addr, data, data_size) \ 134 PtraceWrapper((req), (pid), (addr), (data), (data_size), #req, __FILE__, __LINE__) 135 #else 136 #define PTRACE(req, pid, addr, data, data_size) \ 137 PtraceWrapper((req), (pid), (addr), (data), (data_size)) 138 #endif 139 140 // Private bits we only need internally. 141 namespace 142 { 143 using namespace lldb; 144 using namespace lldb_private; 145 146 const UnixSignals& 147 GetUnixSignals () 148 { 149 static process_linux::LinuxSignals signals; 150 return signals; 151 } 152 153 ThreadStateCoordinator::LogFunction 154 GetThreadLoggerFunction () 155 { 156 return [](const char *format, va_list args) 157 { 158 Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD); 159 if (log) 160 log->VAPrintf (format, args); 161 }; 162 } 163 164 void 165 CoordinatorErrorHandler (const std::string &error_message) 166 { 167 Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD); 168 if (log) 169 log->Printf ("NativePlatformLinux::%s ThreadStateCoordinator error received: %s", __FUNCTION__, error_message.c_str ()); 170 assert (false && "ThreadStateCoordinator error reported"); 171 } 172 173 Error 174 ResolveProcessArchitecture (lldb::pid_t pid, Platform &platform, ArchSpec &arch) 175 { 176 // Grab process info for the running process. 177 ProcessInstanceInfo process_info; 178 if (!platform.GetProcessInfo (pid, process_info)) 179 return lldb_private::Error("failed to get process info"); 180 181 // Resolve the executable module. 182 ModuleSP exe_module_sp; 183 ModuleSpec exe_module_spec(process_info.GetExecutableFile(), platform.GetSystemArchitecture ()); 184 FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths ()); 185 Error error = platform.ResolveExecutable( 186 exe_module_spec, 187 exe_module_sp, 188 executable_search_paths.GetSize () ? &executable_search_paths : NULL); 189 190 if (!error.Success ()) 191 return error; 192 193 // Check if we've got our architecture from the exe_module. 194 arch = exe_module_sp->GetArchitecture (); 195 if (arch.IsValid ()) 196 return Error(); 197 else 198 return Error("failed to retrieve a valid architecture from the exe module"); 199 } 200 201 void 202 DisplayBytes (lldb_private::StreamString &s, void *bytes, uint32_t count) 203 { 204 uint8_t *ptr = (uint8_t *)bytes; 205 const uint32_t loop_count = std::min<uint32_t>(DEBUG_PTRACE_MAXBYTES, count); 206 for(uint32_t i=0; i<loop_count; i++) 207 { 208 s.Printf ("[%x]", *ptr); 209 ptr++; 210 } 211 } 212 213 void 214 PtraceDisplayBytes(int &req, void *data, size_t data_size) 215 { 216 StreamString buf; 217 Log *verbose_log (ProcessPOSIXLog::GetLogIfAllCategoriesSet ( 218 POSIX_LOG_PTRACE | POSIX_LOG_VERBOSE)); 219 220 if (verbose_log) 221 { 222 switch(req) 223 { 224 case PTRACE_POKETEXT: 225 { 226 DisplayBytes(buf, &data, 8); 227 verbose_log->Printf("PTRACE_POKETEXT %s", buf.GetData()); 228 break; 229 } 230 case PTRACE_POKEDATA: 231 { 232 DisplayBytes(buf, &data, 8); 233 verbose_log->Printf("PTRACE_POKEDATA %s", buf.GetData()); 234 break; 235 } 236 case PTRACE_POKEUSER: 237 { 238 DisplayBytes(buf, &data, 8); 239 verbose_log->Printf("PTRACE_POKEUSER %s", buf.GetData()); 240 break; 241 } 242 case PTRACE_SETREGS: 243 { 244 DisplayBytes(buf, data, data_size); 245 verbose_log->Printf("PTRACE_SETREGS %s", buf.GetData()); 246 break; 247 } 248 case PTRACE_SETFPREGS: 249 { 250 DisplayBytes(buf, data, data_size); 251 verbose_log->Printf("PTRACE_SETFPREGS %s", buf.GetData()); 252 break; 253 } 254 case PTRACE_SETSIGINFO: 255 { 256 DisplayBytes(buf, data, sizeof(siginfo_t)); 257 verbose_log->Printf("PTRACE_SETSIGINFO %s", buf.GetData()); 258 break; 259 } 260 case PTRACE_SETREGSET: 261 { 262 // Extract iov_base from data, which is a pointer to the struct IOVEC 263 DisplayBytes(buf, *(void **)data, data_size); 264 verbose_log->Printf("PTRACE_SETREGSET %s", buf.GetData()); 265 break; 266 } 267 default: 268 { 269 } 270 } 271 } 272 } 273 274 // Wrapper for ptrace to catch errors and log calls. 275 // Note that ptrace sets errno on error because -1 can be a valid result (i.e. for PTRACE_PEEK*) 276 long 277 PtraceWrapper(int req, lldb::pid_t pid, void *addr, void *data, size_t data_size, 278 const char* reqName, const char* file, int line) 279 { 280 long int result; 281 282 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PTRACE)); 283 284 PtraceDisplayBytes(req, data, data_size); 285 286 errno = 0; 287 if (req == PTRACE_GETREGSET || req == PTRACE_SETREGSET) 288 result = ptrace(static_cast<__ptrace_request>(req), static_cast< ::pid_t>(pid), *(unsigned int *)addr, data); 289 else 290 result = ptrace(static_cast<__ptrace_request>(req), static_cast< ::pid_t>(pid), addr, data); 291 292 if (log) 293 log->Printf("ptrace(%s, %" PRIu64 ", %p, %p, %zu)=%lX called from file %s line %d", 294 reqName, pid, addr, data, data_size, result, file, line); 295 296 PtraceDisplayBytes(req, data, data_size); 297 298 if (log && errno != 0) 299 { 300 const char* str; 301 switch (errno) 302 { 303 case ESRCH: str = "ESRCH"; break; 304 case EINVAL: str = "EINVAL"; break; 305 case EBUSY: str = "EBUSY"; break; 306 case EPERM: str = "EPERM"; break; 307 default: str = "<unknown>"; 308 } 309 log->Printf("ptrace() failed; errno=%d (%s)", errno, str); 310 } 311 312 return result; 313 } 314 315 #ifdef LLDB_CONFIGURATION_BUILDANDINTEGRATION 316 // Wrapper for ptrace when logging is not required. 317 // Sets errno to 0 prior to calling ptrace. 318 long 319 PtraceWrapper(int req, lldb::pid_t pid, void *addr, void *data, size_t data_size) 320 { 321 long result = 0; 322 errno = 0; 323 if (req == PTRACE_GETREGSET || req == PTRACE_SETREGSET) 324 result = ptrace(static_cast<__ptrace_request>(req), static_cast< ::pid_t>(pid), *(unsigned int *)addr, data); 325 else 326 result = ptrace(static_cast<__ptrace_request>(req), static_cast< ::pid_t>(pid), addr, data); 327 return result; 328 } 329 #endif 330 331 //------------------------------------------------------------------------------ 332 // Static implementations of NativeProcessLinux::ReadMemory and 333 // NativeProcessLinux::WriteMemory. This enables mutual recursion between these 334 // functions without needed to go thru the thread funnel. 335 336 static lldb::addr_t 337 DoReadMemory ( 338 lldb::pid_t pid, 339 lldb::addr_t vm_addr, 340 void *buf, 341 lldb::addr_t size, 342 Error &error) 343 { 344 // ptrace word size is determined by the host, not the child 345 static const unsigned word_size = sizeof(void*); 346 unsigned char *dst = static_cast<unsigned char*>(buf); 347 lldb::addr_t bytes_read; 348 lldb::addr_t remainder; 349 long data; 350 351 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_ALL)); 352 if (log) 353 ProcessPOSIXLog::IncNestLevel(); 354 if (log && ProcessPOSIXLog::AtTopNestLevel() && log->GetMask().Test(POSIX_LOG_MEMORY)) 355 log->Printf ("NativeProcessLinux::%s(%" PRIu64 ", %d, %p, %p, %zd, _)", __FUNCTION__, 356 pid, word_size, (void*)vm_addr, buf, size); 357 358 assert(sizeof(data) >= word_size); 359 for (bytes_read = 0; bytes_read < size; bytes_read += remainder) 360 { 361 errno = 0; 362 data = PTRACE(PTRACE_PEEKDATA, pid, (void*)vm_addr, NULL, 0); 363 if (errno) 364 { 365 error.SetErrorToErrno(); 366 if (log) 367 ProcessPOSIXLog::DecNestLevel(); 368 return bytes_read; 369 } 370 371 remainder = size - bytes_read; 372 remainder = remainder > word_size ? word_size : remainder; 373 374 // Copy the data into our buffer 375 for (unsigned i = 0; i < remainder; ++i) 376 dst[i] = ((data >> i*8) & 0xFF); 377 378 if (log && ProcessPOSIXLog::AtTopNestLevel() && 379 (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_LONG) || 380 (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_SHORT) && 381 size <= POSIX_LOG_MEMORY_SHORT_BYTES))) 382 { 383 uintptr_t print_dst = 0; 384 // Format bytes from data by moving into print_dst for log output 385 for (unsigned i = 0; i < remainder; ++i) 386 print_dst |= (((data >> i*8) & 0xFF) << i*8); 387 log->Printf ("NativeProcessLinux::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__, 388 (void*)vm_addr, print_dst, (unsigned long)data); 389 } 390 391 vm_addr += word_size; 392 dst += word_size; 393 } 394 395 if (log) 396 ProcessPOSIXLog::DecNestLevel(); 397 return bytes_read; 398 } 399 400 static lldb::addr_t 401 DoWriteMemory( 402 lldb::pid_t pid, 403 lldb::addr_t vm_addr, 404 const void *buf, 405 lldb::addr_t size, 406 Error &error) 407 { 408 // ptrace word size is determined by the host, not the child 409 static const unsigned word_size = sizeof(void*); 410 const unsigned char *src = static_cast<const unsigned char*>(buf); 411 lldb::addr_t bytes_written = 0; 412 lldb::addr_t remainder; 413 414 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_ALL)); 415 if (log) 416 ProcessPOSIXLog::IncNestLevel(); 417 if (log && ProcessPOSIXLog::AtTopNestLevel() && log->GetMask().Test(POSIX_LOG_MEMORY)) 418 log->Printf ("NativeProcessLinux::%s(%" PRIu64 ", %u, %p, %p, %" PRIu64 ")", __FUNCTION__, 419 pid, word_size, (void*)vm_addr, buf, size); 420 421 for (bytes_written = 0; bytes_written < size; bytes_written += remainder) 422 { 423 remainder = size - bytes_written; 424 remainder = remainder > word_size ? word_size : remainder; 425 426 if (remainder == word_size) 427 { 428 unsigned long data = 0; 429 assert(sizeof(data) >= word_size); 430 for (unsigned i = 0; i < word_size; ++i) 431 data |= (unsigned long)src[i] << i*8; 432 433 if (log && ProcessPOSIXLog::AtTopNestLevel() && 434 (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_LONG) || 435 (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_SHORT) && 436 size <= POSIX_LOG_MEMORY_SHORT_BYTES))) 437 log->Printf ("NativeProcessLinux::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__, 438 (void*)vm_addr, *(unsigned long*)src, data); 439 440 if (PTRACE(PTRACE_POKEDATA, pid, (void*)vm_addr, (void*)data, 0)) 441 { 442 error.SetErrorToErrno(); 443 if (log) 444 ProcessPOSIXLog::DecNestLevel(); 445 return bytes_written; 446 } 447 } 448 else 449 { 450 unsigned char buff[8]; 451 if (DoReadMemory(pid, vm_addr, 452 buff, word_size, error) != word_size) 453 { 454 if (log) 455 ProcessPOSIXLog::DecNestLevel(); 456 return bytes_written; 457 } 458 459 memcpy(buff, src, remainder); 460 461 if (DoWriteMemory(pid, vm_addr, 462 buff, word_size, error) != word_size) 463 { 464 if (log) 465 ProcessPOSIXLog::DecNestLevel(); 466 return bytes_written; 467 } 468 469 if (log && ProcessPOSIXLog::AtTopNestLevel() && 470 (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_LONG) || 471 (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_SHORT) && 472 size <= POSIX_LOG_MEMORY_SHORT_BYTES))) 473 log->Printf ("NativeProcessLinux::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__, 474 (void*)vm_addr, *(unsigned long*)src, *(unsigned long*)buff); 475 } 476 477 vm_addr += word_size; 478 src += word_size; 479 } 480 if (log) 481 ProcessPOSIXLog::DecNestLevel(); 482 return bytes_written; 483 } 484 485 //------------------------------------------------------------------------------ 486 /// @class Operation 487 /// @brief Represents a NativeProcessLinux operation. 488 /// 489 /// Under Linux, it is not possible to ptrace() from any other thread but the 490 /// one that spawned or attached to the process from the start. Therefore, when 491 /// a NativeProcessLinux is asked to deliver or change the state of an inferior 492 /// process the operation must be "funneled" to a specific thread to perform the 493 /// task. The Operation class provides an abstract base for all services the 494 /// NativeProcessLinux must perform via the single virtual function Execute, thus 495 /// encapsulating the code that needs to run in the privileged context. 496 class Operation 497 { 498 public: 499 Operation () : m_error() { } 500 501 virtual 502 ~Operation() {} 503 504 virtual void 505 Execute (NativeProcessLinux *process) = 0; 506 507 const Error & 508 GetError () const { return m_error; } 509 510 protected: 511 Error m_error; 512 }; 513 514 //------------------------------------------------------------------------------ 515 /// @class ReadOperation 516 /// @brief Implements NativeProcessLinux::ReadMemory. 517 class ReadOperation : public Operation 518 { 519 public: 520 ReadOperation ( 521 lldb::addr_t addr, 522 void *buff, 523 lldb::addr_t size, 524 lldb::addr_t &result) : 525 Operation (), 526 m_addr (addr), 527 m_buff (buff), 528 m_size (size), 529 m_result (result) 530 { 531 } 532 533 void Execute (NativeProcessLinux *process) override; 534 535 private: 536 lldb::addr_t m_addr; 537 void *m_buff; 538 lldb::addr_t m_size; 539 lldb::addr_t &m_result; 540 }; 541 542 void 543 ReadOperation::Execute (NativeProcessLinux *process) 544 { 545 m_result = DoReadMemory (process->GetID (), m_addr, m_buff, m_size, m_error); 546 } 547 548 //------------------------------------------------------------------------------ 549 /// @class WriteOperation 550 /// @brief Implements NativeProcessLinux::WriteMemory. 551 class WriteOperation : public Operation 552 { 553 public: 554 WriteOperation ( 555 lldb::addr_t addr, 556 const void *buff, 557 lldb::addr_t size, 558 lldb::addr_t &result) : 559 Operation (), 560 m_addr (addr), 561 m_buff (buff), 562 m_size (size), 563 m_result (result) 564 { 565 } 566 567 void Execute (NativeProcessLinux *process) override; 568 569 private: 570 lldb::addr_t m_addr; 571 const void *m_buff; 572 lldb::addr_t m_size; 573 lldb::addr_t &m_result; 574 }; 575 576 void 577 WriteOperation::Execute(NativeProcessLinux *process) 578 { 579 m_result = DoWriteMemory (process->GetID (), m_addr, m_buff, m_size, m_error); 580 } 581 582 //------------------------------------------------------------------------------ 583 /// @class ReadRegOperation 584 /// @brief Implements NativeProcessLinux::ReadRegisterValue. 585 class ReadRegOperation : public Operation 586 { 587 public: 588 ReadRegOperation(lldb::tid_t tid, uint32_t offset, const char *reg_name, 589 RegisterValue &value, bool &result) 590 : m_tid(tid), m_offset(static_cast<uintptr_t> (offset)), m_reg_name(reg_name), 591 m_value(value), m_result(result) 592 { } 593 594 void Execute(NativeProcessLinux *monitor); 595 596 private: 597 lldb::tid_t m_tid; 598 uintptr_t m_offset; 599 const char *m_reg_name; 600 RegisterValue &m_value; 601 bool &m_result; 602 }; 603 604 void 605 ReadRegOperation::Execute(NativeProcessLinux *monitor) 606 { 607 #if defined (__arm64__) || defined (__aarch64__) 608 if (m_offset > sizeof(struct user_pt_regs)) 609 { 610 uintptr_t offset = m_offset - sizeof(struct user_pt_regs); 611 if (offset > sizeof(struct user_fpsimd_state)) 612 { 613 m_result = false; 614 } 615 else 616 { 617 elf_fpregset_t regs; 618 int regset = NT_FPREGSET; 619 struct iovec ioVec; 620 621 ioVec.iov_base = ®s; 622 ioVec.iov_len = sizeof regs; 623 if (PTRACE(PTRACE_GETREGSET, m_tid, ®set, &ioVec, sizeof regs) < 0) 624 m_result = false; 625 else 626 { 627 lldb_private::ArchSpec arch; 628 if (monitor->GetArchitecture(arch)) 629 { 630 m_result = true; 631 m_value.SetBytes((void *)(((unsigned char *)(®s)) + offset), 16, arch.GetByteOrder()); 632 } 633 else 634 m_result = false; 635 } 636 } 637 } 638 else 639 { 640 elf_gregset_t regs; 641 int regset = NT_PRSTATUS; 642 struct iovec ioVec; 643 644 ioVec.iov_base = ®s; 645 ioVec.iov_len = sizeof regs; 646 if (PTRACE(PTRACE_GETREGSET, m_tid, ®set, &ioVec, sizeof regs) < 0) 647 m_result = false; 648 else 649 { 650 lldb_private::ArchSpec arch; 651 if (monitor->GetArchitecture(arch)) 652 { 653 m_result = true; 654 m_value.SetBytes((void *)(((unsigned char *)(regs)) + m_offset), 8, arch.GetByteOrder()); 655 } else 656 m_result = false; 657 } 658 } 659 #else 660 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS)); 661 662 // Set errno to zero so that we can detect a failed peek. 663 errno = 0; 664 lldb::addr_t data = PTRACE(PTRACE_PEEKUSER, m_tid, (void*)m_offset, NULL, 0); 665 if (errno) 666 m_result = false; 667 else 668 { 669 m_value = data; 670 m_result = true; 671 } 672 if (log) 673 log->Printf ("NativeProcessLinux::%s() reg %s: 0x%" PRIx64, __FUNCTION__, 674 m_reg_name, data); 675 #endif 676 } 677 678 //------------------------------------------------------------------------------ 679 /// @class WriteRegOperation 680 /// @brief Implements NativeProcessLinux::WriteRegisterValue. 681 class WriteRegOperation : public Operation 682 { 683 public: 684 WriteRegOperation(lldb::tid_t tid, unsigned offset, const char *reg_name, 685 const RegisterValue &value, bool &result) 686 : m_tid(tid), m_offset(offset), m_reg_name(reg_name), 687 m_value(value), m_result(result) 688 { } 689 690 void Execute(NativeProcessLinux *monitor); 691 692 private: 693 lldb::tid_t m_tid; 694 uintptr_t m_offset; 695 const char *m_reg_name; 696 const RegisterValue &m_value; 697 bool &m_result; 698 }; 699 700 void 701 WriteRegOperation::Execute(NativeProcessLinux *monitor) 702 { 703 #if defined (__arm64__) || defined (__aarch64__) 704 if (m_offset > sizeof(struct user_pt_regs)) 705 { 706 uintptr_t offset = m_offset - sizeof(struct user_pt_regs); 707 if (offset > sizeof(struct user_fpsimd_state)) 708 { 709 m_result = false; 710 } 711 else 712 { 713 elf_fpregset_t regs; 714 int regset = NT_FPREGSET; 715 struct iovec ioVec; 716 717 ioVec.iov_base = ®s; 718 ioVec.iov_len = sizeof regs; 719 if (PTRACE(PTRACE_GETREGSET, m_tid, ®set, &ioVec, sizeof regs) < 0) 720 m_result = false; 721 else 722 { 723 ::memcpy((void *)(((unsigned char *)(®s)) + offset), m_value.GetBytes(), 16); 724 if (PTRACE(PTRACE_SETREGSET, m_tid, ®set, &ioVec, sizeof regs) < 0) 725 m_result = false; 726 else 727 m_result = true; 728 } 729 } 730 } 731 else 732 { 733 elf_gregset_t regs; 734 int regset = NT_PRSTATUS; 735 struct iovec ioVec; 736 737 ioVec.iov_base = ®s; 738 ioVec.iov_len = sizeof regs; 739 if (PTRACE(PTRACE_GETREGSET, m_tid, ®set, &ioVec, sizeof regs) < 0) 740 m_result = false; 741 else 742 { 743 ::memcpy((void *)(((unsigned char *)(®s)) + m_offset), m_value.GetBytes(), 8); 744 if (PTRACE(PTRACE_SETREGSET, m_tid, ®set, &ioVec, sizeof regs) < 0) 745 m_result = false; 746 else 747 m_result = true; 748 } 749 } 750 #else 751 void* buf; 752 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS)); 753 754 buf = (void*) m_value.GetAsUInt64(); 755 756 if (log) 757 log->Printf ("NativeProcessLinux::%s() reg %s: %p", __FUNCTION__, m_reg_name, buf); 758 if (PTRACE(PTRACE_POKEUSER, m_tid, (void*)m_offset, buf, 0)) 759 m_result = false; 760 else 761 m_result = true; 762 #endif 763 } 764 765 //------------------------------------------------------------------------------ 766 /// @class ReadGPROperation 767 /// @brief Implements NativeProcessLinux::ReadGPR. 768 class ReadGPROperation : public Operation 769 { 770 public: 771 ReadGPROperation(lldb::tid_t tid, void *buf, size_t buf_size, bool &result) 772 : m_tid(tid), m_buf(buf), m_buf_size(buf_size), m_result(result) 773 { } 774 775 void Execute(NativeProcessLinux *monitor); 776 777 private: 778 lldb::tid_t m_tid; 779 void *m_buf; 780 size_t m_buf_size; 781 bool &m_result; 782 }; 783 784 void 785 ReadGPROperation::Execute(NativeProcessLinux *monitor) 786 { 787 #if defined (__arm64__) || defined (__aarch64__) 788 int regset = NT_PRSTATUS; 789 struct iovec ioVec; 790 791 ioVec.iov_base = m_buf; 792 ioVec.iov_len = m_buf_size; 793 if (PTRACE(PTRACE_GETREGSET, m_tid, ®set, &ioVec, m_buf_size) < 0) 794 m_result = false; 795 else 796 m_result = true; 797 #else 798 if (PTRACE(PTRACE_GETREGS, m_tid, NULL, m_buf, m_buf_size) < 0) 799 m_result = false; 800 else 801 m_result = true; 802 #endif 803 } 804 805 //------------------------------------------------------------------------------ 806 /// @class ReadFPROperation 807 /// @brief Implements NativeProcessLinux::ReadFPR. 808 class ReadFPROperation : public Operation 809 { 810 public: 811 ReadFPROperation(lldb::tid_t tid, void *buf, size_t buf_size, bool &result) 812 : m_tid(tid), m_buf(buf), m_buf_size(buf_size), m_result(result) 813 { } 814 815 void Execute(NativeProcessLinux *monitor); 816 817 private: 818 lldb::tid_t m_tid; 819 void *m_buf; 820 size_t m_buf_size; 821 bool &m_result; 822 }; 823 824 void 825 ReadFPROperation::Execute(NativeProcessLinux *monitor) 826 { 827 #if defined (__arm64__) || defined (__aarch64__) 828 int regset = NT_FPREGSET; 829 struct iovec ioVec; 830 831 ioVec.iov_base = m_buf; 832 ioVec.iov_len = m_buf_size; 833 if (PTRACE(PTRACE_GETREGSET, m_tid, ®set, &ioVec, m_buf_size) < 0) 834 m_result = false; 835 else 836 m_result = true; 837 #else 838 if (PTRACE(PTRACE_GETFPREGS, m_tid, NULL, m_buf, m_buf_size) < 0) 839 m_result = false; 840 else 841 m_result = true; 842 #endif 843 } 844 845 //------------------------------------------------------------------------------ 846 /// @class ReadRegisterSetOperation 847 /// @brief Implements NativeProcessLinux::ReadRegisterSet. 848 class ReadRegisterSetOperation : public Operation 849 { 850 public: 851 ReadRegisterSetOperation(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset, bool &result) 852 : m_tid(tid), m_buf(buf), m_buf_size(buf_size), m_regset(regset), m_result(result) 853 { } 854 855 void Execute(NativeProcessLinux *monitor); 856 857 private: 858 lldb::tid_t m_tid; 859 void *m_buf; 860 size_t m_buf_size; 861 const unsigned int m_regset; 862 bool &m_result; 863 }; 864 865 void 866 ReadRegisterSetOperation::Execute(NativeProcessLinux *monitor) 867 { 868 if (PTRACE(PTRACE_GETREGSET, m_tid, (void *)&m_regset, m_buf, m_buf_size) < 0) 869 m_result = false; 870 else 871 m_result = true; 872 } 873 874 //------------------------------------------------------------------------------ 875 /// @class WriteGPROperation 876 /// @brief Implements NativeProcessLinux::WriteGPR. 877 class WriteGPROperation : public Operation 878 { 879 public: 880 WriteGPROperation(lldb::tid_t tid, void *buf, size_t buf_size, bool &result) 881 : m_tid(tid), m_buf(buf), m_buf_size(buf_size), m_result(result) 882 { } 883 884 void Execute(NativeProcessLinux *monitor); 885 886 private: 887 lldb::tid_t m_tid; 888 void *m_buf; 889 size_t m_buf_size; 890 bool &m_result; 891 }; 892 893 void 894 WriteGPROperation::Execute(NativeProcessLinux *monitor) 895 { 896 #if defined (__arm64__) || defined (__aarch64__) 897 int regset = NT_PRSTATUS; 898 struct iovec ioVec; 899 900 ioVec.iov_base = m_buf; 901 ioVec.iov_len = m_buf_size; 902 if (PTRACE(PTRACE_SETREGSET, m_tid, ®set, &ioVec, m_buf_size) < 0) 903 m_result = false; 904 else 905 m_result = true; 906 #else 907 if (PTRACE(PTRACE_SETREGS, m_tid, NULL, m_buf, m_buf_size) < 0) 908 m_result = false; 909 else 910 m_result = true; 911 #endif 912 } 913 914 //------------------------------------------------------------------------------ 915 /// @class WriteFPROperation 916 /// @brief Implements NativeProcessLinux::WriteFPR. 917 class WriteFPROperation : public Operation 918 { 919 public: 920 WriteFPROperation(lldb::tid_t tid, void *buf, size_t buf_size, bool &result) 921 : m_tid(tid), m_buf(buf), m_buf_size(buf_size), m_result(result) 922 { } 923 924 void Execute(NativeProcessLinux *monitor); 925 926 private: 927 lldb::tid_t m_tid; 928 void *m_buf; 929 size_t m_buf_size; 930 bool &m_result; 931 }; 932 933 void 934 WriteFPROperation::Execute(NativeProcessLinux *monitor) 935 { 936 #if defined (__arm64__) || defined (__aarch64__) 937 int regset = NT_FPREGSET; 938 struct iovec ioVec; 939 940 ioVec.iov_base = m_buf; 941 ioVec.iov_len = m_buf_size; 942 if (PTRACE(PTRACE_SETREGSET, m_tid, ®set, &ioVec, m_buf_size) < 0) 943 m_result = false; 944 else 945 m_result = true; 946 #else 947 if (PTRACE(PTRACE_SETFPREGS, m_tid, NULL, m_buf, m_buf_size) < 0) 948 m_result = false; 949 else 950 m_result = true; 951 #endif 952 } 953 954 //------------------------------------------------------------------------------ 955 /// @class WriteRegisterSetOperation 956 /// @brief Implements NativeProcessLinux::WriteRegisterSet. 957 class WriteRegisterSetOperation : public Operation 958 { 959 public: 960 WriteRegisterSetOperation(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset, bool &result) 961 : m_tid(tid), m_buf(buf), m_buf_size(buf_size), m_regset(regset), m_result(result) 962 { } 963 964 void Execute(NativeProcessLinux *monitor); 965 966 private: 967 lldb::tid_t m_tid; 968 void *m_buf; 969 size_t m_buf_size; 970 const unsigned int m_regset; 971 bool &m_result; 972 }; 973 974 void 975 WriteRegisterSetOperation::Execute(NativeProcessLinux *monitor) 976 { 977 if (PTRACE(PTRACE_SETREGSET, m_tid, (void *)&m_regset, m_buf, m_buf_size) < 0) 978 m_result = false; 979 else 980 m_result = true; 981 } 982 983 //------------------------------------------------------------------------------ 984 /// @class ResumeOperation 985 /// @brief Implements NativeProcessLinux::Resume. 986 class ResumeOperation : public Operation 987 { 988 public: 989 ResumeOperation(lldb::tid_t tid, uint32_t signo, bool &result) : 990 m_tid(tid), m_signo(signo), m_result(result) { } 991 992 void Execute(NativeProcessLinux *monitor); 993 994 private: 995 lldb::tid_t m_tid; 996 uint32_t m_signo; 997 bool &m_result; 998 }; 999 1000 void 1001 ResumeOperation::Execute(NativeProcessLinux *monitor) 1002 { 1003 intptr_t data = 0; 1004 1005 if (m_signo != LLDB_INVALID_SIGNAL_NUMBER) 1006 data = m_signo; 1007 1008 if (PTRACE(PTRACE_CONT, m_tid, NULL, (void*)data, 0)) 1009 { 1010 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 1011 1012 if (log) 1013 log->Printf ("ResumeOperation (%" PRIu64 ") failed: %s", m_tid, strerror(errno)); 1014 m_result = false; 1015 } 1016 else 1017 m_result = true; 1018 } 1019 1020 //------------------------------------------------------------------------------ 1021 /// @class SingleStepOperation 1022 /// @brief Implements NativeProcessLinux::SingleStep. 1023 class SingleStepOperation : public Operation 1024 { 1025 public: 1026 SingleStepOperation(lldb::tid_t tid, uint32_t signo, bool &result) 1027 : m_tid(tid), m_signo(signo), m_result(result) { } 1028 1029 void Execute(NativeProcessLinux *monitor); 1030 1031 private: 1032 lldb::tid_t m_tid; 1033 uint32_t m_signo; 1034 bool &m_result; 1035 }; 1036 1037 void 1038 SingleStepOperation::Execute(NativeProcessLinux *monitor) 1039 { 1040 intptr_t data = 0; 1041 1042 if (m_signo != LLDB_INVALID_SIGNAL_NUMBER) 1043 data = m_signo; 1044 1045 if (PTRACE(PTRACE_SINGLESTEP, m_tid, NULL, (void*)data, 0)) 1046 m_result = false; 1047 else 1048 m_result = true; 1049 } 1050 1051 //------------------------------------------------------------------------------ 1052 /// @class SiginfoOperation 1053 /// @brief Implements NativeProcessLinux::GetSignalInfo. 1054 class SiginfoOperation : public Operation 1055 { 1056 public: 1057 SiginfoOperation(lldb::tid_t tid, void *info, bool &result, int &ptrace_err) 1058 : m_tid(tid), m_info(info), m_result(result), m_err(ptrace_err) { } 1059 1060 void Execute(NativeProcessLinux *monitor); 1061 1062 private: 1063 lldb::tid_t m_tid; 1064 void *m_info; 1065 bool &m_result; 1066 int &m_err; 1067 }; 1068 1069 void 1070 SiginfoOperation::Execute(NativeProcessLinux *monitor) 1071 { 1072 if (PTRACE(PTRACE_GETSIGINFO, m_tid, NULL, m_info, 0)) { 1073 m_result = false; 1074 m_err = errno; 1075 } 1076 else 1077 m_result = true; 1078 } 1079 1080 //------------------------------------------------------------------------------ 1081 /// @class EventMessageOperation 1082 /// @brief Implements NativeProcessLinux::GetEventMessage. 1083 class EventMessageOperation : public Operation 1084 { 1085 public: 1086 EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result) 1087 : m_tid(tid), m_message(message), m_result(result) { } 1088 1089 void Execute(NativeProcessLinux *monitor); 1090 1091 private: 1092 lldb::tid_t m_tid; 1093 unsigned long *m_message; 1094 bool &m_result; 1095 }; 1096 1097 void 1098 EventMessageOperation::Execute(NativeProcessLinux *monitor) 1099 { 1100 if (PTRACE(PTRACE_GETEVENTMSG, m_tid, NULL, m_message, 0)) 1101 m_result = false; 1102 else 1103 m_result = true; 1104 } 1105 1106 class DetachOperation : public Operation 1107 { 1108 public: 1109 DetachOperation(lldb::tid_t tid, Error &result) : m_tid(tid), m_error(result) { } 1110 1111 void Execute(NativeProcessLinux *monitor); 1112 1113 private: 1114 lldb::tid_t m_tid; 1115 Error &m_error; 1116 }; 1117 1118 void 1119 DetachOperation::Execute(NativeProcessLinux *monitor) 1120 { 1121 if (ptrace(PT_DETACH, m_tid, NULL, 0) < 0) 1122 m_error.SetErrorToErrno(); 1123 } 1124 1125 } 1126 1127 using namespace lldb_private; 1128 1129 // Simple helper function to ensure flags are enabled on the given file 1130 // descriptor. 1131 static bool 1132 EnsureFDFlags(int fd, int flags, Error &error) 1133 { 1134 int status; 1135 1136 if ((status = fcntl(fd, F_GETFL)) == -1) 1137 { 1138 error.SetErrorToErrno(); 1139 return false; 1140 } 1141 1142 if (fcntl(fd, F_SETFL, status | flags) == -1) 1143 { 1144 error.SetErrorToErrno(); 1145 return false; 1146 } 1147 1148 return true; 1149 } 1150 1151 NativeProcessLinux::OperationArgs::OperationArgs(NativeProcessLinux *monitor) 1152 : m_monitor(monitor) 1153 { 1154 sem_init(&m_semaphore, 0, 0); 1155 } 1156 1157 NativeProcessLinux::OperationArgs::~OperationArgs() 1158 { 1159 sem_destroy(&m_semaphore); 1160 } 1161 1162 NativeProcessLinux::LaunchArgs::LaunchArgs(NativeProcessLinux *monitor, 1163 lldb_private::Module *module, 1164 char const **argv, 1165 char const **envp, 1166 const std::string &stdin_path, 1167 const std::string &stdout_path, 1168 const std::string &stderr_path, 1169 const char *working_dir, 1170 const lldb_private::ProcessLaunchInfo &launch_info) 1171 : OperationArgs(monitor), 1172 m_module(module), 1173 m_argv(argv), 1174 m_envp(envp), 1175 m_stdin_path(stdin_path), 1176 m_stdout_path(stdout_path), 1177 m_stderr_path(stderr_path), 1178 m_working_dir(working_dir), 1179 m_launch_info(launch_info) 1180 { 1181 } 1182 1183 NativeProcessLinux::LaunchArgs::~LaunchArgs() 1184 { } 1185 1186 NativeProcessLinux::AttachArgs::AttachArgs(NativeProcessLinux *monitor, 1187 lldb::pid_t pid) 1188 : OperationArgs(monitor), m_pid(pid) { } 1189 1190 NativeProcessLinux::AttachArgs::~AttachArgs() 1191 { } 1192 1193 // ----------------------------------------------------------------------------- 1194 // Public Static Methods 1195 // ----------------------------------------------------------------------------- 1196 1197 lldb_private::Error 1198 NativeProcessLinux::LaunchProcess ( 1199 lldb_private::Module *exe_module, 1200 lldb_private::ProcessLaunchInfo &launch_info, 1201 lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate, 1202 NativeProcessProtocolSP &native_process_sp) 1203 { 1204 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 1205 1206 Error error; 1207 1208 // Verify the working directory is valid if one was specified. 1209 const char* working_dir = launch_info.GetWorkingDirectory (); 1210 if (working_dir) 1211 { 1212 FileSpec working_dir_fs (working_dir, true); 1213 if (!working_dir_fs || working_dir_fs.GetFileType () != FileSpec::eFileTypeDirectory) 1214 { 1215 error.SetErrorStringWithFormat ("No such file or directory: %s", working_dir); 1216 return error; 1217 } 1218 } 1219 1220 const lldb_private::FileAction *file_action; 1221 1222 // Default of NULL will mean to use existing open file descriptors. 1223 std::string stdin_path; 1224 std::string stdout_path; 1225 std::string stderr_path; 1226 1227 file_action = launch_info.GetFileActionForFD (STDIN_FILENO); 1228 if (file_action) 1229 stdin_path = file_action->GetPath (); 1230 1231 file_action = launch_info.GetFileActionForFD (STDOUT_FILENO); 1232 if (file_action) 1233 stdout_path = file_action->GetPath (); 1234 1235 file_action = launch_info.GetFileActionForFD (STDERR_FILENO); 1236 if (file_action) 1237 stderr_path = file_action->GetPath (); 1238 1239 if (log) 1240 { 1241 if (!stdin_path.empty ()) 1242 log->Printf ("NativeProcessLinux::%s setting STDIN to '%s'", __FUNCTION__, stdin_path.c_str ()); 1243 else 1244 log->Printf ("NativeProcessLinux::%s leaving STDIN as is", __FUNCTION__); 1245 1246 if (!stdout_path.empty ()) 1247 log->Printf ("NativeProcessLinux::%s setting STDOUT to '%s'", __FUNCTION__, stdout_path.c_str ()); 1248 else 1249 log->Printf ("NativeProcessLinux::%s leaving STDOUT as is", __FUNCTION__); 1250 1251 if (!stderr_path.empty ()) 1252 log->Printf ("NativeProcessLinux::%s setting STDERR to '%s'", __FUNCTION__, stderr_path.c_str ()); 1253 else 1254 log->Printf ("NativeProcessLinux::%s leaving STDERR as is", __FUNCTION__); 1255 } 1256 1257 // Create the NativeProcessLinux in launch mode. 1258 native_process_sp.reset (new NativeProcessLinux ()); 1259 1260 if (log) 1261 { 1262 int i = 0; 1263 for (const char **args = launch_info.GetArguments ().GetConstArgumentVector (); *args; ++args, ++i) 1264 { 1265 log->Printf ("NativeProcessLinux::%s arg %d: \"%s\"", __FUNCTION__, i, *args ? *args : "nullptr"); 1266 ++i; 1267 } 1268 } 1269 1270 if (!native_process_sp->RegisterNativeDelegate (native_delegate)) 1271 { 1272 native_process_sp.reset (); 1273 error.SetErrorStringWithFormat ("failed to register the native delegate"); 1274 return error; 1275 } 1276 1277 reinterpret_cast<NativeProcessLinux*> (native_process_sp.get ())->LaunchInferior ( 1278 exe_module, 1279 launch_info.GetArguments ().GetConstArgumentVector (), 1280 launch_info.GetEnvironmentEntries ().GetConstArgumentVector (), 1281 stdin_path, 1282 stdout_path, 1283 stderr_path, 1284 working_dir, 1285 launch_info, 1286 error); 1287 1288 if (error.Fail ()) 1289 { 1290 native_process_sp.reset (); 1291 if (log) 1292 log->Printf ("NativeProcessLinux::%s failed to launch process: %s", __FUNCTION__, error.AsCString ()); 1293 return error; 1294 } 1295 1296 launch_info.SetProcessID (native_process_sp->GetID ()); 1297 1298 return error; 1299 } 1300 1301 lldb_private::Error 1302 NativeProcessLinux::AttachToProcess ( 1303 lldb::pid_t pid, 1304 lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate, 1305 NativeProcessProtocolSP &native_process_sp) 1306 { 1307 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 1308 if (log && log->GetMask ().Test (POSIX_LOG_VERBOSE)) 1309 log->Printf ("NativeProcessLinux::%s(pid = %" PRIi64 ")", __FUNCTION__, pid); 1310 1311 // Grab the current platform architecture. This should be Linux, 1312 // since this code is only intended to run on a Linux host. 1313 PlatformSP platform_sp (Platform::GetHostPlatform ()); 1314 if (!platform_sp) 1315 return Error("failed to get a valid default platform"); 1316 1317 // Retrieve the architecture for the running process. 1318 ArchSpec process_arch; 1319 Error error = ResolveProcessArchitecture (pid, *platform_sp.get (), process_arch); 1320 if (!error.Success ()) 1321 return error; 1322 1323 std::shared_ptr<NativeProcessLinux> native_process_linux_sp (new NativeProcessLinux ()); 1324 1325 if (!native_process_linux_sp->RegisterNativeDelegate (native_delegate)) 1326 { 1327 error.SetErrorStringWithFormat ("failed to register the native delegate"); 1328 return error; 1329 } 1330 1331 native_process_linux_sp->AttachToInferior (pid, error); 1332 if (!error.Success ()) 1333 return error; 1334 1335 native_process_sp = native_process_linux_sp; 1336 return error; 1337 } 1338 1339 // ----------------------------------------------------------------------------- 1340 // Public Instance Methods 1341 // ----------------------------------------------------------------------------- 1342 1343 NativeProcessLinux::NativeProcessLinux () : 1344 NativeProcessProtocol (LLDB_INVALID_PROCESS_ID), 1345 m_arch (), 1346 m_operation_thread (), 1347 m_monitor_thread (), 1348 m_operation (nullptr), 1349 m_operation_mutex (), 1350 m_operation_pending (), 1351 m_operation_done (), 1352 m_supports_mem_region (eLazyBoolCalculate), 1353 m_mem_region_cache (), 1354 m_mem_region_cache_mutex (), 1355 m_coordinator_up (new ThreadStateCoordinator (GetThreadLoggerFunction ())), 1356 m_coordinator_thread () 1357 { 1358 } 1359 1360 //------------------------------------------------------------------------------ 1361 /// The basic design of the NativeProcessLinux is built around two threads. 1362 /// 1363 /// One thread (@see SignalThread) simply blocks on a call to waitpid() looking 1364 /// for changes in the debugee state. When a change is detected a 1365 /// ProcessMessage is sent to the associated ProcessLinux instance. This thread 1366 /// "drives" state changes in the debugger. 1367 /// 1368 /// The second thread (@see OperationThread) is responsible for two things 1) 1369 /// launching or attaching to the inferior process, and then 2) servicing 1370 /// operations such as register reads/writes, stepping, etc. See the comments 1371 /// on the Operation class for more info as to why this is needed. 1372 void 1373 NativeProcessLinux::LaunchInferior ( 1374 Module *module, 1375 const char *argv[], 1376 const char *envp[], 1377 const std::string &stdin_path, 1378 const std::string &stdout_path, 1379 const std::string &stderr_path, 1380 const char *working_dir, 1381 const lldb_private::ProcessLaunchInfo &launch_info, 1382 lldb_private::Error &error) 1383 { 1384 if (module) 1385 m_arch = module->GetArchitecture (); 1386 1387 SetState (eStateLaunching); 1388 1389 std::unique_ptr<LaunchArgs> args( 1390 new LaunchArgs( 1391 this, module, argv, envp, 1392 stdin_path, stdout_path, stderr_path, 1393 working_dir, launch_info)); 1394 1395 sem_init (&m_operation_pending, 0, 0); 1396 sem_init (&m_operation_done, 0, 0); 1397 1398 StartLaunchOpThread (args.get(), error); 1399 if (!error.Success ()) 1400 return; 1401 1402 error = StartCoordinatorThread (); 1403 if (!error.Success ()) 1404 return; 1405 1406 WAIT_AGAIN: 1407 // Wait for the operation thread to initialize. 1408 if (sem_wait(&args->m_semaphore)) 1409 { 1410 if (errno == EINTR) 1411 goto WAIT_AGAIN; 1412 else 1413 { 1414 error.SetErrorToErrno(); 1415 return; 1416 } 1417 } 1418 1419 // Check that the launch was a success. 1420 if (!args->m_error.Success()) 1421 { 1422 StopOpThread(); 1423 StopCoordinatorThread (); 1424 error = args->m_error; 1425 return; 1426 } 1427 1428 // Finally, start monitoring the child process for change in state. 1429 m_monitor_thread = Host::StartMonitoringChildProcess( 1430 NativeProcessLinux::MonitorCallback, this, GetID(), true); 1431 if (!m_monitor_thread.IsJoinable()) 1432 { 1433 error.SetErrorToGenericError(); 1434 error.SetErrorString ("Process attach failed to create monitor thread for NativeProcessLinux::MonitorCallback."); 1435 return; 1436 } 1437 } 1438 1439 void 1440 NativeProcessLinux::AttachToInferior (lldb::pid_t pid, lldb_private::Error &error) 1441 { 1442 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 1443 if (log) 1444 log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 ")", __FUNCTION__, pid); 1445 1446 // We can use the Host for everything except the ResolveExecutable portion. 1447 PlatformSP platform_sp = Platform::GetHostPlatform (); 1448 if (!platform_sp) 1449 { 1450 if (log) 1451 log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 "): no default platform set", __FUNCTION__, pid); 1452 error.SetErrorString ("no default platform available"); 1453 return; 1454 } 1455 1456 // Gather info about the process. 1457 ProcessInstanceInfo process_info; 1458 if (!platform_sp->GetProcessInfo (pid, process_info)) 1459 { 1460 if (log) 1461 log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 "): failed to get process info", __FUNCTION__, pid); 1462 error.SetErrorString ("failed to get process info"); 1463 return; 1464 } 1465 1466 // Resolve the executable module 1467 ModuleSP exe_module_sp; 1468 FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths()); 1469 ModuleSpec exe_module_spec(process_info.GetExecutableFile(), HostInfo::GetArchitecture()); 1470 error = platform_sp->ResolveExecutable(exe_module_spec, exe_module_sp, 1471 executable_search_paths.GetSize() ? &executable_search_paths : NULL); 1472 if (!error.Success()) 1473 return; 1474 1475 // Set the architecture to the exe architecture. 1476 m_arch = exe_module_sp->GetArchitecture(); 1477 if (log) 1478 log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 ") detected architecture %s", __FUNCTION__, pid, m_arch.GetArchitectureName ()); 1479 1480 m_pid = pid; 1481 SetState(eStateAttaching); 1482 1483 sem_init (&m_operation_pending, 0, 0); 1484 sem_init (&m_operation_done, 0, 0); 1485 1486 std::unique_ptr<AttachArgs> args (new AttachArgs (this, pid)); 1487 1488 StartAttachOpThread(args.get (), error); 1489 if (!error.Success ()) 1490 return; 1491 1492 error = StartCoordinatorThread (); 1493 if (!error.Success ()) 1494 return; 1495 1496 WAIT_AGAIN: 1497 // Wait for the operation thread to initialize. 1498 if (sem_wait (&args->m_semaphore)) 1499 { 1500 if (errno == EINTR) 1501 goto WAIT_AGAIN; 1502 else 1503 { 1504 error.SetErrorToErrno (); 1505 return; 1506 } 1507 } 1508 1509 // Check that the attach was a success. 1510 if (!args->m_error.Success ()) 1511 { 1512 StopOpThread (); 1513 StopCoordinatorThread (); 1514 error = args->m_error; 1515 return; 1516 } 1517 1518 // Finally, start monitoring the child process for change in state. 1519 m_monitor_thread = Host::StartMonitoringChildProcess ( 1520 NativeProcessLinux::MonitorCallback, this, GetID (), true); 1521 if (!m_monitor_thread.IsJoinable()) 1522 { 1523 error.SetErrorToGenericError (); 1524 error.SetErrorString ("Process attach failed to create monitor thread for NativeProcessLinux::MonitorCallback."); 1525 return; 1526 } 1527 } 1528 1529 NativeProcessLinux::~NativeProcessLinux() 1530 { 1531 StopMonitor(); 1532 } 1533 1534 //------------------------------------------------------------------------------ 1535 // Thread setup and tear down. 1536 1537 void 1538 NativeProcessLinux::StartLaunchOpThread(LaunchArgs *args, Error &error) 1539 { 1540 static const char *g_thread_name = "lldb.process.nativelinux.operation"; 1541 1542 if (m_operation_thread.IsJoinable()) 1543 return; 1544 1545 m_operation_thread = ThreadLauncher::LaunchThread(g_thread_name, LaunchOpThread, args, &error); 1546 } 1547 1548 void * 1549 NativeProcessLinux::LaunchOpThread(void *arg) 1550 { 1551 LaunchArgs *args = static_cast<LaunchArgs*>(arg); 1552 1553 if (!Launch(args)) { 1554 sem_post(&args->m_semaphore); 1555 return NULL; 1556 } 1557 1558 ServeOperation(args); 1559 return NULL; 1560 } 1561 1562 bool 1563 NativeProcessLinux::Launch(LaunchArgs *args) 1564 { 1565 assert (args && "null args"); 1566 if (!args) 1567 return false; 1568 1569 NativeProcessLinux *monitor = args->m_monitor; 1570 assert (monitor && "monitor is NULL"); 1571 if (!monitor) 1572 return false; 1573 1574 const char **argv = args->m_argv; 1575 const char **envp = args->m_envp; 1576 const char *working_dir = args->m_working_dir; 1577 1578 lldb_utility::PseudoTerminal terminal; 1579 const size_t err_len = 1024; 1580 char err_str[err_len]; 1581 lldb::pid_t pid; 1582 NativeThreadProtocolSP thread_sp; 1583 1584 lldb::ThreadSP inferior; 1585 1586 // Propagate the environment if one is not supplied. 1587 if (envp == NULL || envp[0] == NULL) 1588 envp = const_cast<const char **>(environ); 1589 1590 if ((pid = terminal.Fork(err_str, err_len)) == static_cast<lldb::pid_t> (-1)) 1591 { 1592 args->m_error.SetErrorToGenericError(); 1593 args->m_error.SetErrorString("Process fork failed."); 1594 return false; 1595 } 1596 1597 // Recognized child exit status codes. 1598 enum { 1599 ePtraceFailed = 1, 1600 eDupStdinFailed, 1601 eDupStdoutFailed, 1602 eDupStderrFailed, 1603 eChdirFailed, 1604 eExecFailed, 1605 eSetGidFailed 1606 }; 1607 1608 // Child process. 1609 if (pid == 0) 1610 { 1611 // FIXME consider opening a pipe between parent/child and have this forked child 1612 // send log info to parent re: launch status, in place of the log lines removed here. 1613 1614 // Start tracing this child that is about to exec. 1615 if (PTRACE(PTRACE_TRACEME, 0, NULL, NULL, 0) < 0) 1616 exit(ePtraceFailed); 1617 1618 // Do not inherit setgid powers. 1619 if (setgid(getgid()) != 0) 1620 exit(eSetGidFailed); 1621 1622 // Attempt to have our own process group. 1623 if (setpgid(0, 0) != 0) 1624 { 1625 // FIXME log that this failed. This is common. 1626 // Don't allow this to prevent an inferior exec. 1627 } 1628 1629 // Dup file descriptors if needed. 1630 if (!args->m_stdin_path.empty ()) 1631 if (!DupDescriptor(args->m_stdin_path.c_str (), STDIN_FILENO, O_RDONLY)) 1632 exit(eDupStdinFailed); 1633 1634 if (!args->m_stdout_path.empty ()) 1635 if (!DupDescriptor(args->m_stdout_path.c_str (), STDOUT_FILENO, O_WRONLY | O_CREAT)) 1636 exit(eDupStdoutFailed); 1637 1638 if (!args->m_stderr_path.empty ()) 1639 if (!DupDescriptor(args->m_stderr_path.c_str (), STDERR_FILENO, O_WRONLY | O_CREAT)) 1640 exit(eDupStderrFailed); 1641 1642 // Change working directory 1643 if (working_dir != NULL && working_dir[0]) 1644 if (0 != ::chdir(working_dir)) 1645 exit(eChdirFailed); 1646 1647 // Disable ASLR if requested. 1648 if (args->m_launch_info.GetFlags ().Test (lldb::eLaunchFlagDisableASLR)) 1649 { 1650 const int old_personality = personality (LLDB_PERSONALITY_GET_CURRENT_SETTINGS); 1651 if (old_personality == -1) 1652 { 1653 // Can't retrieve Linux personality. Cannot disable ASLR. 1654 } 1655 else 1656 { 1657 const int new_personality = personality (ADDR_NO_RANDOMIZE | old_personality); 1658 if (new_personality == -1) 1659 { 1660 // Disabling ASLR failed. 1661 } 1662 else 1663 { 1664 // Disabling ASLR succeeded. 1665 } 1666 } 1667 } 1668 1669 // Execute. We should never return... 1670 execve(argv[0], 1671 const_cast<char *const *>(argv), 1672 const_cast<char *const *>(envp)); 1673 1674 // ...unless exec fails. In which case we definitely need to end the child here. 1675 exit(eExecFailed); 1676 } 1677 1678 // 1679 // This is the parent code here. 1680 // 1681 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 1682 1683 // Wait for the child process to trap on its call to execve. 1684 ::pid_t wpid; 1685 int status; 1686 if ((wpid = waitpid(pid, &status, 0)) < 0) 1687 { 1688 args->m_error.SetErrorToErrno(); 1689 1690 if (log) 1691 log->Printf ("NativeProcessLinux::%s waitpid for inferior failed with %s", __FUNCTION__, args->m_error.AsCString ()); 1692 1693 // Mark the inferior as invalid. 1694 // FIXME this could really use a new state - eStateLaunchFailure. For now, using eStateInvalid. 1695 monitor->SetState (StateType::eStateInvalid); 1696 1697 return false; 1698 } 1699 else if (WIFEXITED(status)) 1700 { 1701 // open, dup or execve likely failed for some reason. 1702 args->m_error.SetErrorToGenericError(); 1703 switch (WEXITSTATUS(status)) 1704 { 1705 case ePtraceFailed: 1706 args->m_error.SetErrorString("Child ptrace failed."); 1707 break; 1708 case eDupStdinFailed: 1709 args->m_error.SetErrorString("Child open stdin failed."); 1710 break; 1711 case eDupStdoutFailed: 1712 args->m_error.SetErrorString("Child open stdout failed."); 1713 break; 1714 case eDupStderrFailed: 1715 args->m_error.SetErrorString("Child open stderr failed."); 1716 break; 1717 case eChdirFailed: 1718 args->m_error.SetErrorString("Child failed to set working directory."); 1719 break; 1720 case eExecFailed: 1721 args->m_error.SetErrorString("Child exec failed."); 1722 break; 1723 case eSetGidFailed: 1724 args->m_error.SetErrorString("Child setgid failed."); 1725 break; 1726 default: 1727 args->m_error.SetErrorString("Child returned unknown exit status."); 1728 break; 1729 } 1730 1731 if (log) 1732 { 1733 log->Printf ("NativeProcessLinux::%s inferior exited with status %d before issuing a STOP", 1734 __FUNCTION__, 1735 WEXITSTATUS(status)); 1736 } 1737 1738 // Mark the inferior as invalid. 1739 // FIXME this could really use a new state - eStateLaunchFailure. For now, using eStateInvalid. 1740 monitor->SetState (StateType::eStateInvalid); 1741 1742 return false; 1743 } 1744 assert(WIFSTOPPED(status) && (wpid == static_cast< ::pid_t> (pid)) && 1745 "Could not sync with inferior process."); 1746 1747 if (log) 1748 log->Printf ("NativeProcessLinux::%s inferior started, now in stopped state", __FUNCTION__); 1749 1750 if (!SetDefaultPtraceOpts(pid)) 1751 { 1752 args->m_error.SetErrorToErrno(); 1753 if (log) 1754 log->Printf ("NativeProcessLinux::%s inferior failed to set default ptrace options: %s", 1755 __FUNCTION__, 1756 args->m_error.AsCString ()); 1757 1758 // Mark the inferior as invalid. 1759 // FIXME this could really use a new state - eStateLaunchFailure. For now, using eStateInvalid. 1760 monitor->SetState (StateType::eStateInvalid); 1761 1762 return false; 1763 } 1764 1765 // Release the master terminal descriptor and pass it off to the 1766 // NativeProcessLinux instance. Similarly stash the inferior pid. 1767 monitor->m_terminal_fd = terminal.ReleaseMasterFileDescriptor(); 1768 monitor->m_pid = pid; 1769 1770 // Set the terminal fd to be in non blocking mode (it simplifies the 1771 // implementation of ProcessLinux::GetSTDOUT to have a non-blocking 1772 // descriptor to read from). 1773 if (!EnsureFDFlags(monitor->m_terminal_fd, O_NONBLOCK, args->m_error)) 1774 { 1775 if (log) 1776 log->Printf ("NativeProcessLinux::%s inferior EnsureFDFlags failed for ensuring terminal O_NONBLOCK setting: %s", 1777 __FUNCTION__, 1778 args->m_error.AsCString ()); 1779 1780 // Mark the inferior as invalid. 1781 // FIXME this could really use a new state - eStateLaunchFailure. For now, using eStateInvalid. 1782 monitor->SetState (StateType::eStateInvalid); 1783 1784 return false; 1785 } 1786 1787 if (log) 1788 log->Printf ("NativeProcessLinux::%s() adding pid = %" PRIu64, __FUNCTION__, pid); 1789 1790 thread_sp = monitor->AddThread (pid); 1791 assert (thread_sp && "AddThread() returned a nullptr thread"); 1792 monitor->NotifyThreadCreateStopped (pid); 1793 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGSTOP); 1794 1795 // Let our process instance know the thread has stopped. 1796 monitor->SetCurrentThreadID (thread_sp->GetID ()); 1797 monitor->SetState (StateType::eStateStopped); 1798 1799 if (log) 1800 { 1801 if (args->m_error.Success ()) 1802 { 1803 log->Printf ("NativeProcessLinux::%s inferior launching succeeded", __FUNCTION__); 1804 } 1805 else 1806 { 1807 log->Printf ("NativeProcessLinux::%s inferior launching failed: %s", 1808 __FUNCTION__, 1809 args->m_error.AsCString ()); 1810 } 1811 } 1812 return args->m_error.Success(); 1813 } 1814 1815 void 1816 NativeProcessLinux::StartAttachOpThread(AttachArgs *args, lldb_private::Error &error) 1817 { 1818 static const char *g_thread_name = "lldb.process.linux.operation"; 1819 1820 if (m_operation_thread.IsJoinable()) 1821 return; 1822 1823 m_operation_thread = ThreadLauncher::LaunchThread(g_thread_name, AttachOpThread, args, &error); 1824 } 1825 1826 void * 1827 NativeProcessLinux::AttachOpThread(void *arg) 1828 { 1829 AttachArgs *args = static_cast<AttachArgs*>(arg); 1830 1831 if (!Attach(args)) { 1832 sem_post(&args->m_semaphore); 1833 return nullptr; 1834 } 1835 1836 ServeOperation(args); 1837 return nullptr; 1838 } 1839 1840 bool 1841 NativeProcessLinux::Attach(AttachArgs *args) 1842 { 1843 lldb::pid_t pid = args->m_pid; 1844 1845 NativeProcessLinux *monitor = args->m_monitor; 1846 lldb::ThreadSP inferior; 1847 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 1848 1849 // Use a map to keep track of the threads which we have attached/need to attach. 1850 Host::TidMap tids_to_attach; 1851 if (pid <= 1) 1852 { 1853 args->m_error.SetErrorToGenericError(); 1854 args->m_error.SetErrorString("Attaching to process 1 is not allowed."); 1855 goto FINISH; 1856 } 1857 1858 while (Host::FindProcessThreads(pid, tids_to_attach)) 1859 { 1860 for (Host::TidMap::iterator it = tids_to_attach.begin(); 1861 it != tids_to_attach.end();) 1862 { 1863 if (it->second == false) 1864 { 1865 lldb::tid_t tid = it->first; 1866 1867 // Attach to the requested process. 1868 // An attach will cause the thread to stop with a SIGSTOP. 1869 if (PTRACE(PTRACE_ATTACH, tid, NULL, NULL, 0) < 0) 1870 { 1871 // No such thread. The thread may have exited. 1872 // More error handling may be needed. 1873 if (errno == ESRCH) 1874 { 1875 it = tids_to_attach.erase(it); 1876 continue; 1877 } 1878 else 1879 { 1880 args->m_error.SetErrorToErrno(); 1881 goto FINISH; 1882 } 1883 } 1884 1885 int status; 1886 // Need to use __WALL otherwise we receive an error with errno=ECHLD 1887 // At this point we should have a thread stopped if waitpid succeeds. 1888 if ((status = waitpid(tid, NULL, __WALL)) < 0) 1889 { 1890 // No such thread. The thread may have exited. 1891 // More error handling may be needed. 1892 if (errno == ESRCH) 1893 { 1894 it = tids_to_attach.erase(it); 1895 continue; 1896 } 1897 else 1898 { 1899 args->m_error.SetErrorToErrno(); 1900 goto FINISH; 1901 } 1902 } 1903 1904 if (!SetDefaultPtraceOpts(tid)) 1905 { 1906 args->m_error.SetErrorToErrno(); 1907 goto FINISH; 1908 } 1909 1910 1911 if (log) 1912 log->Printf ("NativeProcessLinux::%s() adding tid = %" PRIu64, __FUNCTION__, tid); 1913 1914 it->second = true; 1915 1916 // Create the thread, mark it as stopped. 1917 NativeThreadProtocolSP thread_sp (monitor->AddThread (static_cast<lldb::tid_t> (tid))); 1918 assert (thread_sp && "AddThread() returned a nullptr"); 1919 1920 // This will notify this is a new thread and tell the system it is stopped. 1921 monitor->NotifyThreadCreateStopped (tid); 1922 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGSTOP); 1923 monitor->SetCurrentThreadID (thread_sp->GetID ()); 1924 } 1925 1926 // move the loop forward 1927 ++it; 1928 } 1929 } 1930 1931 if (tids_to_attach.size() > 0) 1932 { 1933 monitor->m_pid = pid; 1934 // Let our process instance know the thread has stopped. 1935 monitor->SetState (StateType::eStateStopped); 1936 } 1937 else 1938 { 1939 args->m_error.SetErrorToGenericError(); 1940 args->m_error.SetErrorString("No such process."); 1941 } 1942 1943 FINISH: 1944 return args->m_error.Success(); 1945 } 1946 1947 bool 1948 NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid) 1949 { 1950 long ptrace_opts = 0; 1951 1952 // Have the child raise an event on exit. This is used to keep the child in 1953 // limbo until it is destroyed. 1954 ptrace_opts |= PTRACE_O_TRACEEXIT; 1955 1956 // Have the tracer trace threads which spawn in the inferior process. 1957 // TODO: if we want to support tracing the inferiors' child, add the 1958 // appropriate ptrace flags here (PTRACE_O_TRACEFORK, PTRACE_O_TRACEVFORK) 1959 ptrace_opts |= PTRACE_O_TRACECLONE; 1960 1961 // Have the tracer notify us before execve returns 1962 // (needed to disable legacy SIGTRAP generation) 1963 ptrace_opts |= PTRACE_O_TRACEEXEC; 1964 1965 return PTRACE(PTRACE_SETOPTIONS, pid, NULL, (void*)ptrace_opts, 0) >= 0; 1966 } 1967 1968 static ExitType convert_pid_status_to_exit_type (int status) 1969 { 1970 if (WIFEXITED (status)) 1971 return ExitType::eExitTypeExit; 1972 else if (WIFSIGNALED (status)) 1973 return ExitType::eExitTypeSignal; 1974 else if (WIFSTOPPED (status)) 1975 return ExitType::eExitTypeStop; 1976 else 1977 { 1978 // We don't know what this is. 1979 return ExitType::eExitTypeInvalid; 1980 } 1981 } 1982 1983 static int convert_pid_status_to_return_code (int status) 1984 { 1985 if (WIFEXITED (status)) 1986 return WEXITSTATUS (status); 1987 else if (WIFSIGNALED (status)) 1988 return WTERMSIG (status); 1989 else if (WIFSTOPPED (status)) 1990 return WSTOPSIG (status); 1991 else 1992 { 1993 // We don't know what this is. 1994 return ExitType::eExitTypeInvalid; 1995 } 1996 } 1997 1998 // Main process monitoring waitpid-loop handler. 1999 bool 2000 NativeProcessLinux::MonitorCallback(void *callback_baton, 2001 lldb::pid_t pid, 2002 bool exited, 2003 int signal, 2004 int status) 2005 { 2006 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS)); 2007 2008 NativeProcessLinux *const process = static_cast<NativeProcessLinux*>(callback_baton); 2009 assert (process && "process is null"); 2010 if (!process) 2011 { 2012 if (log) 2013 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " callback_baton was null, can't determine process to use", __FUNCTION__, pid); 2014 return true; 2015 } 2016 2017 // Certain activities differ based on whether the pid is the tid of the main thread. 2018 const bool is_main_thread = (pid == process->GetID ()); 2019 2020 // Assume we keep monitoring by default. 2021 bool stop_monitoring = false; 2022 2023 // Handle when the thread exits. 2024 if (exited) 2025 { 2026 if (log) 2027 log->Printf ("NativeProcessLinux::%s() got exit signal, tid = %" PRIu64 " (%s main thread)", __FUNCTION__, pid, is_main_thread ? "is" : "is not"); 2028 2029 // This is a thread that exited. Ensure we're not tracking it anymore. 2030 const bool thread_found = process->StopTrackingThread (pid); 2031 2032 // Make sure the thread state coordinator knows about this. 2033 process->NotifyThreadDeath (pid); 2034 2035 if (is_main_thread) 2036 { 2037 // We only set the exit status and notify the delegate if we haven't already set the process 2038 // state to an exited state. We normally should have received a SIGTRAP | (PTRACE_EVENT_EXIT << 8) 2039 // for the main thread. 2040 const bool already_notified = (process->GetState() == StateType::eStateExited) || (process->GetState () == StateType::eStateCrashed); 2041 if (!already_notified) 2042 { 2043 if (log) 2044 log->Printf ("NativeProcessLinux::%s() tid = %" PRIu64 " handling main thread exit (%s), expected exit state already set but state was %s instead, setting exit state now", __FUNCTION__, pid, thread_found ? "stopped tracking thread metadata" : "thread metadata not found", StateAsCString (process->GetState ())); 2045 // The main thread exited. We're done monitoring. Report to delegate. 2046 process->SetExitStatus (convert_pid_status_to_exit_type (status), convert_pid_status_to_return_code (status), nullptr, true); 2047 2048 // Notify delegate that our process has exited. 2049 process->SetState (StateType::eStateExited, true); 2050 } 2051 else 2052 { 2053 if (log) 2054 log->Printf ("NativeProcessLinux::%s() tid = %" PRIu64 " main thread now exited (%s)", __FUNCTION__, pid, thread_found ? "stopped tracking thread metadata" : "thread metadata not found"); 2055 } 2056 return true; 2057 } 2058 else 2059 { 2060 // Do we want to report to the delegate in this case? I think not. If this was an orderly 2061 // thread exit, we would already have received the SIGTRAP | (PTRACE_EVENT_EXIT << 8) signal, 2062 // and we would have done an all-stop then. 2063 if (log) 2064 log->Printf ("NativeProcessLinux::%s() tid = %" PRIu64 " handling non-main thread exit (%s)", __FUNCTION__, pid, thread_found ? "stopped tracking thread metadata" : "thread metadata not found"); 2065 2066 // Not the main thread, we keep going. 2067 return false; 2068 } 2069 } 2070 2071 // Get details on the signal raised. 2072 siginfo_t info; 2073 int ptrace_err = 0; 2074 2075 if (process->GetSignalInfo (pid, &info, ptrace_err)) 2076 { 2077 // We have retrieved the signal info. Dispatch appropriately. 2078 if (info.si_signo == SIGTRAP) 2079 process->MonitorSIGTRAP(&info, pid); 2080 else 2081 process->MonitorSignal(&info, pid, exited); 2082 2083 stop_monitoring = false; 2084 } 2085 else 2086 { 2087 if (ptrace_err == EINVAL) 2088 { 2089 // This is a group stop reception for this tid. 2090 if (log) 2091 log->Printf ("NativeThreadLinux::%s received a group stop for pid %" PRIu64 " tid %" PRIu64, __FUNCTION__, process->GetID (), pid); 2092 process->NotifyThreadStop (pid); 2093 } 2094 else 2095 { 2096 // ptrace(GETSIGINFO) failed (but not due to group-stop). 2097 2098 // A return value of ESRCH means the thread/process is no longer on the system, 2099 // so it was killed somehow outside of our control. Either way, we can't do anything 2100 // with it anymore. 2101 2102 // We stop monitoring if it was the main thread. 2103 stop_monitoring = is_main_thread; 2104 2105 // Stop tracking the metadata for the thread since it's entirely off the system now. 2106 const bool thread_found = process->StopTrackingThread (pid); 2107 2108 // Make sure the thread state coordinator knows about this. 2109 process->NotifyThreadDeath (pid); 2110 2111 if (log) 2112 log->Printf ("NativeProcessLinux::%s GetSignalInfo failed: %s, tid = %" PRIu64 ", signal = %d, status = %d (%s, %s, %s)", 2113 __FUNCTION__, strerror(ptrace_err), pid, signal, status, ptrace_err == ESRCH ? "thread/process killed" : "unknown reason", is_main_thread ? "is main thread" : "is not main thread", thread_found ? "thread metadata removed" : "thread metadata not found"); 2114 2115 if (is_main_thread) 2116 { 2117 // Notify the delegate - our process is not available but appears to have been killed outside 2118 // our control. Is eStateExited the right exit state in this case? 2119 process->SetExitStatus (convert_pid_status_to_exit_type (status), convert_pid_status_to_return_code (status), nullptr, true); 2120 process->SetState (StateType::eStateExited, true); 2121 } 2122 else 2123 { 2124 // This thread was pulled out from underneath us. Anything to do here? Do we want to do an all stop? 2125 if (log) 2126 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 " non-main thread exit occurred, didn't tell delegate anything since thread disappeared out from underneath us", __FUNCTION__, process->GetID (), pid); 2127 } 2128 } 2129 } 2130 2131 return stop_monitoring; 2132 } 2133 2134 void 2135 NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid) 2136 { 2137 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2138 const bool is_main_thread = (pid == GetID ()); 2139 2140 assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!"); 2141 if (!info) 2142 return; 2143 2144 // See if we can find a thread for this signal. 2145 NativeThreadProtocolSP thread_sp = GetThreadByID (pid); 2146 if (!thread_sp) 2147 { 2148 if (log) 2149 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " no thread found for tid %" PRIu64, __FUNCTION__, GetID (), pid); 2150 } 2151 2152 switch (info->si_code) 2153 { 2154 // TODO: these two cases are required if we want to support tracing of the inferiors' children. We'd need this to debug a monitor. 2155 // case (SIGTRAP | (PTRACE_EVENT_FORK << 8)): 2156 // case (SIGTRAP | (PTRACE_EVENT_VFORK << 8)): 2157 2158 case (SIGTRAP | (PTRACE_EVENT_CLONE << 8)): 2159 { 2160 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 2161 2162 // The main thread is stopped here. 2163 if (thread_sp) 2164 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGTRAP); 2165 NotifyThreadStop (pid); 2166 2167 unsigned long event_message = 0; 2168 if (GetEventMessage (pid, &event_message)) 2169 { 2170 tid = static_cast<lldb::tid_t> (event_message); 2171 if (log) 2172 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " received thread creation event for tid %" PRIu64, __FUNCTION__, pid, tid); 2173 2174 // If we don't track the thread yet: create it, mark as stopped. 2175 // If we do track it, this is the wait we needed. Now resume the new thread. 2176 // In all cases, resume the current (i.e. main process) thread. 2177 bool created_now = false; 2178 NativeThreadProtocolSP new_thread_sp = GetOrCreateThread (tid, created_now); 2179 assert (new_thread_sp.get() && "failed to get or create the tracking data for newly created inferior thread"); 2180 2181 // If the thread was already tracked, it means the created thread already received its SI_USER notification of creation. 2182 if (!created_now) 2183 { 2184 // We can now resume the newly created thread since it is fully created. 2185 NotifyThreadCreateStopped (tid); 2186 m_coordinator_up->RequestThreadResume (tid, 2187 [=](lldb::tid_t tid_to_resume) 2188 { 2189 reinterpret_cast<NativeThreadLinux*> (new_thread_sp.get ())->SetRunning (); 2190 Resume (tid_to_resume, LLDB_INVALID_SIGNAL_NUMBER); 2191 }, 2192 CoordinatorErrorHandler); 2193 } 2194 else 2195 { 2196 // Mark the thread as currently launching. Need to wait for SIGTRAP clone on the main thread before 2197 // this thread is ready to go. 2198 reinterpret_cast<NativeThreadLinux*> (new_thread_sp.get ())->SetLaunching (); 2199 } 2200 } 2201 else 2202 { 2203 if (log) 2204 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " received thread creation event but GetEventMessage failed so we don't know the new tid", __FUNCTION__, pid); 2205 } 2206 2207 // In all cases, we can resume the main thread here. 2208 m_coordinator_up->RequestThreadResume (pid, 2209 [=](lldb::tid_t tid_to_resume) 2210 { 2211 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2212 Resume (tid_to_resume, LLDB_INVALID_SIGNAL_NUMBER); 2213 }, 2214 CoordinatorErrorHandler); 2215 2216 break; 2217 } 2218 2219 case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)): 2220 { 2221 NativeThreadProtocolSP main_thread_sp; 2222 if (log) 2223 log->Printf ("NativeProcessLinux::%s() received exec event, code = %d", __FUNCTION__, info->si_code ^ SIGTRAP); 2224 2225 // The thread state coordinator needs to reset due to the exec. 2226 m_coordinator_up->ResetForExec (); 2227 2228 // Remove all but the main thread here. Linux fork creates a new process which only copies the main thread. Mutexes are in undefined state. 2229 { 2230 Mutex::Locker locker (m_threads_mutex); 2231 2232 if (log) 2233 log->Printf ("NativeProcessLinux::%s exec received, stop tracking all but main thread", __FUNCTION__); 2234 2235 for (auto thread_sp : m_threads) 2236 { 2237 const bool is_main_thread = thread_sp && thread_sp->GetID () == GetID (); 2238 if (is_main_thread) 2239 { 2240 main_thread_sp = thread_sp; 2241 if (log) 2242 log->Printf ("NativeProcessLinux::%s found main thread with tid %" PRIu64 ", keeping", __FUNCTION__, main_thread_sp->GetID ()); 2243 } 2244 else 2245 { 2246 // Tell thread coordinator this thread is dead. 2247 if (log) 2248 log->Printf ("NativeProcessLinux::%s discarding non-main-thread tid %" PRIu64 " due to exec", __FUNCTION__, thread_sp->GetID ()); 2249 } 2250 } 2251 2252 m_threads.clear (); 2253 2254 if (main_thread_sp) 2255 { 2256 m_threads.push_back (main_thread_sp); 2257 SetCurrentThreadID (main_thread_sp->GetID ()); 2258 reinterpret_cast<NativeThreadLinux*>(main_thread_sp.get())->SetStoppedByExec (); 2259 } 2260 else 2261 { 2262 SetCurrentThreadID (LLDB_INVALID_THREAD_ID); 2263 if (log) 2264 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 "no main thread found, discarded all threads, we're in a no-thread state!", __FUNCTION__, GetID ()); 2265 } 2266 } 2267 2268 // Tell coordinator about about the "new" (since exec) stopped main thread. 2269 const lldb::tid_t main_thread_tid = GetID (); 2270 NotifyThreadCreateStopped (main_thread_tid); 2271 2272 // NOTE: ideally these next statements would execute at the same time as the coordinator thread create was executed. 2273 // Consider a handler that can execute when that happens. 2274 // Let our delegate know we have just exec'd. 2275 NotifyDidExec (); 2276 2277 // If we have a main thread, indicate we are stopped. 2278 assert (main_thread_sp && "exec called during ptraced process but no main thread metadata tracked"); 2279 2280 // Let the process know we're stopped. 2281 SetState (StateType::eStateStopped); 2282 2283 break; 2284 } 2285 2286 case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)): 2287 { 2288 // The inferior process or one of its threads is about to exit. 2289 2290 // This thread is currently stopped. It's not actually dead yet, just about to be. 2291 NotifyThreadStop (pid); 2292 2293 unsigned long data = 0; 2294 if (!GetEventMessage(pid, &data)) 2295 data = -1; 2296 2297 if (log) 2298 { 2299 log->Printf ("NativeProcessLinux::%s() received PTRACE_EVENT_EXIT, data = %lx (WIFEXITED=%s,WIFSIGNALED=%s), pid = %" PRIu64 " (%s)", 2300 __FUNCTION__, 2301 data, WIFEXITED (data) ? "true" : "false", WIFSIGNALED (data) ? "true" : "false", 2302 pid, 2303 is_main_thread ? "is main thread" : "not main thread"); 2304 } 2305 2306 // We'll set the thread to exited later... 2307 // if (thread_sp) 2308 // reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetExited (); 2309 // else 2310 // { 2311 // if (log) 2312 // log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " failed to retrieve thread for tid %" PRIu64", cannot set thread state", __FUNCTION__, GetID (), pid); 2313 // } 2314 2315 // FIXME: review if this is the spot, or the follow up, which tells us the real exit code. 2316 // If it's this one, we need to track it or set it here. Setting it here is not really in the 2317 // right time flow though unless we skip the follow up. 2318 if (is_main_thread) 2319 { 2320 SetExitStatus (convert_pid_status_to_exit_type (data), convert_pid_status_to_return_code (data), nullptr, true); 2321 } 2322 2323 m_coordinator_up->RequestThreadResume (pid, 2324 [=](lldb::tid_t tid_to_resume) 2325 { 2326 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2327 Resume (tid_to_resume, LLDB_INVALID_SIGNAL_NUMBER); 2328 }, 2329 CoordinatorErrorHandler); 2330 2331 break; 2332 } 2333 2334 case 0: 2335 case TRAP_TRACE: 2336 // We receive this on single stepping. 2337 if (log) 2338 log->Printf ("NativeProcessLinux::%s() received trace event, pid = %" PRIu64 " (single stepping)", __FUNCTION__, pid); 2339 2340 // This thread is currently stopped. 2341 NotifyThreadStop (pid); 2342 2343 if (thread_sp) 2344 { 2345 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGTRAP); 2346 } 2347 else 2348 { 2349 if (log) 2350 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 " single stepping received trace but thread not found", __FUNCTION__, GetID (), pid); 2351 } 2352 2353 // We need to tell all other running threads before we notify the delegate about this stop. 2354 CallAfterRunningThreadsStop (pid, 2355 [=](lldb::tid_t deferred_notification_tid) 2356 { 2357 SetCurrentThreadID (deferred_notification_tid); 2358 // Tell the process we have a stop (from single stepping). 2359 SetState (StateType::eStateStopped, true); 2360 }); 2361 break; 2362 2363 case SI_KERNEL: 2364 case TRAP_BRKPT: 2365 if (log) 2366 log->Printf ("NativeProcessLinux::%s() received breakpoint event, pid = %" PRIu64, __FUNCTION__, pid); 2367 2368 // This thread is currently stopped. 2369 NotifyThreadStop (pid); 2370 2371 // Mark the thread as stopped at breakpoint. 2372 if (thread_sp) 2373 { 2374 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGTRAP); 2375 Error error = FixupBreakpointPCAsNeeded (thread_sp); 2376 if (error.Fail ()) 2377 { 2378 if (log) 2379 log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 " fixup: %s", __FUNCTION__, pid, error.AsCString ()); 2380 } 2381 } 2382 else 2383 { 2384 if (log) 2385 log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 ": warning, cannot process software breakpoint since no thread metadata", __FUNCTION__, pid); 2386 } 2387 2388 2389 // We need to tell all other running threads before we notify the delegate about this stop. 2390 CallAfterRunningThreadsStop (pid, 2391 [=](lldb::tid_t deferred_notification_tid) 2392 { 2393 SetCurrentThreadID (deferred_notification_tid); 2394 // Tell the process we have a stop (from software breakpoint). 2395 SetState (StateType::eStateStopped, true); 2396 }); 2397 break; 2398 2399 case TRAP_HWBKPT: 2400 if (log) 2401 log->Printf ("NativeProcessLinux::%s() received watchpoint event, pid = %" PRIu64, __FUNCTION__, pid); 2402 2403 // This thread is currently stopped. 2404 NotifyThreadStop (pid); 2405 2406 // Mark the thread as stopped at watchpoint. 2407 // The address is at (lldb::addr_t)info->si_addr if we need it. 2408 if (thread_sp) 2409 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGTRAP); 2410 else 2411 { 2412 if (log) 2413 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 ": warning, cannot process hardware breakpoint since no thread metadata", __FUNCTION__, GetID (), pid); 2414 } 2415 2416 // We need to tell all other running threads before we notify the delegate about this stop. 2417 CallAfterRunningThreadsStop (pid, 2418 [=](lldb::tid_t deferred_notification_tid) 2419 { 2420 SetCurrentThreadID (deferred_notification_tid); 2421 // Tell the process we have a stop (from hardware breakpoint). 2422 SetState (StateType::eStateStopped, true); 2423 }); 2424 break; 2425 2426 case SIGTRAP: 2427 case (SIGTRAP | 0x80): 2428 if (log) 2429 log->Printf ("NativeProcessLinux::%s() received unknown SIGTRAP system call stop event, pid %" PRIu64 "tid %" PRIu64 ", resuming", __FUNCTION__, GetID (), pid); 2430 2431 // This thread is currently stopped. 2432 NotifyThreadStop (pid); 2433 if (thread_sp) 2434 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGTRAP); 2435 2436 2437 // Ignore these signals until we know more about them. 2438 m_coordinator_up->RequestThreadResume (pid, 2439 [=](lldb::tid_t tid_to_resume) 2440 { 2441 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2442 Resume (tid_to_resume, LLDB_INVALID_SIGNAL_NUMBER); 2443 }, 2444 CoordinatorErrorHandler); 2445 break; 2446 2447 default: 2448 assert(false && "Unexpected SIGTRAP code!"); 2449 if (log) 2450 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 "tid %" PRIu64 " received unhandled SIGTRAP code: 0x%" PRIx64, __FUNCTION__, GetID (), pid, static_cast<uint64_t> (SIGTRAP | (PTRACE_EVENT_CLONE << 8))); 2451 break; 2452 2453 } 2454 } 2455 2456 void 2457 NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited) 2458 { 2459 assert (info && "null info"); 2460 if (!info) 2461 return; 2462 2463 const int signo = info->si_signo; 2464 const bool is_from_llgs = info->si_pid == getpid (); 2465 2466 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2467 2468 // POSIX says that process behaviour is undefined after it ignores a SIGFPE, 2469 // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a 2470 // kill(2) or raise(3). Similarly for tgkill(2) on Linux. 2471 // 2472 // IOW, user generated signals never generate what we consider to be a 2473 // "crash". 2474 // 2475 // Similarly, ACK signals generated by this monitor. 2476 2477 // See if we can find a thread for this signal. 2478 NativeThreadProtocolSP thread_sp = GetThreadByID (pid); 2479 if (!thread_sp) 2480 { 2481 if (log) 2482 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " no thread found for tid %" PRIu64, __FUNCTION__, GetID (), pid); 2483 } 2484 2485 // Handle the signal. 2486 if (info->si_code == SI_TKILL || info->si_code == SI_USER) 2487 { 2488 if (log) 2489 log->Printf ("NativeProcessLinux::%s() received signal %s (%d) with code %s, (siginfo pid = %d (%s), waitpid pid = %" PRIu64 ")", 2490 __FUNCTION__, 2491 GetUnixSignals ().GetSignalAsCString (signo), 2492 signo, 2493 (info->si_code == SI_TKILL ? "SI_TKILL" : "SI_USER"), 2494 info->si_pid, 2495 is_from_llgs ? "from llgs" : "not from llgs", 2496 pid); 2497 } 2498 2499 // Check for new thread notification. 2500 if ((info->si_pid == 0) && (info->si_code == SI_USER)) 2501 { 2502 // A new thread creation is being signaled. This is one of two parts that come in 2503 // a non-deterministic order. pid is the thread id. 2504 if (log) 2505 log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 " tid %" PRIu64 ": new thread notification", 2506 __FUNCTION__, GetID (), pid); 2507 2508 // Did we already create the thread? 2509 bool created_now = false; 2510 thread_sp = GetOrCreateThread (pid, created_now); 2511 assert (thread_sp.get() && "failed to get or create the tracking data for newly created inferior thread"); 2512 2513 // If the thread was already tracked, it means the main thread already received its SIGTRAP for the create. 2514 if (!created_now) 2515 { 2516 // We can now resume the newly created thread since it is fully created. 2517 NotifyThreadCreateStopped (pid); 2518 m_coordinator_up->RequestThreadResume (pid, 2519 [=](lldb::tid_t tid_to_resume) 2520 { 2521 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2522 Resume (tid_to_resume, LLDB_INVALID_SIGNAL_NUMBER); 2523 }, 2524 CoordinatorErrorHandler); 2525 } 2526 else 2527 { 2528 // Mark the thread as currently launching. Need to wait for SIGTRAP clone on the main thread before 2529 // this thread is ready to go. 2530 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetLaunching (); 2531 } 2532 2533 // Done handling. 2534 return; 2535 } 2536 2537 // Check for thread stop notification. 2538 if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP)) 2539 { 2540 // This is a tgkill()-based stop. 2541 if (thread_sp) 2542 { 2543 if (log) 2544 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 ", thread stopped", 2545 __FUNCTION__, 2546 GetID (), 2547 pid); 2548 2549 // An inferior thread just stopped. Mark it as such. 2550 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (signo); 2551 SetCurrentThreadID (thread_sp->GetID ()); 2552 2553 // Tell the thread state coordinator about the stop. 2554 NotifyThreadStop (thread_sp->GetID ()); 2555 } 2556 2557 // Done handling. 2558 return; 2559 } 2560 2561 if (log) 2562 log->Printf ("NativeProcessLinux::%s() received signal %s", __FUNCTION__, GetUnixSignals ().GetSignalAsCString (signo)); 2563 2564 switch (signo) 2565 { 2566 case SIGSEGV: 2567 case SIGABRT: 2568 case SIGILL: 2569 case SIGFPE: 2570 case SIGBUS: 2571 { 2572 // This thread is stopped. 2573 NotifyThreadStop (pid); 2574 2575 // lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr); 2576 2577 // This is just a pre-signal-delivery notification of the incoming signal. 2578 if (thread_sp) 2579 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (signo); 2580 2581 // We can get more details on the exact nature of the crash here. 2582 // ProcessMessage::CrashReason reason = GetCrashReasonForSIGSEGV(info); 2583 if (!exited) 2584 { 2585 // Send a stop to the debugger after we get all other threads to stop. 2586 CallAfterRunningThreadsStop (pid, 2587 [=] (lldb::tid_t signaling_tid) 2588 { 2589 SetCurrentThreadID (signaling_tid); 2590 SetState (StateType::eStateStopped, true); 2591 }); 2592 } 2593 else 2594 { 2595 // FIXME the process might die right after this - might not ever get stops on any other threads. 2596 // Send a stop to the debugger after we get all other threads to stop. 2597 CallAfterRunningThreadsStop (pid, 2598 [=] (lldb::tid_t signaling_tid) 2599 { 2600 SetCurrentThreadID (signaling_tid); 2601 SetState (StateType::eStateCrashed, true); 2602 }); 2603 } 2604 } 2605 break; 2606 2607 case SIGSTOP: 2608 { 2609 // This thread is stopped. 2610 NotifyThreadStop (pid); 2611 2612 if (log) 2613 { 2614 if (is_from_llgs) 2615 log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " received SIGSTOP from llgs, most likely an interrupt", __FUNCTION__, GetID (), pid); 2616 else 2617 log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " received SIGSTOP from outside of debugger", __FUNCTION__, GetID (), pid); 2618 } 2619 2620 // Resume this thread to get the group-stop mechanism to fire off the true group stops. 2621 // This thread will get stopped again as part of the group-stop completion. 2622 m_coordinator_up->RequestThreadResume (pid, 2623 [=](lldb::tid_t tid_to_resume) 2624 { 2625 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2626 // Pass this signal number on to the inferior to handle. 2627 Resume (tid_to_resume, signo); 2628 }, 2629 CoordinatorErrorHandler); 2630 2631 // And now we want to signal that we received a SIGSTOP on this thread 2632 // as soon as all running threads stop (i.e. the group stop sequence completes). 2633 CallAfterRunningThreadsStop (pid, 2634 [=] (lldb::tid_t signaling_tid) 2635 { 2636 SetCurrentThreadID (signaling_tid); 2637 SetState (StateType::eStateStopped, true); 2638 }); 2639 break; 2640 } 2641 2642 default: 2643 { 2644 // This thread is stopped. 2645 NotifyThreadStop (pid); 2646 2647 if (log) 2648 log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " resuming thread with signal %s (%d)", __FUNCTION__, GetID (), pid, GetUnixSignals().GetSignalAsCString (signo), signo); 2649 2650 // Pass the signal on to the inferior. 2651 m_coordinator_up->RequestThreadResume (pid, 2652 [=](lldb::tid_t tid_to_resume) 2653 { 2654 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2655 // Pass this signal number on to the inferior to handle. 2656 Resume (tid_to_resume, signo); 2657 }, 2658 CoordinatorErrorHandler); 2659 } 2660 break; 2661 } 2662 } 2663 2664 Error 2665 NativeProcessLinux::Resume (const ResumeActionList &resume_actions) 2666 { 2667 Error error; 2668 2669 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 2670 if (log) 2671 log->Printf ("NativeProcessLinux::%s called: pid %" PRIu64, __FUNCTION__, GetID ()); 2672 2673 int stop_thread_id = LLDB_INVALID_THREAD_ID; 2674 2675 std::vector<NativeThreadProtocolSP> new_stop_threads; 2676 2677 // Scope for threads mutex. 2678 { 2679 Mutex::Locker locker (m_threads_mutex); 2680 for (auto thread_sp : m_threads) 2681 { 2682 assert (thread_sp && "thread list should not contain NULL threads"); 2683 NativeThreadLinux *const linux_thread_p = reinterpret_cast<NativeThreadLinux*> (thread_sp.get ()); 2684 2685 const ResumeAction *const action = resume_actions.GetActionForThread (thread_sp->GetID (), true); 2686 assert (action && "NULL ResumeAction returned for thread during Resume ()"); 2687 2688 if (log) 2689 { 2690 log->Printf ("NativeProcessLinux::%s processing resume action state %s for pid %" PRIu64 " tid %" PRIu64, 2691 __FUNCTION__, StateAsCString (action->state), GetID (), thread_sp->GetID ()); 2692 } 2693 2694 switch (action->state) 2695 { 2696 case eStateRunning: 2697 { 2698 // Run the thread, possibly feeding it the signal. 2699 const int signo = action->signal; 2700 m_coordinator_up->RequestThreadResume (thread_sp->GetID (), 2701 [=](lldb::tid_t tid_to_resume) 2702 { 2703 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2704 // Pass this signal number on to the inferior to handle. 2705 Resume (tid_to_resume, (signo > 0) ? signo : LLDB_INVALID_SIGNAL_NUMBER); 2706 }, 2707 CoordinatorErrorHandler); 2708 break; 2709 } 2710 2711 case eStateStepping: 2712 linux_thread_p->SetStepping (); 2713 if (SingleStep (thread_sp->GetID (), 0)) 2714 { 2715 if (log) 2716 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 " single step succeeded", 2717 __FUNCTION__, GetID (), thread_sp->GetID ()); 2718 } 2719 else 2720 { 2721 if (log) 2722 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 " single step failed", 2723 __FUNCTION__, GetID (), thread_sp->GetID ()); 2724 } 2725 break; 2726 2727 case eStateSuspended: 2728 case eStateStopped: 2729 // if we haven't chosen a stop thread id yet, use this one. 2730 if (stop_thread_id == LLDB_INVALID_THREAD_ID) 2731 stop_thread_id = thread_sp->GetID (); 2732 break; 2733 2734 default: 2735 return Error ("NativeProcessLinux::%s (): unexpected state %s specified for pid %" PRIu64 ", tid %" PRIu64, 2736 __FUNCTION__, StateAsCString (action->state), GetID (), thread_sp->GetID ()); 2737 } 2738 } 2739 } 2740 2741 // We don't need to tell the delegate when we're running, so don't do that here. 2742 2743 // If we had any thread stopping, then do a deferred notification of the chosen stop thread id and signal 2744 // after all other running threads have stopped. 2745 if (stop_thread_id != LLDB_INVALID_THREAD_ID) 2746 { 2747 CallAfterRunningThreadsStop (stop_thread_id, 2748 [=](lldb::tid_t deferred_notification_tid) 2749 { 2750 SetCurrentThreadID (deferred_notification_tid); 2751 // Tell the process we have a stop. 2752 SetState (StateType::eStateStopped, true); 2753 }); 2754 } 2755 2756 return error; 2757 } 2758 2759 Error 2760 NativeProcessLinux::Halt () 2761 { 2762 Error error; 2763 2764 if (kill (GetID (), SIGSTOP) != 0) 2765 error.SetErrorToErrno (); 2766 2767 return error; 2768 } 2769 2770 Error 2771 NativeProcessLinux::Detach () 2772 { 2773 Error error; 2774 2775 // Tell ptrace to detach from the process. 2776 if (GetID () != LLDB_INVALID_PROCESS_ID) 2777 error = Detach (GetID ()); 2778 2779 // Stop monitoring the inferior. 2780 StopMonitor (); 2781 2782 // No error. 2783 return error; 2784 } 2785 2786 Error 2787 NativeProcessLinux::Signal (int signo) 2788 { 2789 Error error; 2790 2791 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2792 if (log) 2793 log->Printf ("NativeProcessLinux::%s: sending signal %d (%s) to pid %" PRIu64, 2794 __FUNCTION__, signo, GetUnixSignals ().GetSignalAsCString (signo), GetID ()); 2795 2796 if (kill(GetID(), signo)) 2797 error.SetErrorToErrno(); 2798 2799 return error; 2800 } 2801 2802 Error 2803 NativeProcessLinux::Kill () 2804 { 2805 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2806 if (log) 2807 log->Printf ("NativeProcessLinux::%s called for PID %" PRIu64, __FUNCTION__, GetID ()); 2808 2809 Error error; 2810 2811 switch (m_state) 2812 { 2813 case StateType::eStateInvalid: 2814 case StateType::eStateExited: 2815 case StateType::eStateCrashed: 2816 case StateType::eStateDetached: 2817 case StateType::eStateUnloaded: 2818 // Nothing to do - the process is already dead. 2819 if (log) 2820 log->Printf ("NativeProcessLinux::%s ignored for PID %" PRIu64 " due to current state: %s", __FUNCTION__, GetID (), StateAsCString (m_state)); 2821 return error; 2822 2823 case StateType::eStateConnected: 2824 case StateType::eStateAttaching: 2825 case StateType::eStateLaunching: 2826 case StateType::eStateStopped: 2827 case StateType::eStateRunning: 2828 case StateType::eStateStepping: 2829 case StateType::eStateSuspended: 2830 // We can try to kill a process in these states. 2831 break; 2832 } 2833 2834 if (kill (GetID (), SIGKILL) != 0) 2835 { 2836 error.SetErrorToErrno (); 2837 return error; 2838 } 2839 2840 return error; 2841 } 2842 2843 static Error 2844 ParseMemoryRegionInfoFromProcMapsLine (const std::string &maps_line, MemoryRegionInfo &memory_region_info) 2845 { 2846 memory_region_info.Clear(); 2847 2848 StringExtractor line_extractor (maps_line.c_str ()); 2849 2850 // Format: {address_start_hex}-{address_end_hex} perms offset dev inode pathname 2851 // perms: rwxp (letter is present if set, '-' if not, final character is p=private, s=shared). 2852 2853 // Parse out the starting address 2854 lldb::addr_t start_address = line_extractor.GetHexMaxU64 (false, 0); 2855 2856 // Parse out hyphen separating start and end address from range. 2857 if (!line_extractor.GetBytesLeft () || (line_extractor.GetChar () != '-')) 2858 return Error ("malformed /proc/{pid}/maps entry, missing dash between address range"); 2859 2860 // Parse out the ending address 2861 lldb::addr_t end_address = line_extractor.GetHexMaxU64 (false, start_address); 2862 2863 // Parse out the space after the address. 2864 if (!line_extractor.GetBytesLeft () || (line_extractor.GetChar () != ' ')) 2865 return Error ("malformed /proc/{pid}/maps entry, missing space after range"); 2866 2867 // Save the range. 2868 memory_region_info.GetRange ().SetRangeBase (start_address); 2869 memory_region_info.GetRange ().SetRangeEnd (end_address); 2870 2871 // Parse out each permission entry. 2872 if (line_extractor.GetBytesLeft () < 4) 2873 return Error ("malformed /proc/{pid}/maps entry, missing some portion of permissions"); 2874 2875 // Handle read permission. 2876 const char read_perm_char = line_extractor.GetChar (); 2877 if (read_perm_char == 'r') 2878 memory_region_info.SetReadable (MemoryRegionInfo::OptionalBool::eYes); 2879 else 2880 { 2881 assert ( (read_perm_char == '-') && "unexpected /proc/{pid}/maps read permission char" ); 2882 memory_region_info.SetReadable (MemoryRegionInfo::OptionalBool::eNo); 2883 } 2884 2885 // Handle write permission. 2886 const char write_perm_char = line_extractor.GetChar (); 2887 if (write_perm_char == 'w') 2888 memory_region_info.SetWritable (MemoryRegionInfo::OptionalBool::eYes); 2889 else 2890 { 2891 assert ( (write_perm_char == '-') && "unexpected /proc/{pid}/maps write permission char" ); 2892 memory_region_info.SetWritable (MemoryRegionInfo::OptionalBool::eNo); 2893 } 2894 2895 // Handle execute permission. 2896 const char exec_perm_char = line_extractor.GetChar (); 2897 if (exec_perm_char == 'x') 2898 memory_region_info.SetExecutable (MemoryRegionInfo::OptionalBool::eYes); 2899 else 2900 { 2901 assert ( (exec_perm_char == '-') && "unexpected /proc/{pid}/maps exec permission char" ); 2902 memory_region_info.SetExecutable (MemoryRegionInfo::OptionalBool::eNo); 2903 } 2904 2905 return Error (); 2906 } 2907 2908 Error 2909 NativeProcessLinux::GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info) 2910 { 2911 // FIXME review that the final memory region returned extends to the end of the virtual address space, 2912 // with no perms if it is not mapped. 2913 2914 // Use an approach that reads memory regions from /proc/{pid}/maps. 2915 // Assume proc maps entries are in ascending order. 2916 // FIXME assert if we find differently. 2917 Mutex::Locker locker (m_mem_region_cache_mutex); 2918 2919 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2920 Error error; 2921 2922 if (m_supports_mem_region == LazyBool::eLazyBoolNo) 2923 { 2924 // We're done. 2925 error.SetErrorString ("unsupported"); 2926 return error; 2927 } 2928 2929 // If our cache is empty, pull the latest. There should always be at least one memory region 2930 // if memory region handling is supported. 2931 if (m_mem_region_cache.empty ()) 2932 { 2933 error = ProcFileReader::ProcessLineByLine (GetID (), "maps", 2934 [&] (const std::string &line) -> bool 2935 { 2936 MemoryRegionInfo info; 2937 const Error parse_error = ParseMemoryRegionInfoFromProcMapsLine (line, info); 2938 if (parse_error.Success ()) 2939 { 2940 m_mem_region_cache.push_back (info); 2941 return true; 2942 } 2943 else 2944 { 2945 if (log) 2946 log->Printf ("NativeProcessLinux::%s failed to parse proc maps line '%s': %s", __FUNCTION__, line.c_str (), error.AsCString ()); 2947 return false; 2948 } 2949 }); 2950 2951 // If we had an error, we'll mark unsupported. 2952 if (error.Fail ()) 2953 { 2954 m_supports_mem_region = LazyBool::eLazyBoolNo; 2955 return error; 2956 } 2957 else if (m_mem_region_cache.empty ()) 2958 { 2959 // No entries after attempting to read them. This shouldn't happen if /proc/{pid}/maps 2960 // is supported. Assume we don't support map entries via procfs. 2961 if (log) 2962 log->Printf ("NativeProcessLinux::%s failed to find any procfs maps entries, assuming no support for memory region metadata retrieval", __FUNCTION__); 2963 m_supports_mem_region = LazyBool::eLazyBoolNo; 2964 error.SetErrorString ("not supported"); 2965 return error; 2966 } 2967 2968 if (log) 2969 log->Printf ("NativeProcessLinux::%s read %" PRIu64 " memory region entries from /proc/%" PRIu64 "/maps", __FUNCTION__, static_cast<uint64_t> (m_mem_region_cache.size ()), GetID ()); 2970 2971 // We support memory retrieval, remember that. 2972 m_supports_mem_region = LazyBool::eLazyBoolYes; 2973 } 2974 else 2975 { 2976 if (log) 2977 log->Printf ("NativeProcessLinux::%s reusing %" PRIu64 " cached memory region entries", __FUNCTION__, static_cast<uint64_t> (m_mem_region_cache.size ())); 2978 } 2979 2980 lldb::addr_t prev_base_address = 0; 2981 2982 // FIXME start by finding the last region that is <= target address using binary search. Data is sorted. 2983 // There can be a ton of regions on pthreads apps with lots of threads. 2984 for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end (); ++it) 2985 { 2986 MemoryRegionInfo &proc_entry_info = *it; 2987 2988 // Sanity check assumption that /proc/{pid}/maps entries are ascending. 2989 assert ((proc_entry_info.GetRange ().GetRangeBase () >= prev_base_address) && "descending /proc/pid/maps entries detected, unexpected"); 2990 prev_base_address = proc_entry_info.GetRange ().GetRangeBase (); 2991 2992 // If the target address comes before this entry, indicate distance to next region. 2993 if (load_addr < proc_entry_info.GetRange ().GetRangeBase ()) 2994 { 2995 range_info.GetRange ().SetRangeBase (load_addr); 2996 range_info.GetRange ().SetByteSize (proc_entry_info.GetRange ().GetRangeBase () - load_addr); 2997 range_info.SetReadable (MemoryRegionInfo::OptionalBool::eNo); 2998 range_info.SetWritable (MemoryRegionInfo::OptionalBool::eNo); 2999 range_info.SetExecutable (MemoryRegionInfo::OptionalBool::eNo); 3000 3001 return error; 3002 } 3003 else if (proc_entry_info.GetRange ().Contains (load_addr)) 3004 { 3005 // The target address is within the memory region we're processing here. 3006 range_info = proc_entry_info; 3007 return error; 3008 } 3009 3010 // The target memory address comes somewhere after the region we just parsed. 3011 } 3012 3013 // If we made it here, we didn't find an entry that contained the given address. 3014 error.SetErrorString ("address comes after final region"); 3015 3016 if (log) 3017 log->Printf ("NativeProcessLinux::%s failed to find map entry for address 0x%" PRIx64 ": %s", __FUNCTION__, load_addr, error.AsCString ()); 3018 3019 return error; 3020 } 3021 3022 void 3023 NativeProcessLinux::DoStopIDBumped (uint32_t newBumpId) 3024 { 3025 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 3026 if (log) 3027 log->Printf ("NativeProcessLinux::%s(newBumpId=%" PRIu32 ") called", __FUNCTION__, newBumpId); 3028 3029 { 3030 Mutex::Locker locker (m_mem_region_cache_mutex); 3031 if (log) 3032 log->Printf ("NativeProcessLinux::%s clearing %" PRIu64 " entries from the cache", __FUNCTION__, static_cast<uint64_t> (m_mem_region_cache.size ())); 3033 m_mem_region_cache.clear (); 3034 } 3035 } 3036 3037 Error 3038 NativeProcessLinux::AllocateMemory ( 3039 lldb::addr_t size, 3040 uint32_t permissions, 3041 lldb::addr_t &addr) 3042 { 3043 // FIXME implementing this requires the equivalent of 3044 // InferiorCallPOSIX::InferiorCallMmap, which depends on 3045 // functional ThreadPlans working with Native*Protocol. 3046 #if 1 3047 return Error ("not implemented yet"); 3048 #else 3049 addr = LLDB_INVALID_ADDRESS; 3050 3051 unsigned prot = 0; 3052 if (permissions & lldb::ePermissionsReadable) 3053 prot |= eMmapProtRead; 3054 if (permissions & lldb::ePermissionsWritable) 3055 prot |= eMmapProtWrite; 3056 if (permissions & lldb::ePermissionsExecutable) 3057 prot |= eMmapProtExec; 3058 3059 // TODO implement this directly in NativeProcessLinux 3060 // (and lift to NativeProcessPOSIX if/when that class is 3061 // refactored out). 3062 if (InferiorCallMmap(this, addr, 0, size, prot, 3063 eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) { 3064 m_addr_to_mmap_size[addr] = size; 3065 return Error (); 3066 } else { 3067 addr = LLDB_INVALID_ADDRESS; 3068 return Error("unable to allocate %" PRIu64 " bytes of memory with permissions %s", size, GetPermissionsAsCString (permissions)); 3069 } 3070 #endif 3071 } 3072 3073 Error 3074 NativeProcessLinux::DeallocateMemory (lldb::addr_t addr) 3075 { 3076 // FIXME see comments in AllocateMemory - required lower-level 3077 // bits not in place yet (ThreadPlans) 3078 return Error ("not implemented"); 3079 } 3080 3081 lldb::addr_t 3082 NativeProcessLinux::GetSharedLibraryInfoAddress () 3083 { 3084 #if 1 3085 // punt on this for now 3086 return LLDB_INVALID_ADDRESS; 3087 #else 3088 // Return the image info address for the exe module 3089 #if 1 3090 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 3091 3092 ModuleSP module_sp; 3093 Error error = GetExeModuleSP (module_sp); 3094 if (error.Fail ()) 3095 { 3096 if (log) 3097 log->Warning ("NativeProcessLinux::%s failed to retrieve exe module: %s", __FUNCTION__, error.AsCString ()); 3098 return LLDB_INVALID_ADDRESS; 3099 } 3100 3101 if (module_sp == nullptr) 3102 { 3103 if (log) 3104 log->Warning ("NativeProcessLinux::%s exe module returned was NULL", __FUNCTION__); 3105 return LLDB_INVALID_ADDRESS; 3106 } 3107 3108 ObjectFileSP object_file_sp = module_sp->GetObjectFile (); 3109 if (object_file_sp == nullptr) 3110 { 3111 if (log) 3112 log->Warning ("NativeProcessLinux::%s exe module returned a NULL object file", __FUNCTION__); 3113 return LLDB_INVALID_ADDRESS; 3114 } 3115 3116 return obj_file_sp->GetImageInfoAddress(); 3117 #else 3118 Target *target = &GetTarget(); 3119 ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile(); 3120 Address addr = obj_file->GetImageInfoAddress(target); 3121 3122 if (addr.IsValid()) 3123 return addr.GetLoadAddress(target); 3124 return LLDB_INVALID_ADDRESS; 3125 #endif 3126 #endif // punt on this for now 3127 } 3128 3129 size_t 3130 NativeProcessLinux::UpdateThreads () 3131 { 3132 // The NativeProcessLinux monitoring threads are always up to date 3133 // with respect to thread state and they keep the thread list 3134 // populated properly. All this method needs to do is return the 3135 // thread count. 3136 Mutex::Locker locker (m_threads_mutex); 3137 return m_threads.size (); 3138 } 3139 3140 bool 3141 NativeProcessLinux::GetArchitecture (ArchSpec &arch) const 3142 { 3143 arch = m_arch; 3144 return true; 3145 } 3146 3147 Error 3148 NativeProcessLinux::GetSoftwareBreakpointSize (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size) 3149 { 3150 // FIXME put this behind a breakpoint protocol class that can be 3151 // set per architecture. Need ARM, MIPS support here. 3152 static const uint8_t g_aarch64_opcode[] = { 0x00, 0x00, 0x20, 0xd4 }; 3153 static const uint8_t g_i386_opcode [] = { 0xCC }; 3154 3155 switch (m_arch.GetMachine ()) 3156 { 3157 case llvm::Triple::aarch64: 3158 actual_opcode_size = static_cast<uint32_t> (sizeof(g_aarch64_opcode)); 3159 return Error (); 3160 3161 case llvm::Triple::x86: 3162 case llvm::Triple::x86_64: 3163 actual_opcode_size = static_cast<uint32_t> (sizeof(g_i386_opcode)); 3164 return Error (); 3165 3166 default: 3167 assert(false && "CPU type not supported!"); 3168 return Error ("CPU type not supported"); 3169 } 3170 } 3171 3172 Error 3173 NativeProcessLinux::SetBreakpoint (lldb::addr_t addr, uint32_t size, bool hardware) 3174 { 3175 if (hardware) 3176 return Error ("NativeProcessLinux does not support hardware breakpoints"); 3177 else 3178 return SetSoftwareBreakpoint (addr, size); 3179 } 3180 3181 Error 3182 NativeProcessLinux::GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) 3183 { 3184 // FIXME put this behind a breakpoint protocol class that can be 3185 // set per architecture. Need ARM, MIPS support here. 3186 static const uint8_t g_aarch64_opcode[] = { 0x00, 0x00, 0x20, 0xd4 }; 3187 static const uint8_t g_i386_opcode [] = { 0xCC }; 3188 3189 switch (m_arch.GetMachine ()) 3190 { 3191 case llvm::Triple::aarch64: 3192 trap_opcode_bytes = g_aarch64_opcode; 3193 actual_opcode_size = sizeof(g_aarch64_opcode); 3194 return Error (); 3195 3196 case llvm::Triple::x86: 3197 case llvm::Triple::x86_64: 3198 trap_opcode_bytes = g_i386_opcode; 3199 actual_opcode_size = sizeof(g_i386_opcode); 3200 return Error (); 3201 3202 default: 3203 assert(false && "CPU type not supported!"); 3204 return Error ("CPU type not supported"); 3205 } 3206 } 3207 3208 #if 0 3209 ProcessMessage::CrashReason 3210 NativeProcessLinux::GetCrashReasonForSIGSEGV(const siginfo_t *info) 3211 { 3212 ProcessMessage::CrashReason reason; 3213 assert(info->si_signo == SIGSEGV); 3214 3215 reason = ProcessMessage::eInvalidCrashReason; 3216 3217 switch (info->si_code) 3218 { 3219 default: 3220 assert(false && "unexpected si_code for SIGSEGV"); 3221 break; 3222 case SI_KERNEL: 3223 // Linux will occasionally send spurious SI_KERNEL codes. 3224 // (this is poorly documented in sigaction) 3225 // One way to get this is via unaligned SIMD loads. 3226 reason = ProcessMessage::eInvalidAddress; // for lack of anything better 3227 break; 3228 case SEGV_MAPERR: 3229 reason = ProcessMessage::eInvalidAddress; 3230 break; 3231 case SEGV_ACCERR: 3232 reason = ProcessMessage::ePrivilegedAddress; 3233 break; 3234 } 3235 3236 return reason; 3237 } 3238 #endif 3239 3240 3241 #if 0 3242 ProcessMessage::CrashReason 3243 NativeProcessLinux::GetCrashReasonForSIGILL(const siginfo_t *info) 3244 { 3245 ProcessMessage::CrashReason reason; 3246 assert(info->si_signo == SIGILL); 3247 3248 reason = ProcessMessage::eInvalidCrashReason; 3249 3250 switch (info->si_code) 3251 { 3252 default: 3253 assert(false && "unexpected si_code for SIGILL"); 3254 break; 3255 case ILL_ILLOPC: 3256 reason = ProcessMessage::eIllegalOpcode; 3257 break; 3258 case ILL_ILLOPN: 3259 reason = ProcessMessage::eIllegalOperand; 3260 break; 3261 case ILL_ILLADR: 3262 reason = ProcessMessage::eIllegalAddressingMode; 3263 break; 3264 case ILL_ILLTRP: 3265 reason = ProcessMessage::eIllegalTrap; 3266 break; 3267 case ILL_PRVOPC: 3268 reason = ProcessMessage::ePrivilegedOpcode; 3269 break; 3270 case ILL_PRVREG: 3271 reason = ProcessMessage::ePrivilegedRegister; 3272 break; 3273 case ILL_COPROC: 3274 reason = ProcessMessage::eCoprocessorError; 3275 break; 3276 case ILL_BADSTK: 3277 reason = ProcessMessage::eInternalStackError; 3278 break; 3279 } 3280 3281 return reason; 3282 } 3283 #endif 3284 3285 #if 0 3286 ProcessMessage::CrashReason 3287 NativeProcessLinux::GetCrashReasonForSIGFPE(const siginfo_t *info) 3288 { 3289 ProcessMessage::CrashReason reason; 3290 assert(info->si_signo == SIGFPE); 3291 3292 reason = ProcessMessage::eInvalidCrashReason; 3293 3294 switch (info->si_code) 3295 { 3296 default: 3297 assert(false && "unexpected si_code for SIGFPE"); 3298 break; 3299 case FPE_INTDIV: 3300 reason = ProcessMessage::eIntegerDivideByZero; 3301 break; 3302 case FPE_INTOVF: 3303 reason = ProcessMessage::eIntegerOverflow; 3304 break; 3305 case FPE_FLTDIV: 3306 reason = ProcessMessage::eFloatDivideByZero; 3307 break; 3308 case FPE_FLTOVF: 3309 reason = ProcessMessage::eFloatOverflow; 3310 break; 3311 case FPE_FLTUND: 3312 reason = ProcessMessage::eFloatUnderflow; 3313 break; 3314 case FPE_FLTRES: 3315 reason = ProcessMessage::eFloatInexactResult; 3316 break; 3317 case FPE_FLTINV: 3318 reason = ProcessMessage::eFloatInvalidOperation; 3319 break; 3320 case FPE_FLTSUB: 3321 reason = ProcessMessage::eFloatSubscriptRange; 3322 break; 3323 } 3324 3325 return reason; 3326 } 3327 #endif 3328 3329 #if 0 3330 ProcessMessage::CrashReason 3331 NativeProcessLinux::GetCrashReasonForSIGBUS(const siginfo_t *info) 3332 { 3333 ProcessMessage::CrashReason reason; 3334 assert(info->si_signo == SIGBUS); 3335 3336 reason = ProcessMessage::eInvalidCrashReason; 3337 3338 switch (info->si_code) 3339 { 3340 default: 3341 assert(false && "unexpected si_code for SIGBUS"); 3342 break; 3343 case BUS_ADRALN: 3344 reason = ProcessMessage::eIllegalAlignment; 3345 break; 3346 case BUS_ADRERR: 3347 reason = ProcessMessage::eIllegalAddress; 3348 break; 3349 case BUS_OBJERR: 3350 reason = ProcessMessage::eHardwareError; 3351 break; 3352 } 3353 3354 return reason; 3355 } 3356 #endif 3357 3358 void 3359 NativeProcessLinux::ServeOperation(OperationArgs *args) 3360 { 3361 NativeProcessLinux *monitor = args->m_monitor; 3362 3363 // We are finised with the arguments and are ready to go. Sync with the 3364 // parent thread and start serving operations on the inferior. 3365 sem_post(&args->m_semaphore); 3366 3367 for(;;) 3368 { 3369 // wait for next pending operation 3370 if (sem_wait(&monitor->m_operation_pending)) 3371 { 3372 if (errno == EINTR) 3373 continue; 3374 assert(false && "Unexpected errno from sem_wait"); 3375 } 3376 3377 reinterpret_cast<Operation*>(monitor->m_operation)->Execute(monitor); 3378 3379 // notify calling thread that operation is complete 3380 sem_post(&monitor->m_operation_done); 3381 } 3382 } 3383 3384 void 3385 NativeProcessLinux::DoOperation(void *op) 3386 { 3387 Mutex::Locker lock(m_operation_mutex); 3388 3389 m_operation = op; 3390 3391 // notify operation thread that an operation is ready to be processed 3392 sem_post(&m_operation_pending); 3393 3394 // wait for operation to complete 3395 while (sem_wait(&m_operation_done)) 3396 { 3397 if (errno == EINTR) 3398 continue; 3399 assert(false && "Unexpected errno from sem_wait"); 3400 } 3401 } 3402 3403 Error 3404 NativeProcessLinux::ReadMemory (lldb::addr_t addr, void *buf, lldb::addr_t size, lldb::addr_t &bytes_read) 3405 { 3406 ReadOperation op(addr, buf, size, bytes_read); 3407 DoOperation(&op); 3408 return op.GetError (); 3409 } 3410 3411 Error 3412 NativeProcessLinux::WriteMemory (lldb::addr_t addr, const void *buf, lldb::addr_t size, lldb::addr_t &bytes_written) 3413 { 3414 WriteOperation op(addr, buf, size, bytes_written); 3415 DoOperation(&op); 3416 return op.GetError (); 3417 } 3418 3419 bool 3420 NativeProcessLinux::ReadRegisterValue(lldb::tid_t tid, uint32_t offset, const char* reg_name, 3421 uint32_t size, RegisterValue &value) 3422 { 3423 bool result; 3424 ReadRegOperation op(tid, offset, reg_name, value, result); 3425 DoOperation(&op); 3426 return result; 3427 } 3428 3429 bool 3430 NativeProcessLinux::WriteRegisterValue(lldb::tid_t tid, unsigned offset, 3431 const char* reg_name, const RegisterValue &value) 3432 { 3433 bool result; 3434 WriteRegOperation op(tid, offset, reg_name, value, result); 3435 DoOperation(&op); 3436 return result; 3437 } 3438 3439 bool 3440 NativeProcessLinux::ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size) 3441 { 3442 bool result; 3443 ReadGPROperation op(tid, buf, buf_size, result); 3444 DoOperation(&op); 3445 return result; 3446 } 3447 3448 bool 3449 NativeProcessLinux::ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size) 3450 { 3451 bool result; 3452 ReadFPROperation op(tid, buf, buf_size, result); 3453 DoOperation(&op); 3454 return result; 3455 } 3456 3457 bool 3458 NativeProcessLinux::ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset) 3459 { 3460 bool result; 3461 ReadRegisterSetOperation op(tid, buf, buf_size, regset, result); 3462 DoOperation(&op); 3463 return result; 3464 } 3465 3466 bool 3467 NativeProcessLinux::WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size) 3468 { 3469 bool result; 3470 WriteGPROperation op(tid, buf, buf_size, result); 3471 DoOperation(&op); 3472 return result; 3473 } 3474 3475 bool 3476 NativeProcessLinux::WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size) 3477 { 3478 bool result; 3479 WriteFPROperation op(tid, buf, buf_size, result); 3480 DoOperation(&op); 3481 return result; 3482 } 3483 3484 bool 3485 NativeProcessLinux::WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset) 3486 { 3487 bool result; 3488 WriteRegisterSetOperation op(tid, buf, buf_size, regset, result); 3489 DoOperation(&op); 3490 return result; 3491 } 3492 3493 bool 3494 NativeProcessLinux::Resume (lldb::tid_t tid, uint32_t signo) 3495 { 3496 bool result; 3497 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 3498 3499 if (log) 3500 log->Printf ("NativeProcessLinux::%s() resuming thread = %" PRIu64 " with signal %s", __FUNCTION__, tid, 3501 GetUnixSignals().GetSignalAsCString (signo)); 3502 ResumeOperation op (tid, signo, result); 3503 DoOperation (&op); 3504 if (log) 3505 log->Printf ("NativeProcessLinux::%s() resuming result = %s", __FUNCTION__, result ? "true" : "false"); 3506 return result; 3507 } 3508 3509 bool 3510 NativeProcessLinux::SingleStep(lldb::tid_t tid, uint32_t signo) 3511 { 3512 bool result; 3513 SingleStepOperation op(tid, signo, result); 3514 DoOperation(&op); 3515 return result; 3516 } 3517 3518 bool 3519 NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo, int &ptrace_err) 3520 { 3521 bool result; 3522 SiginfoOperation op(tid, siginfo, result, ptrace_err); 3523 DoOperation(&op); 3524 return result; 3525 } 3526 3527 bool 3528 NativeProcessLinux::GetEventMessage(lldb::tid_t tid, unsigned long *message) 3529 { 3530 bool result; 3531 EventMessageOperation op(tid, message, result); 3532 DoOperation(&op); 3533 return result; 3534 } 3535 3536 lldb_private::Error 3537 NativeProcessLinux::Detach(lldb::tid_t tid) 3538 { 3539 lldb_private::Error error; 3540 if (tid != LLDB_INVALID_THREAD_ID) 3541 { 3542 DetachOperation op(tid, error); 3543 DoOperation(&op); 3544 } 3545 return error; 3546 } 3547 3548 bool 3549 NativeProcessLinux::DupDescriptor(const char *path, int fd, int flags) 3550 { 3551 int target_fd = open(path, flags, 0666); 3552 3553 if (target_fd == -1) 3554 return false; 3555 3556 return (dup2(target_fd, fd) == -1) ? false : true; 3557 } 3558 3559 void 3560 NativeProcessLinux::StopMonitoringChildProcess() 3561 { 3562 if (m_monitor_thread.IsJoinable()) 3563 { 3564 m_monitor_thread.Cancel(); 3565 m_monitor_thread.Join(nullptr); 3566 } 3567 } 3568 3569 void 3570 NativeProcessLinux::StopMonitor() 3571 { 3572 StopMonitoringChildProcess(); 3573 StopOpThread(); 3574 StopCoordinatorThread (); 3575 sem_destroy(&m_operation_pending); 3576 sem_destroy(&m_operation_done); 3577 3578 // TODO: validate whether this still holds, fix up comment. 3579 // Note: ProcessPOSIX passes the m_terminal_fd file descriptor to 3580 // Process::SetSTDIOFileDescriptor, which in turn transfers ownership of 3581 // the descriptor to a ConnectionFileDescriptor object. Consequently 3582 // even though still has the file descriptor, we shouldn't close it here. 3583 } 3584 3585 void 3586 NativeProcessLinux::StopOpThread() 3587 { 3588 if (!m_operation_thread.IsJoinable()) 3589 return; 3590 3591 m_operation_thread.Cancel(); 3592 m_operation_thread.Join(nullptr); 3593 } 3594 3595 Error 3596 NativeProcessLinux::StartCoordinatorThread () 3597 { 3598 Error error; 3599 static const char *g_thread_name = "lldb.process.linux.ts_coordinator"; 3600 Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3601 3602 // Skip if thread is already running 3603 if (m_coordinator_thread.IsJoinable()) 3604 { 3605 error.SetErrorString ("ThreadStateCoordinator's run loop is already running"); 3606 if (log) 3607 log->Printf ("NativeProcessLinux::%s %s", __FUNCTION__, error.AsCString ()); 3608 return error; 3609 } 3610 3611 // Enable verbose logging if lldb thread logging is enabled. 3612 m_coordinator_up->LogEnableEventProcessing (log != nullptr); 3613 3614 if (log) 3615 log->Printf ("NativeProcessLinux::%s launching ThreadStateCoordinator thread for pid %" PRIu64, __FUNCTION__, GetID ()); 3616 m_coordinator_thread = ThreadLauncher::LaunchThread(g_thread_name, CoordinatorThread, this, &error); 3617 return error; 3618 } 3619 3620 void * 3621 NativeProcessLinux::CoordinatorThread (void *arg) 3622 { 3623 Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3624 3625 NativeProcessLinux *const process = static_cast<NativeProcessLinux*> (arg); 3626 assert (process && "null process passed to CoordinatorThread"); 3627 if (!process) 3628 { 3629 if (log) 3630 log->Printf ("NativeProcessLinux::%s null process, exiting ThreadStateCoordinator processing loop", __FUNCTION__); 3631 return nullptr; 3632 } 3633 3634 // Run the thread state coordinator loop until it is done. This call uses 3635 // efficient waiting for an event to be ready. 3636 while (process->m_coordinator_up->ProcessNextEvent () == ThreadStateCoordinator::eventLoopResultContinue) 3637 { 3638 } 3639 3640 if (log) 3641 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " exiting ThreadStateCoordinator processing loop due to coordinator indicating completion", __FUNCTION__, process->GetID ()); 3642 3643 return nullptr; 3644 } 3645 3646 void 3647 NativeProcessLinux::StopCoordinatorThread() 3648 { 3649 Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3650 if (log) 3651 log->Printf ("NativeProcessLinux::%s requesting ThreadStateCoordinator stop for pid %" PRIu64, __FUNCTION__, GetID ()); 3652 3653 // Tell the coordinator we're done. This will cause the coordinator 3654 // run loop thread to exit when the processing queue hits this message. 3655 m_coordinator_up->StopCoordinator (); 3656 } 3657 3658 bool 3659 NativeProcessLinux::HasThreadNoLock (lldb::tid_t thread_id) 3660 { 3661 for (auto thread_sp : m_threads) 3662 { 3663 assert (thread_sp && "thread list should not contain NULL threads"); 3664 if (thread_sp->GetID () == thread_id) 3665 { 3666 // We have this thread. 3667 return true; 3668 } 3669 } 3670 3671 // We don't have this thread. 3672 return false; 3673 } 3674 3675 NativeThreadProtocolSP 3676 NativeProcessLinux::MaybeGetThreadNoLock (lldb::tid_t thread_id) 3677 { 3678 // CONSIDER organize threads by map - we can do better than linear. 3679 for (auto thread_sp : m_threads) 3680 { 3681 if (thread_sp->GetID () == thread_id) 3682 return thread_sp; 3683 } 3684 3685 // We don't have this thread. 3686 return NativeThreadProtocolSP (); 3687 } 3688 3689 bool 3690 NativeProcessLinux::StopTrackingThread (lldb::tid_t thread_id) 3691 { 3692 Mutex::Locker locker (m_threads_mutex); 3693 for (auto it = m_threads.begin (); it != m_threads.end (); ++it) 3694 { 3695 if (*it && ((*it)->GetID () == thread_id)) 3696 { 3697 m_threads.erase (it); 3698 return true; 3699 } 3700 } 3701 3702 // Didn't find it. 3703 return false; 3704 } 3705 3706 NativeThreadProtocolSP 3707 NativeProcessLinux::AddThread (lldb::tid_t thread_id) 3708 { 3709 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3710 3711 Mutex::Locker locker (m_threads_mutex); 3712 3713 if (log) 3714 { 3715 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " adding thread with tid %" PRIu64, 3716 __FUNCTION__, 3717 GetID (), 3718 thread_id); 3719 } 3720 3721 assert (!HasThreadNoLock (thread_id) && "attempted to add a thread by id that already exists"); 3722 3723 // If this is the first thread, save it as the current thread 3724 if (m_threads.empty ()) 3725 SetCurrentThreadID (thread_id); 3726 3727 NativeThreadProtocolSP thread_sp (new NativeThreadLinux (this, thread_id)); 3728 m_threads.push_back (thread_sp); 3729 3730 return thread_sp; 3731 } 3732 3733 NativeThreadProtocolSP 3734 NativeProcessLinux::GetOrCreateThread (lldb::tid_t thread_id, bool &created) 3735 { 3736 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3737 3738 Mutex::Locker locker (m_threads_mutex); 3739 if (log) 3740 { 3741 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " get/create thread with tid %" PRIu64, 3742 __FUNCTION__, 3743 GetID (), 3744 thread_id); 3745 } 3746 3747 // Retrieve the thread if it is already getting tracked. 3748 NativeThreadProtocolSP thread_sp = MaybeGetThreadNoLock (thread_id); 3749 if (thread_sp) 3750 { 3751 if (log) 3752 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": thread already tracked, returning", 3753 __FUNCTION__, 3754 GetID (), 3755 thread_id); 3756 created = false; 3757 return thread_sp; 3758 3759 } 3760 3761 // Create the thread metadata since it isn't being tracked. 3762 if (log) 3763 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": thread didn't exist, tracking now", 3764 __FUNCTION__, 3765 GetID (), 3766 thread_id); 3767 3768 thread_sp.reset (new NativeThreadLinux (this, thread_id)); 3769 m_threads.push_back (thread_sp); 3770 created = true; 3771 3772 return thread_sp; 3773 } 3774 3775 Error 3776 NativeProcessLinux::FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp) 3777 { 3778 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 3779 3780 Error error; 3781 3782 // Get a linux thread pointer. 3783 if (!thread_sp) 3784 { 3785 error.SetErrorString ("null thread_sp"); 3786 if (log) 3787 log->Printf ("NativeProcessLinux::%s failed: %s", __FUNCTION__, error.AsCString ()); 3788 return error; 3789 } 3790 NativeThreadLinux *const linux_thread_p = reinterpret_cast<NativeThreadLinux*> (thread_sp.get()); 3791 3792 // Find out the size of a breakpoint (might depend on where we are in the code). 3793 NativeRegisterContextSP context_sp = linux_thread_p->GetRegisterContext (); 3794 if (!context_sp) 3795 { 3796 error.SetErrorString ("cannot get a NativeRegisterContext for the thread"); 3797 if (log) 3798 log->Printf ("NativeProcessLinux::%s failed: %s", __FUNCTION__, error.AsCString ()); 3799 return error; 3800 } 3801 3802 uint32_t breakpoint_size = 0; 3803 error = GetSoftwareBreakpointSize (context_sp, breakpoint_size); 3804 if (error.Fail ()) 3805 { 3806 if (log) 3807 log->Printf ("NativeProcessLinux::%s GetBreakpointSize() failed: %s", __FUNCTION__, error.AsCString ()); 3808 return error; 3809 } 3810 else 3811 { 3812 if (log) 3813 log->Printf ("NativeProcessLinux::%s breakpoint size: %" PRIu32, __FUNCTION__, breakpoint_size); 3814 } 3815 3816 // First try probing for a breakpoint at a software breakpoint location: PC - breakpoint size. 3817 const lldb::addr_t initial_pc_addr = context_sp->GetPC (); 3818 lldb::addr_t breakpoint_addr = initial_pc_addr; 3819 if (breakpoint_size > static_cast<lldb::addr_t> (0)) 3820 { 3821 // Do not allow breakpoint probe to wrap around. 3822 if (breakpoint_addr >= static_cast<lldb::addr_t> (breakpoint_size)) 3823 breakpoint_addr -= static_cast<lldb::addr_t> (breakpoint_size); 3824 } 3825 3826 // Check if we stopped because of a breakpoint. 3827 NativeBreakpointSP breakpoint_sp; 3828 error = m_breakpoint_list.GetBreakpoint (breakpoint_addr, breakpoint_sp); 3829 if (!error.Success () || !breakpoint_sp) 3830 { 3831 // We didn't find one at a software probe location. Nothing to do. 3832 if (log) 3833 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " no lldb breakpoint found at current pc with adjustment: 0x%" PRIx64, __FUNCTION__, GetID (), breakpoint_addr); 3834 return Error (); 3835 } 3836 3837 // If the breakpoint is not a software breakpoint, nothing to do. 3838 if (!breakpoint_sp->IsSoftwareBreakpoint ()) 3839 { 3840 if (log) 3841 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " breakpoint found at 0x%" PRIx64 ", not software, nothing to adjust", __FUNCTION__, GetID (), breakpoint_addr); 3842 return Error (); 3843 } 3844 3845 // 3846 // We have a software breakpoint and need to adjust the PC. 3847 // 3848 3849 // Sanity check. 3850 if (breakpoint_size == 0) 3851 { 3852 // Nothing to do! How did we get here? 3853 if (log) 3854 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " breakpoint found at 0x%" PRIx64 ", it is software, but the size is zero, nothing to do (unexpected)", __FUNCTION__, GetID (), breakpoint_addr); 3855 return Error (); 3856 } 3857 3858 // Change the program counter. 3859 if (log) 3860 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": changing PC from 0x%" PRIx64 " to 0x%" PRIx64, __FUNCTION__, GetID (), linux_thread_p->GetID (), initial_pc_addr, breakpoint_addr); 3861 3862 error = context_sp->SetPC (breakpoint_addr); 3863 if (error.Fail ()) 3864 { 3865 if (log) 3866 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": failed to set PC: %s", __FUNCTION__, GetID (), linux_thread_p->GetID (), error.AsCString ()); 3867 return error; 3868 } 3869 3870 return error; 3871 } 3872 3873 void 3874 NativeProcessLinux::NotifyThreadCreateStopped (lldb::tid_t tid) 3875 { 3876 const bool is_stopped = true; 3877 m_coordinator_up->NotifyThreadCreate (tid, is_stopped, CoordinatorErrorHandler); 3878 } 3879 3880 void 3881 NativeProcessLinux::NotifyThreadDeath (lldb::tid_t tid) 3882 { 3883 m_coordinator_up->NotifyThreadDeath (tid, CoordinatorErrorHandler); 3884 } 3885 3886 void 3887 NativeProcessLinux::NotifyThreadStop (lldb::tid_t tid) 3888 { 3889 m_coordinator_up->NotifyThreadStop (tid, CoordinatorErrorHandler); 3890 } 3891 3892 void 3893 NativeProcessLinux::CallAfterRunningThreadsStop (lldb::tid_t tid, 3894 const std::function<void (lldb::tid_t tid)> &call_after_function) 3895 { 3896 const lldb::pid_t pid = GetID (); 3897 m_coordinator_up->CallAfterRunningThreadsStop (pid, 3898 [=](lldb::tid_t request_stop_tid) 3899 { 3900 tgkill (pid, request_stop_tid, SIGSTOP); 3901 }, 3902 call_after_function, 3903 CoordinatorErrorHandler); 3904 3905 } 3906