1 //===-- NativeProcessNetBSD.cpp -------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "NativeProcessNetBSD.h" 10 11 #include "Plugins/Process/NetBSD/NativeRegisterContextNetBSD.h" 12 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h" 13 #include "lldb/Host/HostProcess.h" 14 #include "lldb/Host/common/NativeRegisterContext.h" 15 #include "lldb/Host/posix/ProcessLauncherPosixFork.h" 16 #include "lldb/Target/Process.h" 17 #include "lldb/Utility/State.h" 18 #include "llvm/Support/Errno.h" 19 20 // System includes - They have to be included after framework includes because 21 // they define some macros which collide with variable names in other modules 22 // clang-format off 23 #include <sys/types.h> 24 #include <sys/ptrace.h> 25 #include <sys/sysctl.h> 26 #include <sys/wait.h> 27 #include <uvm/uvm_prot.h> 28 #include <elf.h> 29 #include <util.h> 30 // clang-format on 31 32 using namespace lldb; 33 using namespace lldb_private; 34 using namespace lldb_private::process_netbsd; 35 using namespace llvm; 36 37 // Simple helper function to ensure flags are enabled on the given file 38 // descriptor. 39 static Status EnsureFDFlags(int fd, int flags) { 40 Status error; 41 42 int status = fcntl(fd, F_GETFL); 43 if (status == -1) { 44 error.SetErrorToErrno(); 45 return error; 46 } 47 48 if (fcntl(fd, F_SETFL, status | flags) == -1) { 49 error.SetErrorToErrno(); 50 return error; 51 } 52 53 return error; 54 } 55 56 // Public Static Methods 57 58 llvm::Expected<std::unique_ptr<NativeProcessProtocol>> 59 NativeProcessNetBSD::Manager::Launch(ProcessLaunchInfo &launch_info, 60 NativeDelegate &native_delegate) { 61 Log *log = GetLog(POSIXLog::Process); 62 63 Status status; 64 ::pid_t pid = ProcessLauncherPosixFork() 65 .LaunchProcess(launch_info, status) 66 .GetProcessId(); 67 LLDB_LOG(log, "pid = {0:x}", pid); 68 if (status.Fail()) { 69 LLDB_LOG(log, "failed to launch process: {0}", status); 70 return status.ToError(); 71 } 72 73 // Wait for the child process to trap on its call to execve. 74 int wstatus; 75 ::pid_t wpid = llvm::sys::RetryAfterSignal(-1, ::waitpid, pid, &wstatus, 0); 76 assert(wpid == pid); 77 (void)wpid; 78 if (!WIFSTOPPED(wstatus)) { 79 LLDB_LOG(log, "Could not sync with inferior process: wstatus={1}", 80 WaitStatus::Decode(wstatus)); 81 return llvm::make_error<StringError>("Could not sync with inferior process", 82 llvm::inconvertibleErrorCode()); 83 } 84 LLDB_LOG(log, "inferior started, now in stopped state"); 85 86 ProcessInstanceInfo Info; 87 if (!Host::GetProcessInfo(pid, Info)) { 88 return llvm::make_error<StringError>("Cannot get process architecture", 89 llvm::inconvertibleErrorCode()); 90 } 91 92 // Set the architecture to the exe architecture. 93 LLDB_LOG(log, "pid = {0:x}, detected architecture {1}", pid, 94 Info.GetArchitecture().GetArchitectureName()); 95 96 std::unique_ptr<NativeProcessNetBSD> process_up(new NativeProcessNetBSD( 97 pid, launch_info.GetPTY().ReleasePrimaryFileDescriptor(), native_delegate, 98 Info.GetArchitecture(), m_mainloop)); 99 100 status = process_up->SetupTrace(); 101 if (status.Fail()) 102 return status.ToError(); 103 104 for (const auto &thread : process_up->m_threads) 105 static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(SIGSTOP); 106 process_up->SetState(StateType::eStateStopped, false); 107 108 return std::move(process_up); 109 } 110 111 llvm::Expected<std::unique_ptr<NativeProcessProtocol>> 112 NativeProcessNetBSD::Manager::Attach( 113 lldb::pid_t pid, NativeProcessProtocol::NativeDelegate &native_delegate) { 114 Log *log = GetLog(POSIXLog::Process); 115 LLDB_LOG(log, "pid = {0:x}", pid); 116 117 // Retrieve the architecture for the running process. 118 ProcessInstanceInfo Info; 119 if (!Host::GetProcessInfo(pid, Info)) { 120 return llvm::make_error<StringError>("Cannot get process architecture", 121 llvm::inconvertibleErrorCode()); 122 } 123 124 std::unique_ptr<NativeProcessNetBSD> process_up(new NativeProcessNetBSD( 125 pid, -1, native_delegate, Info.GetArchitecture(), m_mainloop)); 126 127 Status status = process_up->Attach(); 128 if (!status.Success()) 129 return status.ToError(); 130 131 return std::move(process_up); 132 } 133 134 NativeProcessNetBSD::Extension 135 NativeProcessNetBSD::Manager::GetSupportedExtensions() const { 136 return Extension::multiprocess | Extension::fork | Extension::vfork | 137 Extension::pass_signals | Extension::auxv | Extension::libraries_svr4 | 138 Extension::savecore; 139 } 140 141 // Public Instance Methods 142 143 NativeProcessNetBSD::NativeProcessNetBSD(::pid_t pid, int terminal_fd, 144 NativeDelegate &delegate, 145 const ArchSpec &arch, 146 MainLoop &mainloop) 147 : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch), 148 m_main_loop(mainloop) { 149 if (m_terminal_fd != -1) { 150 Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK); 151 assert(status.Success()); 152 } 153 154 Status status; 155 m_sigchld_handle = mainloop.RegisterSignal( 156 SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status); 157 assert(m_sigchld_handle && status.Success()); 158 } 159 160 // Handles all waitpid events from the inferior process. 161 void NativeProcessNetBSD::MonitorCallback(lldb::pid_t pid, int signal) { 162 switch (signal) { 163 case SIGTRAP: 164 return MonitorSIGTRAP(pid); 165 case SIGSTOP: 166 return MonitorSIGSTOP(pid); 167 default: 168 return MonitorSignal(pid, signal); 169 } 170 } 171 172 void NativeProcessNetBSD::MonitorExited(lldb::pid_t pid, WaitStatus status) { 173 Log *log = GetLog(POSIXLog::Process); 174 175 LLDB_LOG(log, "got exit signal({0}) , pid = {1}", status, pid); 176 177 /* Stop Tracking All Threads attached to Process */ 178 m_threads.clear(); 179 180 SetExitStatus(status, true); 181 182 // Notify delegate that our process has exited. 183 SetState(StateType::eStateExited, true); 184 } 185 186 void NativeProcessNetBSD::MonitorSIGSTOP(lldb::pid_t pid) { 187 ptrace_siginfo_t info; 188 189 const auto siginfo_err = 190 PtraceWrapper(PT_GET_SIGINFO, pid, &info, sizeof(info)); 191 192 // Get details on the signal raised. 193 if (siginfo_err.Success()) { 194 // Handle SIGSTOP from LLGS (LLDB GDB Server) 195 if (info.psi_siginfo.si_code == SI_USER && 196 info.psi_siginfo.si_pid == ::getpid()) { 197 /* Stop Tracking all Threads attached to Process */ 198 for (const auto &thread : m_threads) { 199 static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal( 200 SIGSTOP, &info.psi_siginfo); 201 } 202 } 203 SetState(StateType::eStateStopped, true); 204 } 205 } 206 207 void NativeProcessNetBSD::MonitorSIGTRAP(lldb::pid_t pid) { 208 Log *log = GetLog(POSIXLog::Process); 209 ptrace_siginfo_t info; 210 211 const auto siginfo_err = 212 PtraceWrapper(PT_GET_SIGINFO, pid, &info, sizeof(info)); 213 214 // Get details on the signal raised. 215 if (siginfo_err.Fail()) { 216 LLDB_LOG(log, "PT_GET_SIGINFO failed {0}", siginfo_err); 217 return; 218 } 219 220 LLDB_LOG(log, "got SIGTRAP, pid = {0}, lwpid = {1}, si_code = {2}", pid, 221 info.psi_lwpid, info.psi_siginfo.si_code); 222 NativeThreadNetBSD *thread = nullptr; 223 224 if (info.psi_lwpid > 0) { 225 for (const auto &t : m_threads) { 226 if (t->GetID() == static_cast<lldb::tid_t>(info.psi_lwpid)) { 227 thread = static_cast<NativeThreadNetBSD *>(t.get()); 228 break; 229 } 230 static_cast<NativeThreadNetBSD *>(t.get())->SetStoppedWithNoReason(); 231 } 232 if (!thread) 233 LLDB_LOG(log, "thread not found in m_threads, pid = {0}, LWP = {1}", pid, 234 info.psi_lwpid); 235 } 236 237 switch (info.psi_siginfo.si_code) { 238 case TRAP_BRKPT: 239 if (thread) { 240 thread->SetStoppedByBreakpoint(); 241 FixupBreakpointPCAsNeeded(*thread); 242 } 243 SetState(StateType::eStateStopped, true); 244 return; 245 case TRAP_TRACE: 246 if (thread) 247 thread->SetStoppedByTrace(); 248 SetState(StateType::eStateStopped, true); 249 return; 250 case TRAP_EXEC: { 251 Status error = ReinitializeThreads(); 252 if (error.Fail()) { 253 SetState(StateType::eStateInvalid); 254 return; 255 } 256 257 // Let our delegate know we have just exec'd. 258 NotifyDidExec(); 259 260 for (const auto &thread : m_threads) 261 static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByExec(); 262 SetState(StateType::eStateStopped, true); 263 return; 264 } 265 case TRAP_CHLD: { 266 ptrace_state_t pst; 267 Status error = PtraceWrapper(PT_GET_PROCESS_STATE, pid, &pst, sizeof(pst)); 268 if (error.Fail()) { 269 SetState(StateType::eStateInvalid); 270 return; 271 } 272 273 assert(thread); 274 if (pst.pe_report_event == PTRACE_VFORK_DONE) { 275 if ((m_enabled_extensions & Extension::vfork) == Extension::vfork) { 276 thread->SetStoppedByVForkDone(); 277 SetState(StateType::eStateStopped, true); 278 } else { 279 Status error = 280 PtraceWrapper(PT_CONTINUE, pid, reinterpret_cast<void *>(1), 0); 281 if (error.Fail()) 282 SetState(StateType::eStateInvalid); 283 } 284 } else { 285 assert(pst.pe_report_event == PTRACE_FORK || 286 pst.pe_report_event == PTRACE_VFORK); 287 MonitorClone(pst.pe_other_pid, pst.pe_report_event == PTRACE_VFORK, 288 *thread); 289 } 290 return; 291 } 292 case TRAP_LWP: { 293 ptrace_state_t pst; 294 Status error = PtraceWrapper(PT_GET_PROCESS_STATE, pid, &pst, sizeof(pst)); 295 if (error.Fail()) { 296 SetState(StateType::eStateInvalid); 297 return; 298 } 299 300 switch (pst.pe_report_event) { 301 case PTRACE_LWP_CREATE: { 302 LLDB_LOG(log, "monitoring new thread, pid = {0}, LWP = {1}", pid, 303 pst.pe_lwp); 304 NativeThreadNetBSD &t = AddThread(pst.pe_lwp); 305 error = t.CopyWatchpointsFrom( 306 static_cast<NativeThreadNetBSD &>(*GetCurrentThread())); 307 if (error.Fail()) { 308 LLDB_LOG(log, "failed to copy watchpoints to new thread {0}: {1}", 309 pst.pe_lwp, error); 310 SetState(StateType::eStateInvalid); 311 return; 312 } 313 } break; 314 case PTRACE_LWP_EXIT: 315 LLDB_LOG(log, "removing exited thread, pid = {0}, LWP = {1}", pid, 316 pst.pe_lwp); 317 RemoveThread(pst.pe_lwp); 318 break; 319 } 320 321 error = PtraceWrapper(PT_CONTINUE, pid, reinterpret_cast<void *>(1), 0); 322 if (error.Fail()) 323 SetState(StateType::eStateInvalid); 324 return; 325 } 326 case TRAP_DBREG: { 327 if (!thread) 328 break; 329 330 auto ®ctx = static_cast<NativeRegisterContextNetBSD &>( 331 thread->GetRegisterContext()); 332 uint32_t wp_index = LLDB_INVALID_INDEX32; 333 Status error = regctx.GetWatchpointHitIndex( 334 wp_index, (uintptr_t)info.psi_siginfo.si_addr); 335 if (error.Fail()) 336 LLDB_LOG(log, 337 "received error while checking for watchpoint hits, pid = " 338 "{0}, LWP = {1}, error = {2}", 339 pid, info.psi_lwpid, error); 340 if (wp_index != LLDB_INVALID_INDEX32) { 341 thread->SetStoppedByWatchpoint(wp_index); 342 regctx.ClearWatchpointHit(wp_index); 343 SetState(StateType::eStateStopped, true); 344 return; 345 } 346 347 thread->SetStoppedByTrace(); 348 SetState(StateType::eStateStopped, true); 349 return; 350 } 351 } 352 353 // Either user-generated SIGTRAP or an unknown event that would 354 // otherwise leave the debugger hanging. 355 LLDB_LOG(log, "unknown SIGTRAP, passing to generic handler"); 356 MonitorSignal(pid, SIGTRAP); 357 } 358 359 void NativeProcessNetBSD::MonitorSignal(lldb::pid_t pid, int signal) { 360 Log *log = GetLog(POSIXLog::Process); 361 ptrace_siginfo_t info; 362 363 const auto siginfo_err = 364 PtraceWrapper(PT_GET_SIGINFO, pid, &info, sizeof(info)); 365 if (siginfo_err.Fail()) { 366 LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err); 367 return; 368 } 369 370 for (const auto &abs_thread : m_threads) { 371 NativeThreadNetBSD &thread = static_cast<NativeThreadNetBSD &>(*abs_thread); 372 assert(info.psi_lwpid >= 0); 373 if (info.psi_lwpid == 0 || 374 static_cast<lldb::tid_t>(info.psi_lwpid) == thread.GetID()) 375 thread.SetStoppedBySignal(info.psi_siginfo.si_signo, &info.psi_siginfo); 376 else 377 thread.SetStoppedWithNoReason(); 378 } 379 SetState(StateType::eStateStopped, true); 380 } 381 382 Status NativeProcessNetBSD::PtraceWrapper(int req, lldb::pid_t pid, void *addr, 383 int data, int *result) { 384 Log *log = GetLog(POSIXLog::Ptrace); 385 Status error; 386 int ret; 387 388 errno = 0; 389 ret = ptrace(req, static_cast<::pid_t>(pid), addr, data); 390 391 if (ret == -1) 392 error.SetErrorToErrno(); 393 394 if (result) 395 *result = ret; 396 397 LLDB_LOG(log, "ptrace({0}, {1}, {2}, {3})={4:x}", req, pid, addr, data, ret); 398 399 if (error.Fail()) 400 LLDB_LOG(log, "ptrace() failed: {0}", error); 401 402 return error; 403 } 404 405 static llvm::Expected<ptrace_siginfo_t> ComputeSignalInfo( 406 const std::vector<std::unique_ptr<NativeThreadProtocol>> &threads, 407 const ResumeActionList &resume_actions) { 408 // We need to account for three possible scenarios: 409 // 1. no signal being sent. 410 // 2. a signal being sent to one thread. 411 // 3. a signal being sent to the whole process. 412 413 // Count signaled threads. While at it, determine which signal is being sent 414 // and ensure there's only one. 415 size_t signaled_threads = 0; 416 int signal = LLDB_INVALID_SIGNAL_NUMBER; 417 lldb::tid_t signaled_lwp; 418 for (const auto &thread : threads) { 419 assert(thread && "thread list should not contain NULL threads"); 420 const ResumeAction *action = 421 resume_actions.GetActionForThread(thread->GetID(), true); 422 if (action) { 423 if (action->signal != LLDB_INVALID_SIGNAL_NUMBER) { 424 signaled_threads++; 425 if (action->signal != signal) { 426 if (signal != LLDB_INVALID_SIGNAL_NUMBER) 427 return Status("NetBSD does not support passing multiple signals " 428 "simultaneously") 429 .ToError(); 430 signal = action->signal; 431 signaled_lwp = thread->GetID(); 432 } 433 } 434 } 435 } 436 437 if (signaled_threads == 0) { 438 ptrace_siginfo_t siginfo; 439 siginfo.psi_siginfo.si_signo = LLDB_INVALID_SIGNAL_NUMBER; 440 return siginfo; 441 } 442 443 if (signaled_threads > 1 && signaled_threads < threads.size()) 444 return Status("NetBSD does not support passing signal to 1<i<all threads") 445 .ToError(); 446 447 ptrace_siginfo_t siginfo; 448 siginfo.psi_siginfo.si_signo = signal; 449 siginfo.psi_siginfo.si_code = SI_USER; 450 siginfo.psi_siginfo.si_pid = getpid(); 451 siginfo.psi_siginfo.si_uid = getuid(); 452 if (signaled_threads == 1) 453 siginfo.psi_lwpid = signaled_lwp; 454 else // signal for the whole process 455 siginfo.psi_lwpid = 0; 456 return siginfo; 457 } 458 459 Status NativeProcessNetBSD::Resume(const ResumeActionList &resume_actions) { 460 Log *log = GetLog(POSIXLog::Process); 461 LLDB_LOG(log, "pid {0}", GetID()); 462 463 Status ret; 464 465 Expected<ptrace_siginfo_t> siginfo = 466 ComputeSignalInfo(m_threads, resume_actions); 467 if (!siginfo) 468 return Status(siginfo.takeError()); 469 470 for (const auto &abs_thread : m_threads) { 471 assert(abs_thread && "thread list should not contain NULL threads"); 472 NativeThreadNetBSD &thread = static_cast<NativeThreadNetBSD &>(*abs_thread); 473 474 const ResumeAction *action = 475 resume_actions.GetActionForThread(thread.GetID(), true); 476 // we need to explicit issue suspend requests, so it is simpler to map it 477 // into proper action 478 ResumeAction suspend_action{thread.GetID(), eStateSuspended, 479 LLDB_INVALID_SIGNAL_NUMBER}; 480 481 if (action == nullptr) { 482 LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(), 483 thread.GetID()); 484 action = &suspend_action; 485 } 486 487 LLDB_LOG( 488 log, 489 "processing resume action state {0} signal {1} for pid {2} tid {3}", 490 action->state, action->signal, GetID(), thread.GetID()); 491 492 switch (action->state) { 493 case eStateRunning: 494 ret = thread.Resume(); 495 break; 496 case eStateStepping: 497 ret = thread.SingleStep(); 498 break; 499 case eStateSuspended: 500 case eStateStopped: 501 if (action->signal != LLDB_INVALID_SIGNAL_NUMBER) 502 return Status("Passing signal to suspended thread unsupported"); 503 504 ret = thread.Suspend(); 505 break; 506 507 default: 508 return Status("NativeProcessNetBSD::%s (): unexpected state %s specified " 509 "for pid %" PRIu64 ", tid %" PRIu64, 510 __FUNCTION__, StateAsCString(action->state), GetID(), 511 thread.GetID()); 512 } 513 514 if (!ret.Success()) 515 return ret; 516 } 517 518 int signal = 0; 519 if (siginfo->psi_siginfo.si_signo != LLDB_INVALID_SIGNAL_NUMBER) { 520 ret = PtraceWrapper(PT_SET_SIGINFO, GetID(), &siginfo.get(), 521 sizeof(*siginfo)); 522 if (!ret.Success()) 523 return ret; 524 signal = siginfo->psi_siginfo.si_signo; 525 } 526 527 ret = 528 PtraceWrapper(PT_CONTINUE, GetID(), reinterpret_cast<void *>(1), signal); 529 if (ret.Success()) 530 SetState(eStateRunning, true); 531 return ret; 532 } 533 534 Status NativeProcessNetBSD::Halt() { return PtraceWrapper(PT_STOP, GetID()); } 535 536 Status NativeProcessNetBSD::Detach() { 537 Status error; 538 539 // Stop monitoring the inferior. 540 m_sigchld_handle.reset(); 541 542 // Tell ptrace to detach from the process. 543 if (GetID() == LLDB_INVALID_PROCESS_ID) 544 return error; 545 546 return PtraceWrapper(PT_DETACH, GetID(), reinterpret_cast<void *>(1)); 547 } 548 549 Status NativeProcessNetBSD::Signal(int signo) { 550 Status error; 551 552 if (kill(GetID(), signo)) 553 error.SetErrorToErrno(); 554 555 return error; 556 } 557 558 Status NativeProcessNetBSD::Interrupt() { 559 return PtraceWrapper(PT_STOP, GetID()); 560 } 561 562 Status NativeProcessNetBSD::Kill() { 563 Log *log = GetLog(POSIXLog::Process); 564 LLDB_LOG(log, "pid {0}", GetID()); 565 566 Status error; 567 568 switch (m_state) { 569 case StateType::eStateInvalid: 570 case StateType::eStateExited: 571 case StateType::eStateCrashed: 572 case StateType::eStateDetached: 573 case StateType::eStateUnloaded: 574 // Nothing to do - the process is already dead. 575 LLDB_LOG(log, "ignored for PID {0} due to current state: {1}", GetID(), 576 StateAsCString(m_state)); 577 return error; 578 579 case StateType::eStateConnected: 580 case StateType::eStateAttaching: 581 case StateType::eStateLaunching: 582 case StateType::eStateStopped: 583 case StateType::eStateRunning: 584 case StateType::eStateStepping: 585 case StateType::eStateSuspended: 586 // We can try to kill a process in these states. 587 break; 588 } 589 590 if (kill(GetID(), SIGKILL) != 0) { 591 error.SetErrorToErrno(); 592 return error; 593 } 594 595 return error; 596 } 597 598 Status NativeProcessNetBSD::GetMemoryRegionInfo(lldb::addr_t load_addr, 599 MemoryRegionInfo &range_info) { 600 601 if (m_supports_mem_region == LazyBool::eLazyBoolNo) { 602 // We're done. 603 return Status("unsupported"); 604 } 605 606 Status error = PopulateMemoryRegionCache(); 607 if (error.Fail()) { 608 return error; 609 } 610 611 lldb::addr_t prev_base_address = 0; 612 // FIXME start by finding the last region that is <= target address using 613 // binary search. Data is sorted. 614 // There can be a ton of regions on pthreads apps with lots of threads. 615 for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end(); 616 ++it) { 617 MemoryRegionInfo &proc_entry_info = it->first; 618 // Sanity check assumption that memory map entries are ascending. 619 assert((proc_entry_info.GetRange().GetRangeBase() >= prev_base_address) && 620 "descending memory map entries detected, unexpected"); 621 prev_base_address = proc_entry_info.GetRange().GetRangeBase(); 622 UNUSED_IF_ASSERT_DISABLED(prev_base_address); 623 // If the target address comes before this entry, indicate distance to next 624 // region. 625 if (load_addr < proc_entry_info.GetRange().GetRangeBase()) { 626 range_info.GetRange().SetRangeBase(load_addr); 627 range_info.GetRange().SetByteSize( 628 proc_entry_info.GetRange().GetRangeBase() - load_addr); 629 range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo); 630 range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo); 631 range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo); 632 range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo); 633 return error; 634 } else if (proc_entry_info.GetRange().Contains(load_addr)) { 635 // The target address is within the memory region we're processing here. 636 range_info = proc_entry_info; 637 return error; 638 } 639 // The target memory address comes somewhere after the region we just 640 // parsed. 641 } 642 // If we made it here, we didn't find an entry that contained the given 643 // address. Return the load_addr as start and the amount of bytes betwwen 644 // load address and the end of the memory as size. 645 range_info.GetRange().SetRangeBase(load_addr); 646 range_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS); 647 range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo); 648 range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo); 649 range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo); 650 range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo); 651 return error; 652 } 653 654 Status NativeProcessNetBSD::PopulateMemoryRegionCache() { 655 Log *log = GetLog(POSIXLog::Process); 656 // If our cache is empty, pull the latest. There should always be at least 657 // one memory region if memory region handling is supported. 658 if (!m_mem_region_cache.empty()) { 659 LLDB_LOG(log, "reusing {0} cached memory region entries", 660 m_mem_region_cache.size()); 661 return Status(); 662 } 663 664 struct kinfo_vmentry *vm; 665 size_t count, i; 666 vm = kinfo_getvmmap(GetID(), &count); 667 if (vm == NULL) { 668 m_supports_mem_region = LazyBool::eLazyBoolNo; 669 Status error; 670 error.SetErrorString("not supported"); 671 return error; 672 } 673 for (i = 0; i < count; i++) { 674 MemoryRegionInfo info; 675 info.Clear(); 676 info.GetRange().SetRangeBase(vm[i].kve_start); 677 info.GetRange().SetRangeEnd(vm[i].kve_end); 678 info.SetMapped(MemoryRegionInfo::OptionalBool::eYes); 679 680 if (vm[i].kve_protection & VM_PROT_READ) 681 info.SetReadable(MemoryRegionInfo::OptionalBool::eYes); 682 else 683 info.SetReadable(MemoryRegionInfo::OptionalBool::eNo); 684 685 if (vm[i].kve_protection & VM_PROT_WRITE) 686 info.SetWritable(MemoryRegionInfo::OptionalBool::eYes); 687 else 688 info.SetWritable(MemoryRegionInfo::OptionalBool::eNo); 689 690 if (vm[i].kve_protection & VM_PROT_EXECUTE) 691 info.SetExecutable(MemoryRegionInfo::OptionalBool::eYes); 692 else 693 info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo); 694 695 if (vm[i].kve_path[0]) 696 info.SetName(vm[i].kve_path); 697 698 m_mem_region_cache.emplace_back(info, 699 FileSpec(info.GetName().GetCString())); 700 } 701 free(vm); 702 703 if (m_mem_region_cache.empty()) { 704 // No entries after attempting to read them. This shouldn't happen. Assume 705 // we don't support map entries. 706 LLDB_LOG(log, "failed to find any vmmap entries, assuming no support " 707 "for memory region metadata retrieval"); 708 m_supports_mem_region = LazyBool::eLazyBoolNo; 709 Status error; 710 error.SetErrorString("not supported"); 711 return error; 712 } 713 LLDB_LOG(log, "read {0} memory region entries from process {1}", 714 m_mem_region_cache.size(), GetID()); 715 // We support memory retrieval, remember that. 716 m_supports_mem_region = LazyBool::eLazyBoolYes; 717 return Status(); 718 } 719 720 lldb::addr_t NativeProcessNetBSD::GetSharedLibraryInfoAddress() { 721 // punt on this for now 722 return LLDB_INVALID_ADDRESS; 723 } 724 725 size_t NativeProcessNetBSD::UpdateThreads() { return m_threads.size(); } 726 727 Status NativeProcessNetBSD::SetBreakpoint(lldb::addr_t addr, uint32_t size, 728 bool hardware) { 729 if (hardware) 730 return Status("NativeProcessNetBSD does not support hardware breakpoints"); 731 else 732 return SetSoftwareBreakpoint(addr, size); 733 } 734 735 Status NativeProcessNetBSD::GetLoadedModuleFileSpec(const char *module_path, 736 FileSpec &file_spec) { 737 Status error = PopulateMemoryRegionCache(); 738 if (error.Fail()) 739 return error; 740 741 FileSpec module_file_spec(module_path); 742 FileSystem::Instance().Resolve(module_file_spec); 743 744 file_spec.Clear(); 745 for (const auto &it : m_mem_region_cache) { 746 if (it.second.GetFilename() == module_file_spec.GetFilename()) { 747 file_spec = it.second; 748 return Status(); 749 } 750 } 751 return Status("Module file (%s) not found in process' memory map!", 752 module_file_spec.GetFilename().AsCString()); 753 } 754 755 Status NativeProcessNetBSD::GetFileLoadAddress(const llvm::StringRef &file_name, 756 lldb::addr_t &load_addr) { 757 load_addr = LLDB_INVALID_ADDRESS; 758 Status error = PopulateMemoryRegionCache(); 759 if (error.Fail()) 760 return error; 761 762 FileSpec file(file_name); 763 for (const auto &it : m_mem_region_cache) { 764 if (it.second == file) { 765 load_addr = it.first.GetRange().GetRangeBase(); 766 return Status(); 767 } 768 } 769 return Status("No load address found for file %s.", file_name.str().c_str()); 770 } 771 772 void NativeProcessNetBSD::SigchldHandler() { 773 Log *log = GetLog(POSIXLog::Process); 774 int status; 775 ::pid_t wait_pid = llvm::sys::RetryAfterSignal(-1, waitpid, GetID(), &status, 776 WALLSIG | WNOHANG); 777 778 if (wait_pid == 0) 779 return; 780 781 if (wait_pid == -1) { 782 Status error(errno, eErrorTypePOSIX); 783 LLDB_LOG(log, "waitpid ({0}, &status, _) failed: {1}", GetID(), error); 784 return; 785 } 786 787 WaitStatus wait_status = WaitStatus::Decode(status); 788 bool exited = wait_status.type == WaitStatus::Exit || 789 (wait_status.type == WaitStatus::Signal && 790 wait_pid == static_cast<::pid_t>(GetID())); 791 792 LLDB_LOG(log, 793 "waitpid ({0}, &status, _) => pid = {1}, status = {2}, exited = {3}", 794 GetID(), wait_pid, status, exited); 795 796 if (exited) 797 MonitorExited(wait_pid, wait_status); 798 else { 799 assert(wait_status.type == WaitStatus::Stop); 800 MonitorCallback(wait_pid, wait_status.status); 801 } 802 } 803 804 bool NativeProcessNetBSD::HasThreadNoLock(lldb::tid_t thread_id) { 805 for (const auto &thread : m_threads) { 806 assert(thread && "thread list should not contain NULL threads"); 807 if (thread->GetID() == thread_id) { 808 // We have this thread. 809 return true; 810 } 811 } 812 813 // We don't have this thread. 814 return false; 815 } 816 817 NativeThreadNetBSD &NativeProcessNetBSD::AddThread(lldb::tid_t thread_id) { 818 Log *log = GetLog(POSIXLog::Thread); 819 LLDB_LOG(log, "pid {0} adding thread with tid {1}", GetID(), thread_id); 820 821 assert(thread_id > 0); 822 assert(!HasThreadNoLock(thread_id) && 823 "attempted to add a thread by id that already exists"); 824 825 // If this is the first thread, save it as the current thread 826 if (m_threads.empty()) 827 SetCurrentThreadID(thread_id); 828 829 m_threads.push_back(std::make_unique<NativeThreadNetBSD>(*this, thread_id)); 830 return static_cast<NativeThreadNetBSD &>(*m_threads.back()); 831 } 832 833 void NativeProcessNetBSD::RemoveThread(lldb::tid_t thread_id) { 834 Log *log = GetLog(POSIXLog::Thread); 835 LLDB_LOG(log, "pid {0} removing thread with tid {1}", GetID(), thread_id); 836 837 assert(thread_id > 0); 838 assert(HasThreadNoLock(thread_id) && 839 "attempted to remove a thread that does not exist"); 840 841 for (auto it = m_threads.begin(); it != m_threads.end(); ++it) { 842 if ((*it)->GetID() == thread_id) { 843 m_threads.erase(it); 844 break; 845 } 846 } 847 } 848 849 Status NativeProcessNetBSD::Attach() { 850 // Attach to the requested process. 851 // An attach will cause the thread to stop with a SIGSTOP. 852 Status status = PtraceWrapper(PT_ATTACH, m_pid); 853 if (status.Fail()) 854 return status; 855 856 int wstatus; 857 // Need to use WALLSIG otherwise we receive an error with errno=ECHLD At this 858 // point we should have a thread stopped if waitpid succeeds. 859 if ((wstatus = llvm::sys::RetryAfterSignal(-1, waitpid, m_pid, nullptr, 860 WALLSIG)) < 0) 861 return Status(errno, eErrorTypePOSIX); 862 863 // Initialize threads and tracing status 864 // NB: this needs to be called before we set thread state 865 status = SetupTrace(); 866 if (status.Fail()) 867 return status; 868 869 for (const auto &thread : m_threads) 870 static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(SIGSTOP); 871 872 // Let our process instance know the thread has stopped. 873 SetCurrentThreadID(m_threads.front()->GetID()); 874 SetState(StateType::eStateStopped, false); 875 return Status(); 876 } 877 878 Status NativeProcessNetBSD::ReadMemory(lldb::addr_t addr, void *buf, 879 size_t size, size_t &bytes_read) { 880 unsigned char *dst = static_cast<unsigned char *>(buf); 881 struct ptrace_io_desc io; 882 883 Log *log = GetLog(POSIXLog::Memory); 884 LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size); 885 886 bytes_read = 0; 887 io.piod_op = PIOD_READ_D; 888 io.piod_len = size; 889 890 do { 891 io.piod_offs = (void *)(addr + bytes_read); 892 io.piod_addr = dst + bytes_read; 893 894 Status error = NativeProcessNetBSD::PtraceWrapper(PT_IO, GetID(), &io); 895 if (error.Fail() || io.piod_len == 0) 896 return error; 897 898 bytes_read += io.piod_len; 899 io.piod_len = size - bytes_read; 900 } while (bytes_read < size); 901 902 return Status(); 903 } 904 905 Status NativeProcessNetBSD::WriteMemory(lldb::addr_t addr, const void *buf, 906 size_t size, size_t &bytes_written) { 907 const unsigned char *src = static_cast<const unsigned char *>(buf); 908 Status error; 909 struct ptrace_io_desc io; 910 911 Log *log = GetLog(POSIXLog::Memory); 912 LLDB_LOG(log, "addr = {0}, buf = {1}, size = {2}", addr, buf, size); 913 914 bytes_written = 0; 915 io.piod_op = PIOD_WRITE_D; 916 io.piod_len = size; 917 918 do { 919 io.piod_addr = 920 const_cast<void *>(static_cast<const void *>(src + bytes_written)); 921 io.piod_offs = (void *)(addr + bytes_written); 922 923 Status error = NativeProcessNetBSD::PtraceWrapper(PT_IO, GetID(), &io); 924 if (error.Fail() || io.piod_len == 0) 925 return error; 926 927 bytes_written += io.piod_len; 928 io.piod_len = size - bytes_written; 929 } while (bytes_written < size); 930 931 return error; 932 } 933 934 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> 935 NativeProcessNetBSD::GetAuxvData() const { 936 /* 937 * ELF_AUX_ENTRIES is currently restricted to kernel 938 * (<sys/exec_elf.h> r. 1.155 specifies 15) 939 * 940 * ptrace(2) returns the whole AUXV including extra fiels after AT_NULL this 941 * information isn't needed. 942 */ 943 size_t auxv_size = 100 * sizeof(AuxInfo); 944 945 ErrorOr<std::unique_ptr<WritableMemoryBuffer>> buf = 946 llvm::WritableMemoryBuffer::getNewMemBuffer(auxv_size); 947 948 struct ptrace_io_desc io; 949 io.piod_op = PIOD_READ_AUXV; 950 io.piod_offs = 0; 951 io.piod_addr = static_cast<void *>(buf.get()->getBufferStart()); 952 io.piod_len = auxv_size; 953 954 Status error = NativeProcessNetBSD::PtraceWrapper(PT_IO, GetID(), &io); 955 956 if (error.Fail()) 957 return std::error_code(error.GetError(), std::generic_category()); 958 959 if (io.piod_len < 1) 960 return std::error_code(ECANCELED, std::generic_category()); 961 962 return std::move(buf); 963 } 964 965 Status NativeProcessNetBSD::SetupTrace() { 966 // Enable event reporting 967 ptrace_event_t events; 968 Status status = 969 PtraceWrapper(PT_GET_EVENT_MASK, GetID(), &events, sizeof(events)); 970 if (status.Fail()) 971 return status; 972 // TODO: PTRACE_POSIX_SPAWN? 973 events.pe_set_event |= PTRACE_LWP_CREATE | PTRACE_LWP_EXIT | PTRACE_FORK | 974 PTRACE_VFORK | PTRACE_VFORK_DONE; 975 status = PtraceWrapper(PT_SET_EVENT_MASK, GetID(), &events, sizeof(events)); 976 if (status.Fail()) 977 return status; 978 979 return ReinitializeThreads(); 980 } 981 982 Status NativeProcessNetBSD::ReinitializeThreads() { 983 // Clear old threads 984 m_threads.clear(); 985 986 // Initialize new thread 987 #ifdef PT_LWPSTATUS 988 struct ptrace_lwpstatus info = {}; 989 int op = PT_LWPNEXT; 990 #else 991 struct ptrace_lwpinfo info = {}; 992 int op = PT_LWPINFO; 993 #endif 994 995 Status error = PtraceWrapper(op, GetID(), &info, sizeof(info)); 996 997 if (error.Fail()) { 998 return error; 999 } 1000 // Reinitialize from scratch threads and register them in process 1001 while (info.pl_lwpid != 0) { 1002 AddThread(info.pl_lwpid); 1003 error = PtraceWrapper(op, GetID(), &info, sizeof(info)); 1004 if (error.Fail()) { 1005 return error; 1006 } 1007 } 1008 1009 return error; 1010 } 1011 1012 void NativeProcessNetBSD::MonitorClone(::pid_t child_pid, bool is_vfork, 1013 NativeThreadNetBSD &parent_thread) { 1014 Log *log = GetLog(POSIXLog::Process); 1015 LLDB_LOG(log, "clone, child_pid={0}", child_pid); 1016 1017 int status; 1018 ::pid_t wait_pid = 1019 llvm::sys::RetryAfterSignal(-1, ::waitpid, child_pid, &status, 0); 1020 if (wait_pid != child_pid) { 1021 LLDB_LOG(log, 1022 "waiting for pid {0} failed. Assuming the pid has " 1023 "disappeared in the meantime", 1024 child_pid); 1025 return; 1026 } 1027 if (WIFEXITED(status)) { 1028 LLDB_LOG(log, 1029 "waiting for pid {0} returned an 'exited' event. Not " 1030 "tracking it.", 1031 child_pid); 1032 return; 1033 } 1034 1035 ptrace_siginfo_t info; 1036 const auto siginfo_err = 1037 PtraceWrapper(PT_GET_SIGINFO, child_pid, &info, sizeof(info)); 1038 if (siginfo_err.Fail()) { 1039 LLDB_LOG(log, "PT_GET_SIGINFO failed {0}", siginfo_err); 1040 return; 1041 } 1042 assert(info.psi_lwpid >= 0); 1043 lldb::tid_t child_tid = info.psi_lwpid; 1044 1045 std::unique_ptr<NativeProcessNetBSD> child_process{ 1046 new NativeProcessNetBSD(static_cast<::pid_t>(child_pid), m_terminal_fd, 1047 m_delegate, m_arch, m_main_loop)}; 1048 if (!is_vfork) 1049 child_process->m_software_breakpoints = m_software_breakpoints; 1050 1051 Extension expected_ext = is_vfork ? Extension::vfork : Extension::fork; 1052 if ((m_enabled_extensions & expected_ext) == expected_ext) { 1053 child_process->SetupTrace(); 1054 for (const auto &thread : child_process->m_threads) 1055 static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(SIGSTOP); 1056 child_process->SetState(StateType::eStateStopped, false); 1057 1058 m_delegate.NewSubprocess(this, std::move(child_process)); 1059 if (is_vfork) 1060 parent_thread.SetStoppedByVFork(child_pid, child_tid); 1061 else 1062 parent_thread.SetStoppedByFork(child_pid, child_tid); 1063 SetState(StateType::eStateStopped, true); 1064 } else { 1065 child_process->Detach(); 1066 Status pt_error = 1067 PtraceWrapper(PT_CONTINUE, GetID(), reinterpret_cast<void *>(1), 0); 1068 if (pt_error.Fail()) { 1069 LLDB_LOG_ERROR(log, std::move(pt_error.ToError()), 1070 "unable to resume parent process {1}: {0}", GetID()); 1071 SetState(StateType::eStateInvalid); 1072 } 1073 } 1074 } 1075 1076 llvm::Expected<std::string> 1077 NativeProcessNetBSD::SaveCore(llvm::StringRef path_hint) { 1078 llvm::SmallString<128> path{path_hint}; 1079 Status error; 1080 1081 // Try with the suggested path first. 1082 if (!path.empty()) { 1083 error = PtraceWrapper(PT_DUMPCORE, GetID(), path.data(), path.size()); 1084 if (!error.Fail()) 1085 return path.str().str(); 1086 1087 // If the request errored, fall back to a generic temporary file. 1088 } 1089 1090 if (std::error_code errc = 1091 llvm::sys::fs::createTemporaryFile("lldb", "core", path)) 1092 return llvm::createStringError(errc, "Unable to create a temporary file"); 1093 1094 error = PtraceWrapper(PT_DUMPCORE, GetID(), path.data(), path.size()); 1095 if (error.Fail()) 1096 return error.ToError(); 1097 return path.str().str(); 1098 } 1099