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 // Here we don't have to request the rest of the threads to stop or request a deferred stop. 2344 // This would have already happened at the time the Resume() with step operation was signaled. 2345 // At this point, we just need to say we stopped, and the deferred notifcation will fire off 2346 // once all running threads have checked in as stopped. 2347 break; 2348 2349 case SI_KERNEL: 2350 case TRAP_BRKPT: 2351 if (log) 2352 log->Printf ("NativeProcessLinux::%s() received breakpoint event, pid = %" PRIu64, __FUNCTION__, pid); 2353 2354 // This thread is currently stopped. 2355 NotifyThreadStop (pid); 2356 2357 // Mark the thread as stopped at breakpoint. 2358 if (thread_sp) 2359 { 2360 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGTRAP); 2361 Error error = FixupBreakpointPCAsNeeded (thread_sp); 2362 if (error.Fail ()) 2363 { 2364 if (log) 2365 log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 " fixup: %s", __FUNCTION__, pid, error.AsCString ()); 2366 } 2367 } 2368 else 2369 { 2370 if (log) 2371 log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 ": warning, cannot process software breakpoint since no thread metadata", __FUNCTION__, pid); 2372 } 2373 2374 2375 // We need to tell all other running threads before we notify the delegate about this stop. 2376 CallAfterRunningThreadsStop (pid, 2377 [=](lldb::tid_t deferred_notification_tid) 2378 { 2379 SetCurrentThreadID (deferred_notification_tid); 2380 // Tell the process we have a stop (from software breakpoint). 2381 SetState (StateType::eStateStopped, true); 2382 }); 2383 break; 2384 2385 case TRAP_HWBKPT: 2386 if (log) 2387 log->Printf ("NativeProcessLinux::%s() received watchpoint event, pid = %" PRIu64, __FUNCTION__, pid); 2388 2389 // This thread is currently stopped. 2390 NotifyThreadStop (pid); 2391 2392 // Mark the thread as stopped at watchpoint. 2393 // The address is at (lldb::addr_t)info->si_addr if we need it. 2394 if (thread_sp) 2395 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGTRAP); 2396 else 2397 { 2398 if (log) 2399 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 ": warning, cannot process hardware breakpoint since no thread metadata", __FUNCTION__, GetID (), pid); 2400 } 2401 2402 // We need to tell all other running threads before we notify the delegate about this stop. 2403 CallAfterRunningThreadsStop (pid, 2404 [=](lldb::tid_t deferred_notification_tid) 2405 { 2406 SetCurrentThreadID (deferred_notification_tid); 2407 // Tell the process we have a stop (from hardware breakpoint). 2408 SetState (StateType::eStateStopped, true); 2409 }); 2410 break; 2411 2412 case SIGTRAP: 2413 case (SIGTRAP | 0x80): 2414 if (log) 2415 log->Printf ("NativeProcessLinux::%s() received unknown SIGTRAP system call stop event, pid %" PRIu64 "tid %" PRIu64 ", resuming", __FUNCTION__, GetID (), pid); 2416 2417 // This thread is currently stopped. 2418 NotifyThreadStop (pid); 2419 if (thread_sp) 2420 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (SIGTRAP); 2421 2422 2423 // Ignore these signals until we know more about them. 2424 m_coordinator_up->RequestThreadResume (pid, 2425 [=](lldb::tid_t tid_to_resume) 2426 { 2427 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2428 Resume (tid_to_resume, LLDB_INVALID_SIGNAL_NUMBER); 2429 }, 2430 CoordinatorErrorHandler); 2431 break; 2432 2433 default: 2434 assert(false && "Unexpected SIGTRAP code!"); 2435 if (log) 2436 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))); 2437 break; 2438 2439 } 2440 } 2441 2442 void 2443 NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited) 2444 { 2445 assert (info && "null info"); 2446 if (!info) 2447 return; 2448 2449 const int signo = info->si_signo; 2450 const bool is_from_llgs = info->si_pid == getpid (); 2451 2452 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2453 2454 // POSIX says that process behaviour is undefined after it ignores a SIGFPE, 2455 // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a 2456 // kill(2) or raise(3). Similarly for tgkill(2) on Linux. 2457 // 2458 // IOW, user generated signals never generate what we consider to be a 2459 // "crash". 2460 // 2461 // Similarly, ACK signals generated by this monitor. 2462 2463 // See if we can find a thread for this signal. 2464 NativeThreadProtocolSP thread_sp = GetThreadByID (pid); 2465 if (!thread_sp) 2466 { 2467 if (log) 2468 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " no thread found for tid %" PRIu64, __FUNCTION__, GetID (), pid); 2469 } 2470 2471 // Handle the signal. 2472 if (info->si_code == SI_TKILL || info->si_code == SI_USER) 2473 { 2474 if (log) 2475 log->Printf ("NativeProcessLinux::%s() received signal %s (%d) with code %s, (siginfo pid = %d (%s), waitpid pid = %" PRIu64 ")", 2476 __FUNCTION__, 2477 GetUnixSignals ().GetSignalAsCString (signo), 2478 signo, 2479 (info->si_code == SI_TKILL ? "SI_TKILL" : "SI_USER"), 2480 info->si_pid, 2481 is_from_llgs ? "from llgs" : "not from llgs", 2482 pid); 2483 } 2484 2485 // Check for new thread notification. 2486 if ((info->si_pid == 0) && (info->si_code == SI_USER)) 2487 { 2488 // A new thread creation is being signaled. This is one of two parts that come in 2489 // a non-deterministic order. pid is the thread id. 2490 if (log) 2491 log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 " tid %" PRIu64 ": new thread notification", 2492 __FUNCTION__, GetID (), pid); 2493 2494 // Did we already create the thread? 2495 bool created_now = false; 2496 thread_sp = GetOrCreateThread (pid, created_now); 2497 assert (thread_sp.get() && "failed to get or create the tracking data for newly created inferior thread"); 2498 2499 // If the thread was already tracked, it means the main thread already received its SIGTRAP for the create. 2500 if (!created_now) 2501 { 2502 // We can now resume the newly created thread since it is fully created. 2503 NotifyThreadCreateStopped (pid); 2504 m_coordinator_up->RequestThreadResume (pid, 2505 [=](lldb::tid_t tid_to_resume) 2506 { 2507 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2508 Resume (tid_to_resume, LLDB_INVALID_SIGNAL_NUMBER); 2509 }, 2510 CoordinatorErrorHandler); 2511 } 2512 else 2513 { 2514 // Mark the thread as currently launching. Need to wait for SIGTRAP clone on the main thread before 2515 // this thread is ready to go. 2516 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetLaunching (); 2517 } 2518 2519 // Done handling. 2520 return; 2521 } 2522 2523 // Check for thread stop notification. 2524 if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP)) 2525 { 2526 // This is a tgkill()-based stop. 2527 if (thread_sp) 2528 { 2529 if (log) 2530 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 ", thread stopped", 2531 __FUNCTION__, 2532 GetID (), 2533 pid); 2534 2535 // An inferior thread just stopped, but was not the primary cause of the process stop. 2536 // Instead, something else (like a breakpoint or step) caused the stop. Mark the 2537 // stop signal as 0 to let lldb know this isn't the important stop. 2538 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (0); 2539 SetCurrentThreadID (thread_sp->GetID ()); 2540 2541 // Tell the thread state coordinator about the stop. 2542 NotifyThreadStop (thread_sp->GetID ()); 2543 } 2544 2545 // Done handling. 2546 return; 2547 } 2548 2549 if (log) 2550 log->Printf ("NativeProcessLinux::%s() received signal %s", __FUNCTION__, GetUnixSignals ().GetSignalAsCString (signo)); 2551 2552 switch (signo) 2553 { 2554 case SIGSEGV: 2555 case SIGABRT: 2556 case SIGILL: 2557 case SIGFPE: 2558 case SIGBUS: 2559 { 2560 // This thread is stopped. 2561 NotifyThreadStop (pid); 2562 2563 // lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr); 2564 2565 // This is just a pre-signal-delivery notification of the incoming signal. 2566 if (thread_sp) 2567 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStoppedBySignal (signo); 2568 2569 // We can get more details on the exact nature of the crash here. 2570 // ProcessMessage::CrashReason reason = GetCrashReasonForSIGSEGV(info); 2571 if (!exited) 2572 { 2573 // Send a stop to the debugger after we get all other threads to stop. 2574 CallAfterRunningThreadsStop (pid, 2575 [=] (lldb::tid_t signaling_tid) 2576 { 2577 SetCurrentThreadID (signaling_tid); 2578 SetState (StateType::eStateStopped, true); 2579 }); 2580 } 2581 else 2582 { 2583 // FIXME the process might die right after this - might not ever get stops on any other threads. 2584 // Send a stop to the debugger after we get all other threads to stop. 2585 CallAfterRunningThreadsStop (pid, 2586 [=] (lldb::tid_t signaling_tid) 2587 { 2588 SetCurrentThreadID (signaling_tid); 2589 SetState (StateType::eStateCrashed, true); 2590 }); 2591 } 2592 } 2593 break; 2594 2595 case SIGSTOP: 2596 { 2597 // This thread is stopped. 2598 NotifyThreadStop (pid); 2599 2600 if (log) 2601 { 2602 if (is_from_llgs) 2603 log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " received SIGSTOP from llgs, most likely an interrupt", __FUNCTION__, GetID (), pid); 2604 else 2605 log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " received SIGSTOP from outside of debugger", __FUNCTION__, GetID (), pid); 2606 } 2607 2608 // Resume this thread to get the group-stop mechanism to fire off the true group stops. 2609 // This thread will get stopped again as part of the group-stop completion. 2610 m_coordinator_up->RequestThreadResume (pid, 2611 [=](lldb::tid_t tid_to_resume) 2612 { 2613 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2614 // Pass this signal number on to the inferior to handle. 2615 Resume (tid_to_resume, signo); 2616 }, 2617 CoordinatorErrorHandler); 2618 2619 // And now we want to signal that we received a SIGSTOP on this thread 2620 // as soon as all running threads stop (i.e. the group stop sequence completes). 2621 CallAfterRunningThreadsStop (pid, 2622 [=] (lldb::tid_t signaling_tid) 2623 { 2624 SetCurrentThreadID (signaling_tid); 2625 SetState (StateType::eStateStopped, true); 2626 }); 2627 break; 2628 } 2629 2630 default: 2631 { 2632 // This thread is stopped. 2633 NotifyThreadStop (pid); 2634 2635 if (log) 2636 log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " resuming thread with signal %s (%d)", __FUNCTION__, GetID (), pid, GetUnixSignals().GetSignalAsCString (signo), signo); 2637 2638 // Pass the signal on to the inferior. 2639 m_coordinator_up->RequestThreadResume (pid, 2640 [=](lldb::tid_t tid_to_resume) 2641 { 2642 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2643 // Pass this signal number on to the inferior to handle. 2644 Resume (tid_to_resume, signo); 2645 }, 2646 CoordinatorErrorHandler); 2647 } 2648 break; 2649 } 2650 } 2651 2652 Error 2653 NativeProcessLinux::Resume (const ResumeActionList &resume_actions) 2654 { 2655 Error error; 2656 2657 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 2658 if (log) 2659 log->Printf ("NativeProcessLinux::%s called: pid %" PRIu64, __FUNCTION__, GetID ()); 2660 2661 lldb::tid_t deferred_signal_tid = LLDB_INVALID_THREAD_ID; 2662 lldb::tid_t deferred_signal_skip_tid = LLDB_INVALID_THREAD_ID; 2663 int deferred_signo = 0; 2664 NativeThreadProtocolSP deferred_signal_thread_sp; 2665 int resume_count = 0; 2666 2667 2668 // std::vector<NativeThreadProtocolSP> new_stop_threads; 2669 2670 // Scope for threads mutex. 2671 { 2672 Mutex::Locker locker (m_threads_mutex); 2673 for (auto thread_sp : m_threads) 2674 { 2675 assert (thread_sp && "thread list should not contain NULL threads"); 2676 2677 const ResumeAction *const action = resume_actions.GetActionForThread (thread_sp->GetID (), true); 2678 assert (action && "NULL ResumeAction returned for thread during Resume ()"); 2679 2680 if (log) 2681 { 2682 log->Printf ("NativeProcessLinux::%s processing resume action state %s for pid %" PRIu64 " tid %" PRIu64, 2683 __FUNCTION__, StateAsCString (action->state), GetID (), thread_sp->GetID ()); 2684 } 2685 2686 switch (action->state) 2687 { 2688 case eStateRunning: 2689 { 2690 // Run the thread, possibly feeding it the signal. 2691 const int signo = action->signal; 2692 m_coordinator_up->RequestThreadResume (thread_sp->GetID (), 2693 [=](lldb::tid_t tid_to_resume) 2694 { 2695 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetRunning (); 2696 // Pass this signal number on to the inferior to handle. 2697 Resume (tid_to_resume, (signo > 0) ? signo : LLDB_INVALID_SIGNAL_NUMBER); 2698 }, 2699 CoordinatorErrorHandler); 2700 ++resume_count; 2701 break; 2702 } 2703 2704 case eStateStepping: 2705 { 2706 // Request the step. 2707 const int signo = action->signal; 2708 m_coordinator_up->RequestThreadResume (thread_sp->GetID (), 2709 [=](lldb::tid_t tid_to_step) 2710 { 2711 reinterpret_cast<NativeThreadLinux*> (thread_sp.get ())->SetStepping (); 2712 auto step_result = SingleStep (tid_to_step,(signo > 0) ? signo : LLDB_INVALID_SIGNAL_NUMBER); 2713 assert (step_result && "SingleStep() failed"); 2714 }, 2715 CoordinatorErrorHandler); 2716 2717 // The deferred signal tid is the stepping tid. 2718 // This assumes there is only one stepping tid, or the last stepping tid is a fine choice. 2719 deferred_signal_tid = thread_sp->GetID (); 2720 deferred_signal_thread_sp = thread_sp; 2721 2722 // Don't send a stop request to this thread. The thread resume request 2723 // above will actually run the step thread, and it will finish the step 2724 // by sending a SIGTRAP with the appropriate bits set. So, the deferred 2725 // signal call that happens at the end of the loop below needs to let 2726 // the pending signal handling to *not* send a stop for this thread here 2727 // since the start/stop step functionality will end up with a stop state. 2728 // Otherwise, this stepping thread will get sent an erroneous tgkill for 2729 // with a SIGSTOP signal. 2730 deferred_signal_skip_tid = thread_sp->GetID (); 2731 2732 // And the stop signal we should apply for it is a SIGTRAP. 2733 deferred_signo = SIGTRAP; 2734 break; 2735 } 2736 2737 case eStateSuspended: 2738 case eStateStopped: 2739 // if we haven't chosen a deferred signal tid yet, use this one. 2740 if (deferred_signal_tid == LLDB_INVALID_THREAD_ID) 2741 { 2742 deferred_signal_tid = thread_sp->GetID (); 2743 deferred_signal_thread_sp = thread_sp; 2744 deferred_signo = SIGSTOP; 2745 } 2746 break; 2747 2748 default: 2749 return Error ("NativeProcessLinux::%s (): unexpected state %s specified for pid %" PRIu64 ", tid %" PRIu64, 2750 __FUNCTION__, StateAsCString (action->state), GetID (), thread_sp->GetID ()); 2751 } 2752 } 2753 } 2754 2755 // If we resumed anything, this command was about starting a stopped thread, 2756 // not about stopping something that we should trigger later. 2757 if (resume_count > 0) 2758 return error; 2759 2760 // If we had any thread stopping, then do a deferred notification of the chosen stop thread id and signal 2761 // after all other running threads have stopped. 2762 if (deferred_signal_tid != LLDB_INVALID_THREAD_ID) 2763 { 2764 CallAfterRunningThreadsStopWithSkipTID (deferred_signal_tid, 2765 deferred_signal_skip_tid, 2766 [=](lldb::tid_t deferred_notification_tid) 2767 { 2768 // Set the signal thread to the current thread. 2769 SetCurrentThreadID (deferred_notification_tid); 2770 2771 // Set the thread state as stopped by the deferred signo. 2772 reinterpret_cast<NativeThreadLinux*> (deferred_signal_thread_sp.get ())->SetStoppedBySignal (deferred_signo); 2773 2774 // Tell the process delegate that the process is in a stopped state. 2775 SetState (StateType::eStateStopped, true); 2776 }); 2777 } 2778 2779 return error; 2780 } 2781 2782 Error 2783 NativeProcessLinux::Halt () 2784 { 2785 Error error; 2786 2787 if (kill (GetID (), SIGSTOP) != 0) 2788 error.SetErrorToErrno (); 2789 2790 return error; 2791 } 2792 2793 Error 2794 NativeProcessLinux::Detach () 2795 { 2796 Error error; 2797 2798 // Tell ptrace to detach from the process. 2799 if (GetID () != LLDB_INVALID_PROCESS_ID) 2800 error = Detach (GetID ()); 2801 2802 // Stop monitoring the inferior. 2803 StopMonitor (); 2804 2805 // No error. 2806 return error; 2807 } 2808 2809 Error 2810 NativeProcessLinux::Signal (int signo) 2811 { 2812 Error error; 2813 2814 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2815 if (log) 2816 log->Printf ("NativeProcessLinux::%s: sending signal %d (%s) to pid %" PRIu64, 2817 __FUNCTION__, signo, GetUnixSignals ().GetSignalAsCString (signo), GetID ()); 2818 2819 if (kill(GetID(), signo)) 2820 error.SetErrorToErrno(); 2821 2822 return error; 2823 } 2824 2825 Error 2826 NativeProcessLinux::Kill () 2827 { 2828 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2829 if (log) 2830 log->Printf ("NativeProcessLinux::%s called for PID %" PRIu64, __FUNCTION__, GetID ()); 2831 2832 Error error; 2833 2834 switch (m_state) 2835 { 2836 case StateType::eStateInvalid: 2837 case StateType::eStateExited: 2838 case StateType::eStateCrashed: 2839 case StateType::eStateDetached: 2840 case StateType::eStateUnloaded: 2841 // Nothing to do - the process is already dead. 2842 if (log) 2843 log->Printf ("NativeProcessLinux::%s ignored for PID %" PRIu64 " due to current state: %s", __FUNCTION__, GetID (), StateAsCString (m_state)); 2844 return error; 2845 2846 case StateType::eStateConnected: 2847 case StateType::eStateAttaching: 2848 case StateType::eStateLaunching: 2849 case StateType::eStateStopped: 2850 case StateType::eStateRunning: 2851 case StateType::eStateStepping: 2852 case StateType::eStateSuspended: 2853 // We can try to kill a process in these states. 2854 break; 2855 } 2856 2857 if (kill (GetID (), SIGKILL) != 0) 2858 { 2859 error.SetErrorToErrno (); 2860 return error; 2861 } 2862 2863 return error; 2864 } 2865 2866 static Error 2867 ParseMemoryRegionInfoFromProcMapsLine (const std::string &maps_line, MemoryRegionInfo &memory_region_info) 2868 { 2869 memory_region_info.Clear(); 2870 2871 StringExtractor line_extractor (maps_line.c_str ()); 2872 2873 // Format: {address_start_hex}-{address_end_hex} perms offset dev inode pathname 2874 // perms: rwxp (letter is present if set, '-' if not, final character is p=private, s=shared). 2875 2876 // Parse out the starting address 2877 lldb::addr_t start_address = line_extractor.GetHexMaxU64 (false, 0); 2878 2879 // Parse out hyphen separating start and end address from range. 2880 if (!line_extractor.GetBytesLeft () || (line_extractor.GetChar () != '-')) 2881 return Error ("malformed /proc/{pid}/maps entry, missing dash between address range"); 2882 2883 // Parse out the ending address 2884 lldb::addr_t end_address = line_extractor.GetHexMaxU64 (false, start_address); 2885 2886 // Parse out the space after the address. 2887 if (!line_extractor.GetBytesLeft () || (line_extractor.GetChar () != ' ')) 2888 return Error ("malformed /proc/{pid}/maps entry, missing space after range"); 2889 2890 // Save the range. 2891 memory_region_info.GetRange ().SetRangeBase (start_address); 2892 memory_region_info.GetRange ().SetRangeEnd (end_address); 2893 2894 // Parse out each permission entry. 2895 if (line_extractor.GetBytesLeft () < 4) 2896 return Error ("malformed /proc/{pid}/maps entry, missing some portion of permissions"); 2897 2898 // Handle read permission. 2899 const char read_perm_char = line_extractor.GetChar (); 2900 if (read_perm_char == 'r') 2901 memory_region_info.SetReadable (MemoryRegionInfo::OptionalBool::eYes); 2902 else 2903 { 2904 assert ( (read_perm_char == '-') && "unexpected /proc/{pid}/maps read permission char" ); 2905 memory_region_info.SetReadable (MemoryRegionInfo::OptionalBool::eNo); 2906 } 2907 2908 // Handle write permission. 2909 const char write_perm_char = line_extractor.GetChar (); 2910 if (write_perm_char == 'w') 2911 memory_region_info.SetWritable (MemoryRegionInfo::OptionalBool::eYes); 2912 else 2913 { 2914 assert ( (write_perm_char == '-') && "unexpected /proc/{pid}/maps write permission char" ); 2915 memory_region_info.SetWritable (MemoryRegionInfo::OptionalBool::eNo); 2916 } 2917 2918 // Handle execute permission. 2919 const char exec_perm_char = line_extractor.GetChar (); 2920 if (exec_perm_char == 'x') 2921 memory_region_info.SetExecutable (MemoryRegionInfo::OptionalBool::eYes); 2922 else 2923 { 2924 assert ( (exec_perm_char == '-') && "unexpected /proc/{pid}/maps exec permission char" ); 2925 memory_region_info.SetExecutable (MemoryRegionInfo::OptionalBool::eNo); 2926 } 2927 2928 return Error (); 2929 } 2930 2931 Error 2932 NativeProcessLinux::GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info) 2933 { 2934 // FIXME review that the final memory region returned extends to the end of the virtual address space, 2935 // with no perms if it is not mapped. 2936 2937 // Use an approach that reads memory regions from /proc/{pid}/maps. 2938 // Assume proc maps entries are in ascending order. 2939 // FIXME assert if we find differently. 2940 Mutex::Locker locker (m_mem_region_cache_mutex); 2941 2942 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2943 Error error; 2944 2945 if (m_supports_mem_region == LazyBool::eLazyBoolNo) 2946 { 2947 // We're done. 2948 error.SetErrorString ("unsupported"); 2949 return error; 2950 } 2951 2952 // If our cache is empty, pull the latest. There should always be at least one memory region 2953 // if memory region handling is supported. 2954 if (m_mem_region_cache.empty ()) 2955 { 2956 error = ProcFileReader::ProcessLineByLine (GetID (), "maps", 2957 [&] (const std::string &line) -> bool 2958 { 2959 MemoryRegionInfo info; 2960 const Error parse_error = ParseMemoryRegionInfoFromProcMapsLine (line, info); 2961 if (parse_error.Success ()) 2962 { 2963 m_mem_region_cache.push_back (info); 2964 return true; 2965 } 2966 else 2967 { 2968 if (log) 2969 log->Printf ("NativeProcessLinux::%s failed to parse proc maps line '%s': %s", __FUNCTION__, line.c_str (), error.AsCString ()); 2970 return false; 2971 } 2972 }); 2973 2974 // If we had an error, we'll mark unsupported. 2975 if (error.Fail ()) 2976 { 2977 m_supports_mem_region = LazyBool::eLazyBoolNo; 2978 return error; 2979 } 2980 else if (m_mem_region_cache.empty ()) 2981 { 2982 // No entries after attempting to read them. This shouldn't happen if /proc/{pid}/maps 2983 // is supported. Assume we don't support map entries via procfs. 2984 if (log) 2985 log->Printf ("NativeProcessLinux::%s failed to find any procfs maps entries, assuming no support for memory region metadata retrieval", __FUNCTION__); 2986 m_supports_mem_region = LazyBool::eLazyBoolNo; 2987 error.SetErrorString ("not supported"); 2988 return error; 2989 } 2990 2991 if (log) 2992 log->Printf ("NativeProcessLinux::%s read %" PRIu64 " memory region entries from /proc/%" PRIu64 "/maps", __FUNCTION__, static_cast<uint64_t> (m_mem_region_cache.size ()), GetID ()); 2993 2994 // We support memory retrieval, remember that. 2995 m_supports_mem_region = LazyBool::eLazyBoolYes; 2996 } 2997 else 2998 { 2999 if (log) 3000 log->Printf ("NativeProcessLinux::%s reusing %" PRIu64 " cached memory region entries", __FUNCTION__, static_cast<uint64_t> (m_mem_region_cache.size ())); 3001 } 3002 3003 lldb::addr_t prev_base_address = 0; 3004 3005 // FIXME start by finding the last region that is <= target address using binary search. Data is sorted. 3006 // There can be a ton of regions on pthreads apps with lots of threads. 3007 for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end (); ++it) 3008 { 3009 MemoryRegionInfo &proc_entry_info = *it; 3010 3011 // Sanity check assumption that /proc/{pid}/maps entries are ascending. 3012 assert ((proc_entry_info.GetRange ().GetRangeBase () >= prev_base_address) && "descending /proc/pid/maps entries detected, unexpected"); 3013 prev_base_address = proc_entry_info.GetRange ().GetRangeBase (); 3014 3015 // If the target address comes before this entry, indicate distance to next region. 3016 if (load_addr < proc_entry_info.GetRange ().GetRangeBase ()) 3017 { 3018 range_info.GetRange ().SetRangeBase (load_addr); 3019 range_info.GetRange ().SetByteSize (proc_entry_info.GetRange ().GetRangeBase () - load_addr); 3020 range_info.SetReadable (MemoryRegionInfo::OptionalBool::eNo); 3021 range_info.SetWritable (MemoryRegionInfo::OptionalBool::eNo); 3022 range_info.SetExecutable (MemoryRegionInfo::OptionalBool::eNo); 3023 3024 return error; 3025 } 3026 else if (proc_entry_info.GetRange ().Contains (load_addr)) 3027 { 3028 // The target address is within the memory region we're processing here. 3029 range_info = proc_entry_info; 3030 return error; 3031 } 3032 3033 // The target memory address comes somewhere after the region we just parsed. 3034 } 3035 3036 // If we made it here, we didn't find an entry that contained the given address. 3037 error.SetErrorString ("address comes after final region"); 3038 3039 if (log) 3040 log->Printf ("NativeProcessLinux::%s failed to find map entry for address 0x%" PRIx64 ": %s", __FUNCTION__, load_addr, error.AsCString ()); 3041 3042 return error; 3043 } 3044 3045 void 3046 NativeProcessLinux::DoStopIDBumped (uint32_t newBumpId) 3047 { 3048 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 3049 if (log) 3050 log->Printf ("NativeProcessLinux::%s(newBumpId=%" PRIu32 ") called", __FUNCTION__, newBumpId); 3051 3052 { 3053 Mutex::Locker locker (m_mem_region_cache_mutex); 3054 if (log) 3055 log->Printf ("NativeProcessLinux::%s clearing %" PRIu64 " entries from the cache", __FUNCTION__, static_cast<uint64_t> (m_mem_region_cache.size ())); 3056 m_mem_region_cache.clear (); 3057 } 3058 } 3059 3060 Error 3061 NativeProcessLinux::AllocateMemory ( 3062 lldb::addr_t size, 3063 uint32_t permissions, 3064 lldb::addr_t &addr) 3065 { 3066 // FIXME implementing this requires the equivalent of 3067 // InferiorCallPOSIX::InferiorCallMmap, which depends on 3068 // functional ThreadPlans working with Native*Protocol. 3069 #if 1 3070 return Error ("not implemented yet"); 3071 #else 3072 addr = LLDB_INVALID_ADDRESS; 3073 3074 unsigned prot = 0; 3075 if (permissions & lldb::ePermissionsReadable) 3076 prot |= eMmapProtRead; 3077 if (permissions & lldb::ePermissionsWritable) 3078 prot |= eMmapProtWrite; 3079 if (permissions & lldb::ePermissionsExecutable) 3080 prot |= eMmapProtExec; 3081 3082 // TODO implement this directly in NativeProcessLinux 3083 // (and lift to NativeProcessPOSIX if/when that class is 3084 // refactored out). 3085 if (InferiorCallMmap(this, addr, 0, size, prot, 3086 eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) { 3087 m_addr_to_mmap_size[addr] = size; 3088 return Error (); 3089 } else { 3090 addr = LLDB_INVALID_ADDRESS; 3091 return Error("unable to allocate %" PRIu64 " bytes of memory with permissions %s", size, GetPermissionsAsCString (permissions)); 3092 } 3093 #endif 3094 } 3095 3096 Error 3097 NativeProcessLinux::DeallocateMemory (lldb::addr_t addr) 3098 { 3099 // FIXME see comments in AllocateMemory - required lower-level 3100 // bits not in place yet (ThreadPlans) 3101 return Error ("not implemented"); 3102 } 3103 3104 lldb::addr_t 3105 NativeProcessLinux::GetSharedLibraryInfoAddress () 3106 { 3107 #if 1 3108 // punt on this for now 3109 return LLDB_INVALID_ADDRESS; 3110 #else 3111 // Return the image info address for the exe module 3112 #if 1 3113 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 3114 3115 ModuleSP module_sp; 3116 Error error = GetExeModuleSP (module_sp); 3117 if (error.Fail ()) 3118 { 3119 if (log) 3120 log->Warning ("NativeProcessLinux::%s failed to retrieve exe module: %s", __FUNCTION__, error.AsCString ()); 3121 return LLDB_INVALID_ADDRESS; 3122 } 3123 3124 if (module_sp == nullptr) 3125 { 3126 if (log) 3127 log->Warning ("NativeProcessLinux::%s exe module returned was NULL", __FUNCTION__); 3128 return LLDB_INVALID_ADDRESS; 3129 } 3130 3131 ObjectFileSP object_file_sp = module_sp->GetObjectFile (); 3132 if (object_file_sp == nullptr) 3133 { 3134 if (log) 3135 log->Warning ("NativeProcessLinux::%s exe module returned a NULL object file", __FUNCTION__); 3136 return LLDB_INVALID_ADDRESS; 3137 } 3138 3139 return obj_file_sp->GetImageInfoAddress(); 3140 #else 3141 Target *target = &GetTarget(); 3142 ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile(); 3143 Address addr = obj_file->GetImageInfoAddress(target); 3144 3145 if (addr.IsValid()) 3146 return addr.GetLoadAddress(target); 3147 return LLDB_INVALID_ADDRESS; 3148 #endif 3149 #endif // punt on this for now 3150 } 3151 3152 size_t 3153 NativeProcessLinux::UpdateThreads () 3154 { 3155 // The NativeProcessLinux monitoring threads are always up to date 3156 // with respect to thread state and they keep the thread list 3157 // populated properly. All this method needs to do is return the 3158 // thread count. 3159 Mutex::Locker locker (m_threads_mutex); 3160 return m_threads.size (); 3161 } 3162 3163 bool 3164 NativeProcessLinux::GetArchitecture (ArchSpec &arch) const 3165 { 3166 arch = m_arch; 3167 return true; 3168 } 3169 3170 Error 3171 NativeProcessLinux::GetSoftwareBreakpointSize (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size) 3172 { 3173 // FIXME put this behind a breakpoint protocol class that can be 3174 // set per architecture. Need ARM, MIPS support here. 3175 static const uint8_t g_aarch64_opcode[] = { 0x00, 0x00, 0x20, 0xd4 }; 3176 static const uint8_t g_i386_opcode [] = { 0xCC }; 3177 3178 switch (m_arch.GetMachine ()) 3179 { 3180 case llvm::Triple::aarch64: 3181 actual_opcode_size = static_cast<uint32_t> (sizeof(g_aarch64_opcode)); 3182 return Error (); 3183 3184 case llvm::Triple::x86: 3185 case llvm::Triple::x86_64: 3186 actual_opcode_size = static_cast<uint32_t> (sizeof(g_i386_opcode)); 3187 return Error (); 3188 3189 default: 3190 assert(false && "CPU type not supported!"); 3191 return Error ("CPU type not supported"); 3192 } 3193 } 3194 3195 Error 3196 NativeProcessLinux::SetBreakpoint (lldb::addr_t addr, uint32_t size, bool hardware) 3197 { 3198 if (hardware) 3199 return Error ("NativeProcessLinux does not support hardware breakpoints"); 3200 else 3201 return SetSoftwareBreakpoint (addr, size); 3202 } 3203 3204 Error 3205 NativeProcessLinux::GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) 3206 { 3207 // FIXME put this behind a breakpoint protocol class that can be 3208 // set per architecture. Need ARM, MIPS support here. 3209 static const uint8_t g_aarch64_opcode[] = { 0x00, 0x00, 0x20, 0xd4 }; 3210 static const uint8_t g_i386_opcode [] = { 0xCC }; 3211 3212 switch (m_arch.GetMachine ()) 3213 { 3214 case llvm::Triple::aarch64: 3215 trap_opcode_bytes = g_aarch64_opcode; 3216 actual_opcode_size = sizeof(g_aarch64_opcode); 3217 return Error (); 3218 3219 case llvm::Triple::x86: 3220 case llvm::Triple::x86_64: 3221 trap_opcode_bytes = g_i386_opcode; 3222 actual_opcode_size = sizeof(g_i386_opcode); 3223 return Error (); 3224 3225 default: 3226 assert(false && "CPU type not supported!"); 3227 return Error ("CPU type not supported"); 3228 } 3229 } 3230 3231 #if 0 3232 ProcessMessage::CrashReason 3233 NativeProcessLinux::GetCrashReasonForSIGSEGV(const siginfo_t *info) 3234 { 3235 ProcessMessage::CrashReason reason; 3236 assert(info->si_signo == SIGSEGV); 3237 3238 reason = ProcessMessage::eInvalidCrashReason; 3239 3240 switch (info->si_code) 3241 { 3242 default: 3243 assert(false && "unexpected si_code for SIGSEGV"); 3244 break; 3245 case SI_KERNEL: 3246 // Linux will occasionally send spurious SI_KERNEL codes. 3247 // (this is poorly documented in sigaction) 3248 // One way to get this is via unaligned SIMD loads. 3249 reason = ProcessMessage::eInvalidAddress; // for lack of anything better 3250 break; 3251 case SEGV_MAPERR: 3252 reason = ProcessMessage::eInvalidAddress; 3253 break; 3254 case SEGV_ACCERR: 3255 reason = ProcessMessage::ePrivilegedAddress; 3256 break; 3257 } 3258 3259 return reason; 3260 } 3261 #endif 3262 3263 3264 #if 0 3265 ProcessMessage::CrashReason 3266 NativeProcessLinux::GetCrashReasonForSIGILL(const siginfo_t *info) 3267 { 3268 ProcessMessage::CrashReason reason; 3269 assert(info->si_signo == SIGILL); 3270 3271 reason = ProcessMessage::eInvalidCrashReason; 3272 3273 switch (info->si_code) 3274 { 3275 default: 3276 assert(false && "unexpected si_code for SIGILL"); 3277 break; 3278 case ILL_ILLOPC: 3279 reason = ProcessMessage::eIllegalOpcode; 3280 break; 3281 case ILL_ILLOPN: 3282 reason = ProcessMessage::eIllegalOperand; 3283 break; 3284 case ILL_ILLADR: 3285 reason = ProcessMessage::eIllegalAddressingMode; 3286 break; 3287 case ILL_ILLTRP: 3288 reason = ProcessMessage::eIllegalTrap; 3289 break; 3290 case ILL_PRVOPC: 3291 reason = ProcessMessage::ePrivilegedOpcode; 3292 break; 3293 case ILL_PRVREG: 3294 reason = ProcessMessage::ePrivilegedRegister; 3295 break; 3296 case ILL_COPROC: 3297 reason = ProcessMessage::eCoprocessorError; 3298 break; 3299 case ILL_BADSTK: 3300 reason = ProcessMessage::eInternalStackError; 3301 break; 3302 } 3303 3304 return reason; 3305 } 3306 #endif 3307 3308 #if 0 3309 ProcessMessage::CrashReason 3310 NativeProcessLinux::GetCrashReasonForSIGFPE(const siginfo_t *info) 3311 { 3312 ProcessMessage::CrashReason reason; 3313 assert(info->si_signo == SIGFPE); 3314 3315 reason = ProcessMessage::eInvalidCrashReason; 3316 3317 switch (info->si_code) 3318 { 3319 default: 3320 assert(false && "unexpected si_code for SIGFPE"); 3321 break; 3322 case FPE_INTDIV: 3323 reason = ProcessMessage::eIntegerDivideByZero; 3324 break; 3325 case FPE_INTOVF: 3326 reason = ProcessMessage::eIntegerOverflow; 3327 break; 3328 case FPE_FLTDIV: 3329 reason = ProcessMessage::eFloatDivideByZero; 3330 break; 3331 case FPE_FLTOVF: 3332 reason = ProcessMessage::eFloatOverflow; 3333 break; 3334 case FPE_FLTUND: 3335 reason = ProcessMessage::eFloatUnderflow; 3336 break; 3337 case FPE_FLTRES: 3338 reason = ProcessMessage::eFloatInexactResult; 3339 break; 3340 case FPE_FLTINV: 3341 reason = ProcessMessage::eFloatInvalidOperation; 3342 break; 3343 case FPE_FLTSUB: 3344 reason = ProcessMessage::eFloatSubscriptRange; 3345 break; 3346 } 3347 3348 return reason; 3349 } 3350 #endif 3351 3352 #if 0 3353 ProcessMessage::CrashReason 3354 NativeProcessLinux::GetCrashReasonForSIGBUS(const siginfo_t *info) 3355 { 3356 ProcessMessage::CrashReason reason; 3357 assert(info->si_signo == SIGBUS); 3358 3359 reason = ProcessMessage::eInvalidCrashReason; 3360 3361 switch (info->si_code) 3362 { 3363 default: 3364 assert(false && "unexpected si_code for SIGBUS"); 3365 break; 3366 case BUS_ADRALN: 3367 reason = ProcessMessage::eIllegalAlignment; 3368 break; 3369 case BUS_ADRERR: 3370 reason = ProcessMessage::eIllegalAddress; 3371 break; 3372 case BUS_OBJERR: 3373 reason = ProcessMessage::eHardwareError; 3374 break; 3375 } 3376 3377 return reason; 3378 } 3379 #endif 3380 3381 void 3382 NativeProcessLinux::ServeOperation(OperationArgs *args) 3383 { 3384 NativeProcessLinux *monitor = args->m_monitor; 3385 3386 // We are finised with the arguments and are ready to go. Sync with the 3387 // parent thread and start serving operations on the inferior. 3388 sem_post(&args->m_semaphore); 3389 3390 for(;;) 3391 { 3392 // wait for next pending operation 3393 if (sem_wait(&monitor->m_operation_pending)) 3394 { 3395 if (errno == EINTR) 3396 continue; 3397 assert(false && "Unexpected errno from sem_wait"); 3398 } 3399 3400 reinterpret_cast<Operation*>(monitor->m_operation)->Execute(monitor); 3401 3402 // notify calling thread that operation is complete 3403 sem_post(&monitor->m_operation_done); 3404 } 3405 } 3406 3407 void 3408 NativeProcessLinux::DoOperation(void *op) 3409 { 3410 Mutex::Locker lock(m_operation_mutex); 3411 3412 m_operation = op; 3413 3414 // notify operation thread that an operation is ready to be processed 3415 sem_post(&m_operation_pending); 3416 3417 // wait for operation to complete 3418 while (sem_wait(&m_operation_done)) 3419 { 3420 if (errno == EINTR) 3421 continue; 3422 assert(false && "Unexpected errno from sem_wait"); 3423 } 3424 } 3425 3426 Error 3427 NativeProcessLinux::ReadMemory (lldb::addr_t addr, void *buf, lldb::addr_t size, lldb::addr_t &bytes_read) 3428 { 3429 ReadOperation op(addr, buf, size, bytes_read); 3430 DoOperation(&op); 3431 return op.GetError (); 3432 } 3433 3434 Error 3435 NativeProcessLinux::WriteMemory (lldb::addr_t addr, const void *buf, lldb::addr_t size, lldb::addr_t &bytes_written) 3436 { 3437 WriteOperation op(addr, buf, size, bytes_written); 3438 DoOperation(&op); 3439 return op.GetError (); 3440 } 3441 3442 bool 3443 NativeProcessLinux::ReadRegisterValue(lldb::tid_t tid, uint32_t offset, const char* reg_name, 3444 uint32_t size, RegisterValue &value) 3445 { 3446 bool result; 3447 ReadRegOperation op(tid, offset, reg_name, value, result); 3448 DoOperation(&op); 3449 return result; 3450 } 3451 3452 bool 3453 NativeProcessLinux::WriteRegisterValue(lldb::tid_t tid, unsigned offset, 3454 const char* reg_name, const RegisterValue &value) 3455 { 3456 bool result; 3457 WriteRegOperation op(tid, offset, reg_name, value, result); 3458 DoOperation(&op); 3459 return result; 3460 } 3461 3462 bool 3463 NativeProcessLinux::ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size) 3464 { 3465 bool result; 3466 ReadGPROperation op(tid, buf, buf_size, result); 3467 DoOperation(&op); 3468 return result; 3469 } 3470 3471 bool 3472 NativeProcessLinux::ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size) 3473 { 3474 bool result; 3475 ReadFPROperation op(tid, buf, buf_size, result); 3476 DoOperation(&op); 3477 return result; 3478 } 3479 3480 bool 3481 NativeProcessLinux::ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset) 3482 { 3483 bool result; 3484 ReadRegisterSetOperation op(tid, buf, buf_size, regset, result); 3485 DoOperation(&op); 3486 return result; 3487 } 3488 3489 bool 3490 NativeProcessLinux::WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size) 3491 { 3492 bool result; 3493 WriteGPROperation op(tid, buf, buf_size, result); 3494 DoOperation(&op); 3495 return result; 3496 } 3497 3498 bool 3499 NativeProcessLinux::WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size) 3500 { 3501 bool result; 3502 WriteFPROperation op(tid, buf, buf_size, result); 3503 DoOperation(&op); 3504 return result; 3505 } 3506 3507 bool 3508 NativeProcessLinux::WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset) 3509 { 3510 bool result; 3511 WriteRegisterSetOperation op(tid, buf, buf_size, regset, result); 3512 DoOperation(&op); 3513 return result; 3514 } 3515 3516 bool 3517 NativeProcessLinux::Resume (lldb::tid_t tid, uint32_t signo) 3518 { 3519 bool result; 3520 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 3521 3522 if (log) 3523 log->Printf ("NativeProcessLinux::%s() resuming thread = %" PRIu64 " with signal %s", __FUNCTION__, tid, 3524 GetUnixSignals().GetSignalAsCString (signo)); 3525 ResumeOperation op (tid, signo, result); 3526 DoOperation (&op); 3527 if (log) 3528 log->Printf ("NativeProcessLinux::%s() resuming result = %s", __FUNCTION__, result ? "true" : "false"); 3529 return result; 3530 } 3531 3532 bool 3533 NativeProcessLinux::SingleStep(lldb::tid_t tid, uint32_t signo) 3534 { 3535 bool result; 3536 SingleStepOperation op(tid, signo, result); 3537 DoOperation(&op); 3538 return result; 3539 } 3540 3541 bool 3542 NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo, int &ptrace_err) 3543 { 3544 bool result; 3545 SiginfoOperation op(tid, siginfo, result, ptrace_err); 3546 DoOperation(&op); 3547 return result; 3548 } 3549 3550 bool 3551 NativeProcessLinux::GetEventMessage(lldb::tid_t tid, unsigned long *message) 3552 { 3553 bool result; 3554 EventMessageOperation op(tid, message, result); 3555 DoOperation(&op); 3556 return result; 3557 } 3558 3559 lldb_private::Error 3560 NativeProcessLinux::Detach(lldb::tid_t tid) 3561 { 3562 lldb_private::Error error; 3563 if (tid != LLDB_INVALID_THREAD_ID) 3564 { 3565 DetachOperation op(tid, error); 3566 DoOperation(&op); 3567 } 3568 return error; 3569 } 3570 3571 bool 3572 NativeProcessLinux::DupDescriptor(const char *path, int fd, int flags) 3573 { 3574 int target_fd = open(path, flags, 0666); 3575 3576 if (target_fd == -1) 3577 return false; 3578 3579 return (dup2(target_fd, fd) == -1) ? false : true; 3580 } 3581 3582 void 3583 NativeProcessLinux::StopMonitoringChildProcess() 3584 { 3585 if (m_monitor_thread.IsJoinable()) 3586 { 3587 m_monitor_thread.Cancel(); 3588 m_monitor_thread.Join(nullptr); 3589 } 3590 } 3591 3592 void 3593 NativeProcessLinux::StopMonitor() 3594 { 3595 StopMonitoringChildProcess(); 3596 StopOpThread(); 3597 StopCoordinatorThread (); 3598 sem_destroy(&m_operation_pending); 3599 sem_destroy(&m_operation_done); 3600 3601 // TODO: validate whether this still holds, fix up comment. 3602 // Note: ProcessPOSIX passes the m_terminal_fd file descriptor to 3603 // Process::SetSTDIOFileDescriptor, which in turn transfers ownership of 3604 // the descriptor to a ConnectionFileDescriptor object. Consequently 3605 // even though still has the file descriptor, we shouldn't close it here. 3606 } 3607 3608 void 3609 NativeProcessLinux::StopOpThread() 3610 { 3611 if (!m_operation_thread.IsJoinable()) 3612 return; 3613 3614 m_operation_thread.Cancel(); 3615 m_operation_thread.Join(nullptr); 3616 } 3617 3618 Error 3619 NativeProcessLinux::StartCoordinatorThread () 3620 { 3621 Error error; 3622 static const char *g_thread_name = "lldb.process.linux.ts_coordinator"; 3623 Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3624 3625 // Skip if thread is already running 3626 if (m_coordinator_thread.IsJoinable()) 3627 { 3628 error.SetErrorString ("ThreadStateCoordinator's run loop is already running"); 3629 if (log) 3630 log->Printf ("NativeProcessLinux::%s %s", __FUNCTION__, error.AsCString ()); 3631 return error; 3632 } 3633 3634 // Enable verbose logging if lldb thread logging is enabled. 3635 m_coordinator_up->LogEnableEventProcessing (log != nullptr); 3636 3637 if (log) 3638 log->Printf ("NativeProcessLinux::%s launching ThreadStateCoordinator thread for pid %" PRIu64, __FUNCTION__, GetID ()); 3639 m_coordinator_thread = ThreadLauncher::LaunchThread(g_thread_name, CoordinatorThread, this, &error); 3640 return error; 3641 } 3642 3643 void * 3644 NativeProcessLinux::CoordinatorThread (void *arg) 3645 { 3646 Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3647 3648 NativeProcessLinux *const process = static_cast<NativeProcessLinux*> (arg); 3649 assert (process && "null process passed to CoordinatorThread"); 3650 if (!process) 3651 { 3652 if (log) 3653 log->Printf ("NativeProcessLinux::%s null process, exiting ThreadStateCoordinator processing loop", __FUNCTION__); 3654 return nullptr; 3655 } 3656 3657 // Run the thread state coordinator loop until it is done. This call uses 3658 // efficient waiting for an event to be ready. 3659 while (process->m_coordinator_up->ProcessNextEvent () == ThreadStateCoordinator::eventLoopResultContinue) 3660 { 3661 } 3662 3663 if (log) 3664 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " exiting ThreadStateCoordinator processing loop due to coordinator indicating completion", __FUNCTION__, process->GetID ()); 3665 3666 return nullptr; 3667 } 3668 3669 void 3670 NativeProcessLinux::StopCoordinatorThread() 3671 { 3672 Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3673 if (log) 3674 log->Printf ("NativeProcessLinux::%s requesting ThreadStateCoordinator stop for pid %" PRIu64, __FUNCTION__, GetID ()); 3675 3676 // Tell the coordinator we're done. This will cause the coordinator 3677 // run loop thread to exit when the processing queue hits this message. 3678 m_coordinator_up->StopCoordinator (); 3679 } 3680 3681 bool 3682 NativeProcessLinux::HasThreadNoLock (lldb::tid_t thread_id) 3683 { 3684 for (auto thread_sp : m_threads) 3685 { 3686 assert (thread_sp && "thread list should not contain NULL threads"); 3687 if (thread_sp->GetID () == thread_id) 3688 { 3689 // We have this thread. 3690 return true; 3691 } 3692 } 3693 3694 // We don't have this thread. 3695 return false; 3696 } 3697 3698 NativeThreadProtocolSP 3699 NativeProcessLinux::MaybeGetThreadNoLock (lldb::tid_t thread_id) 3700 { 3701 // CONSIDER organize threads by map - we can do better than linear. 3702 for (auto thread_sp : m_threads) 3703 { 3704 if (thread_sp->GetID () == thread_id) 3705 return thread_sp; 3706 } 3707 3708 // We don't have this thread. 3709 return NativeThreadProtocolSP (); 3710 } 3711 3712 bool 3713 NativeProcessLinux::StopTrackingThread (lldb::tid_t thread_id) 3714 { 3715 Mutex::Locker locker (m_threads_mutex); 3716 for (auto it = m_threads.begin (); it != m_threads.end (); ++it) 3717 { 3718 if (*it && ((*it)->GetID () == thread_id)) 3719 { 3720 m_threads.erase (it); 3721 return true; 3722 } 3723 } 3724 3725 // Didn't find it. 3726 return false; 3727 } 3728 3729 NativeThreadProtocolSP 3730 NativeProcessLinux::AddThread (lldb::tid_t thread_id) 3731 { 3732 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3733 3734 Mutex::Locker locker (m_threads_mutex); 3735 3736 if (log) 3737 { 3738 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " adding thread with tid %" PRIu64, 3739 __FUNCTION__, 3740 GetID (), 3741 thread_id); 3742 } 3743 3744 assert (!HasThreadNoLock (thread_id) && "attempted to add a thread by id that already exists"); 3745 3746 // If this is the first thread, save it as the current thread 3747 if (m_threads.empty ()) 3748 SetCurrentThreadID (thread_id); 3749 3750 NativeThreadProtocolSP thread_sp (new NativeThreadLinux (this, thread_id)); 3751 m_threads.push_back (thread_sp); 3752 3753 return thread_sp; 3754 } 3755 3756 NativeThreadProtocolSP 3757 NativeProcessLinux::GetOrCreateThread (lldb::tid_t thread_id, bool &created) 3758 { 3759 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 3760 3761 Mutex::Locker locker (m_threads_mutex); 3762 if (log) 3763 { 3764 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " get/create thread with tid %" PRIu64, 3765 __FUNCTION__, 3766 GetID (), 3767 thread_id); 3768 } 3769 3770 // Retrieve the thread if it is already getting tracked. 3771 NativeThreadProtocolSP thread_sp = MaybeGetThreadNoLock (thread_id); 3772 if (thread_sp) 3773 { 3774 if (log) 3775 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": thread already tracked, returning", 3776 __FUNCTION__, 3777 GetID (), 3778 thread_id); 3779 created = false; 3780 return thread_sp; 3781 3782 } 3783 3784 // Create the thread metadata since it isn't being tracked. 3785 if (log) 3786 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": thread didn't exist, tracking now", 3787 __FUNCTION__, 3788 GetID (), 3789 thread_id); 3790 3791 thread_sp.reset (new NativeThreadLinux (this, thread_id)); 3792 m_threads.push_back (thread_sp); 3793 created = true; 3794 3795 return thread_sp; 3796 } 3797 3798 Error 3799 NativeProcessLinux::FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp) 3800 { 3801 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 3802 3803 Error error; 3804 3805 // Get a linux thread pointer. 3806 if (!thread_sp) 3807 { 3808 error.SetErrorString ("null thread_sp"); 3809 if (log) 3810 log->Printf ("NativeProcessLinux::%s failed: %s", __FUNCTION__, error.AsCString ()); 3811 return error; 3812 } 3813 NativeThreadLinux *const linux_thread_p = reinterpret_cast<NativeThreadLinux*> (thread_sp.get()); 3814 3815 // Find out the size of a breakpoint (might depend on where we are in the code). 3816 NativeRegisterContextSP context_sp = linux_thread_p->GetRegisterContext (); 3817 if (!context_sp) 3818 { 3819 error.SetErrorString ("cannot get a NativeRegisterContext for the thread"); 3820 if (log) 3821 log->Printf ("NativeProcessLinux::%s failed: %s", __FUNCTION__, error.AsCString ()); 3822 return error; 3823 } 3824 3825 uint32_t breakpoint_size = 0; 3826 error = GetSoftwareBreakpointSize (context_sp, breakpoint_size); 3827 if (error.Fail ()) 3828 { 3829 if (log) 3830 log->Printf ("NativeProcessLinux::%s GetBreakpointSize() failed: %s", __FUNCTION__, error.AsCString ()); 3831 return error; 3832 } 3833 else 3834 { 3835 if (log) 3836 log->Printf ("NativeProcessLinux::%s breakpoint size: %" PRIu32, __FUNCTION__, breakpoint_size); 3837 } 3838 3839 // First try probing for a breakpoint at a software breakpoint location: PC - breakpoint size. 3840 const lldb::addr_t initial_pc_addr = context_sp->GetPC (); 3841 lldb::addr_t breakpoint_addr = initial_pc_addr; 3842 if (breakpoint_size > static_cast<lldb::addr_t> (0)) 3843 { 3844 // Do not allow breakpoint probe to wrap around. 3845 if (breakpoint_addr >= static_cast<lldb::addr_t> (breakpoint_size)) 3846 breakpoint_addr -= static_cast<lldb::addr_t> (breakpoint_size); 3847 } 3848 3849 // Check if we stopped because of a breakpoint. 3850 NativeBreakpointSP breakpoint_sp; 3851 error = m_breakpoint_list.GetBreakpoint (breakpoint_addr, breakpoint_sp); 3852 if (!error.Success () || !breakpoint_sp) 3853 { 3854 // We didn't find one at a software probe location. Nothing to do. 3855 if (log) 3856 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " no lldb breakpoint found at current pc with adjustment: 0x%" PRIx64, __FUNCTION__, GetID (), breakpoint_addr); 3857 return Error (); 3858 } 3859 3860 // If the breakpoint is not a software breakpoint, nothing to do. 3861 if (!breakpoint_sp->IsSoftwareBreakpoint ()) 3862 { 3863 if (log) 3864 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " breakpoint found at 0x%" PRIx64 ", not software, nothing to adjust", __FUNCTION__, GetID (), breakpoint_addr); 3865 return Error (); 3866 } 3867 3868 // 3869 // We have a software breakpoint and need to adjust the PC. 3870 // 3871 3872 // Sanity check. 3873 if (breakpoint_size == 0) 3874 { 3875 // Nothing to do! How did we get here? 3876 if (log) 3877 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); 3878 return Error (); 3879 } 3880 3881 // Change the program counter. 3882 if (log) 3883 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); 3884 3885 error = context_sp->SetPC (breakpoint_addr); 3886 if (error.Fail ()) 3887 { 3888 if (log) 3889 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": failed to set PC: %s", __FUNCTION__, GetID (), linux_thread_p->GetID (), error.AsCString ()); 3890 return error; 3891 } 3892 3893 return error; 3894 } 3895 3896 void 3897 NativeProcessLinux::NotifyThreadCreateStopped (lldb::tid_t tid) 3898 { 3899 const bool is_stopped = true; 3900 m_coordinator_up->NotifyThreadCreate (tid, is_stopped, CoordinatorErrorHandler); 3901 } 3902 3903 void 3904 NativeProcessLinux::NotifyThreadDeath (lldb::tid_t tid) 3905 { 3906 m_coordinator_up->NotifyThreadDeath (tid, CoordinatorErrorHandler); 3907 } 3908 3909 void 3910 NativeProcessLinux::NotifyThreadStop (lldb::tid_t tid) 3911 { 3912 m_coordinator_up->NotifyThreadStop (tid, CoordinatorErrorHandler); 3913 } 3914 3915 void 3916 NativeProcessLinux::CallAfterRunningThreadsStop (lldb::tid_t tid, 3917 const std::function<void (lldb::tid_t tid)> &call_after_function) 3918 { 3919 const lldb::pid_t pid = GetID (); 3920 m_coordinator_up->CallAfterRunningThreadsStop (tid, 3921 [=](lldb::tid_t request_stop_tid) 3922 { 3923 tgkill (pid, request_stop_tid, SIGSTOP); 3924 }, 3925 call_after_function, 3926 CoordinatorErrorHandler); 3927 } 3928 3929 void 3930 NativeProcessLinux::CallAfterRunningThreadsStopWithSkipTID (lldb::tid_t deferred_signal_tid, 3931 lldb::tid_t skip_stop_request_tid, 3932 const std::function<void (lldb::tid_t tid)> &call_after_function) 3933 { 3934 const lldb::pid_t pid = GetID (); 3935 m_coordinator_up->CallAfterRunningThreadsStopWithSkipTIDs (deferred_signal_tid, 3936 skip_stop_request_tid != LLDB_INVALID_THREAD_ID ? ThreadStateCoordinator::ThreadIDSet {skip_stop_request_tid} : ThreadStateCoordinator::ThreadIDSet (), 3937 [=](lldb::tid_t request_stop_tid) 3938 { 3939 tgkill (pid, request_stop_tid, SIGSTOP); 3940 }, 3941 call_after_function, 3942 CoordinatorErrorHandler); 3943 } 3944