contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

   1 //===-- ProcessFreeBSD.cpp ----------------------------------------*- C++
   2 //-*-===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include <errno.h>
  11 #include <pthread.h>
  12 #include <pthread_np.h>
  13 #include <stdlib.h>
  14 #include <sys/sysctl.h>
  15 #include <sys/types.h>
  16 #include <sys/user.h>
  17 #include <machine/elf.h>
  18
  19 #include <mutex>
  20 #include <unordered_map>
  21
  22 #include "lldb/Core/PluginManager.h"
  23 #include "lldb/Host/FileSystem.h"
  24 #include "lldb/Host/Host.h"
  25 #include "lldb/Symbol/ObjectFile.h"
  26 #include "lldb/Target/DynamicLoader.h"
  27 #include "lldb/Target/Target.h"
  28 #include "lldb/Utility/RegisterValue.h"
  29 #include "lldb/Utility/State.h"
  30
  31 #include "FreeBSDThread.h"
  32 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
  33 #include "Plugins/Process/Utility/FreeBSDSignals.h"
  34 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
  35 #include "ProcessFreeBSD.h"
  36 #include "ProcessMonitor.h"
  37
  38 #include "lldb/Breakpoint/BreakpointLocation.h"
  39 #include "lldb/Breakpoint/Watchpoint.h"
  40 #include "lldb/Core/Module.h"
  41 #include "lldb/Core/ModuleSpec.h"
  42 #include "lldb/Core/PluginManager.h"
  43 #include "lldb/Host/Host.h"
  44 #include "lldb/Symbol/ObjectFile.h"
  45 #include "lldb/Target/DynamicLoader.h"
  46 #include "lldb/Target/Platform.h"
  47 #include "lldb/Target/Target.h"
  48 #include "lldb/Utility/DataBufferHeap.h"
  49 #include "lldb/Utility/FileSpec.h"
  50 #include "lldb/Utility/State.h"
  51
  52 #include "lldb/Host/posix/Fcntl.h"
  53
  54 #include "llvm/Support/FileSystem.h"
  55 #include "llvm/Support/Threading.h"
  56
  57 using namespace lldb;
  58 using namespace lldb_private;
  59
  60 namespace {
  61 UnixSignalsSP &GetFreeBSDSignals() {
  62   static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals());
  63   return s_freebsd_signals_sp;
  64 }
  65 }
  66
  67 // Static functions.
  68
  69 lldb::ProcessSP
  70 ProcessFreeBSD::CreateInstance(lldb::TargetSP target_sp,
  71                                lldb::ListenerSP listener_sp,
  72                                const FileSpec *crash_file_path) {
  73   lldb::ProcessSP process_sp;
  74   if (crash_file_path == NULL)
  75     process_sp.reset(
  76         new ProcessFreeBSD(target_sp, listener_sp, GetFreeBSDSignals()));
  77   return process_sp;
  78 }
  79
  80 void ProcessFreeBSD::Initialize() {
  81   static llvm::once_flag g_once_flag;
  82
  83   llvm::call_once(g_once_flag, []() {
  84     PluginManager::RegisterPlugin(GetPluginNameStatic(),
  85                                   GetPluginDescriptionStatic(), CreateInstance);
  86   });
  87 }
  88
  89 lldb_private::ConstString ProcessFreeBSD::GetPluginNameStatic() {
  90   static ConstString g_name("freebsd");
  91   return g_name;
  92 }
  93
  94 const char *ProcessFreeBSD::GetPluginDescriptionStatic() {
  95   return "Process plugin for FreeBSD";
  96 }
  97
  98 // ProcessInterface protocol.
  99
 100 lldb_private::ConstString ProcessFreeBSD::GetPluginName() {
 101   return GetPluginNameStatic();
 102 }
 103
 104 uint32_t ProcessFreeBSD::GetPluginVersion() { return 1; }
 105
 106 void ProcessFreeBSD::Terminate() {}
 107
 108 Status ProcessFreeBSD::DoDetach(bool keep_stopped) {
 109   Status error;
 110   if (keep_stopped) {
 111     error.SetErrorString("Detaching with keep_stopped true is not currently "
 112                          "supported on FreeBSD.");
 113     return error;
 114   }
 115
 116   error = m_monitor->Detach(GetID());
 117
 118   if (error.Success())
 119     SetPrivateState(eStateDetached);
 120
 121   return error;
 122 }
 123
 124 Status ProcessFreeBSD::DoResume() {
 125   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 126
 127   SetPrivateState(eStateRunning);
 128
 129   std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 130   bool do_step = false;
 131   bool software_single_step = !SupportHardwareSingleStepping();
 132
 133   for (tid_collection::const_iterator t_pos = m_run_tids.begin(),
 134                                       t_end = m_run_tids.end();
 135        t_pos != t_end; ++t_pos) {
 136     m_monitor->ThreadSuspend(*t_pos, false);
 137   }
 138   for (tid_collection::const_iterator t_pos = m_step_tids.begin(),
 139                                       t_end = m_step_tids.end();
 140        t_pos != t_end; ++t_pos) {
 141     m_monitor->ThreadSuspend(*t_pos, false);
 142     do_step = true;
 143     if (software_single_step) {
 144       Status error = SetupSoftwareSingleStepping(*t_pos);
 145       if (error.Fail())
 146         return error;
 147     }
 148   }
 149   for (tid_collection::const_iterator t_pos = m_suspend_tids.begin(),
 150                                       t_end = m_suspend_tids.end();
 151        t_pos != t_end; ++t_pos) {
 152     m_monitor->ThreadSuspend(*t_pos, true);
 153     // XXX Cannot PT_CONTINUE properly with suspended threads.
 154     do_step = true;
 155   }
 156
 157   LLDB_LOGF(log, "process %" PRIu64 " resuming (%s)", GetID(),
 158             do_step ? "step" : "continue");
 159   if (do_step && !software_single_step)
 160     m_monitor->SingleStep(GetID(), m_resume_signo);
 161   else
 162     m_monitor->Resume(GetID(), m_resume_signo);
 163
 164   return Status();
 165 }
 166
 167 bool ProcessFreeBSD::UpdateThreadList(ThreadList &old_thread_list,
 168                                       ThreadList &new_thread_list) {
 169   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 170   LLDB_LOGF(log, "ProcessFreeBSD::%s (pid = %" PRIu64 ")", __FUNCTION__,
 171             GetID());
 172
 173   std::vector<lldb::pid_t> tds;
 174   if (!GetMonitor().GetCurrentThreadIDs(tds)) {
 175     return false;
 176   }
 177
 178   ThreadList old_thread_list_copy(old_thread_list);
 179   for (size_t i = 0; i < tds.size(); ++i) {
 180     tid_t tid = tds[i];
 181     ThreadSP thread_sp(old_thread_list_copy.RemoveThreadByID(tid, false));
 182     if (!thread_sp) {
 183       thread_sp.reset(new FreeBSDThread(*this, tid));
 184       LLDB_LOGF(log, "ProcessFreeBSD::%s new tid = %" PRIu64, __FUNCTION__,
 185                 tid);
 186     } else {
 187       LLDB_LOGF(log, "ProcessFreeBSD::%s existing tid = %" PRIu64, __FUNCTION__,
 188                 tid);
 189     }
 190     new_thread_list.AddThread(thread_sp);
 191   }
 192   for (size_t i = 0; i < old_thread_list_copy.GetSize(false); ++i) {
 193     ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(i, false));
 194     if (old_thread_sp) {
 195       LLDB_LOGF(log, "ProcessFreeBSD::%s remove tid", __FUNCTION__);
 196     }
 197   }
 198
 199   return true;
 200 }
 201
 202 Status ProcessFreeBSD::WillResume() {
 203   m_resume_signo = 0;
 204   m_suspend_tids.clear();
 205   m_run_tids.clear();
 206   m_step_tids.clear();
 207   return Process::WillResume();
 208 }
 209
 210 void ProcessFreeBSD::SendMessage(const ProcessMessage &message) {
 211   std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
 212
 213   switch (message.GetKind()) {
 214   case ProcessMessage::eInvalidMessage:
 215     return;
 216
 217   case ProcessMessage::eAttachMessage:
 218     SetPrivateState(eStateStopped);
 219     return;
 220
 221   case ProcessMessage::eLimboMessage:
 222   case ProcessMessage::eExitMessage:
 223     SetExitStatus(message.GetExitStatus(), NULL);
 224     break;
 225
 226   case ProcessMessage::eSignalMessage:
 227   case ProcessMessage::eSignalDeliveredMessage:
 228   case ProcessMessage::eBreakpointMessage:
 229   case ProcessMessage::eTraceMessage:
 230   case ProcessMessage::eWatchpointMessage:
 231   case ProcessMessage::eCrashMessage:
 232     SetPrivateState(eStateStopped);
 233     break;
 234
 235   case ProcessMessage::eNewThreadMessage:
 236     llvm_unreachable("eNewThreadMessage unexpected on FreeBSD");
 237     break;
 238
 239   case ProcessMessage::eExecMessage:
 240     SetPrivateState(eStateStopped);
 241     break;
 242   }
 243
 244   m_message_queue.push(message);
 245 }
 246
 247 // Constructors and destructors.
 248
 249 ProcessFreeBSD::ProcessFreeBSD(lldb::TargetSP target_sp,
 250                                lldb::ListenerSP listener_sp,
 251                                UnixSignalsSP &unix_signals_sp)
 252     : Process(target_sp, listener_sp, unix_signals_sp),
 253       m_byte_order(endian::InlHostByteOrder()), m_monitor(NULL), m_module(NULL),
 254       m_message_mutex(), m_exit_now(false), m_seen_initial_stop(),
 255       m_resume_signo(0) {
 256   // FIXME: Putting this code in the ctor and saving the byte order in a
 257   // member variable is a hack to avoid const qual issues in GetByteOrder.
 258   lldb::ModuleSP module = GetTarget().GetExecutableModule();
 259   if (module && module->GetObjectFile())
 260     m_byte_order = module->GetObjectFile()->GetByteOrder();
 261 }
 262
 263 ProcessFreeBSD::~ProcessFreeBSD() { delete m_monitor; }
 264
 265 // Process protocol.
 266 void ProcessFreeBSD::Finalize() {
 267   Process::Finalize();
 268
 269   if (m_monitor)
 270     m_monitor->StopMonitor();
 271 }
 272
 273 bool ProcessFreeBSD::CanDebug(lldb::TargetSP target_sp,
 274                               bool plugin_specified_by_name) {
 275   // For now we are just making sure the file exists for a given module
 276   ModuleSP exe_module_sp(target_sp->GetExecutableModule());
 277   if (exe_module_sp.get())
 278     return FileSystem::Instance().Exists(exe_module_sp->GetFileSpec());
 279   // If there is no executable module, we return true since we might be
 280   // preparing to attach.
 281   return true;
 282 }
 283
 284 Status
 285 ProcessFreeBSD::DoAttachToProcessWithID(lldb::pid_t pid,
 286                                         const ProcessAttachInfo &attach_info) {
 287   Status error;
 288   assert(m_monitor == NULL);
 289
 290   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 291   LLDB_LOGV(log, "pid = {0}", GetID());
 292
 293   m_monitor = new ProcessMonitor(this, pid, error);
 294
 295   if (!error.Success())
 296     return error;
 297
 298   PlatformSP platform_sp(GetTarget().GetPlatform());
 299   assert(platform_sp.get());
 300   if (!platform_sp)
 301     return error; // FIXME: Detatch?
 302
 303   // Find out what we can about this process
 304   ProcessInstanceInfo process_info;
 305   platform_sp->GetProcessInfo(pid, process_info);
 306
 307   // Resolve the executable module
 308   ModuleSP exe_module_sp;
 309   FileSpecList executable_search_paths(
 310       Target::GetDefaultExecutableSearchPaths());
 311   ModuleSpec exe_module_spec(process_info.GetExecutableFile(),
 312                              GetTarget().GetArchitecture());
 313   error = platform_sp->ResolveExecutable(
 314       exe_module_spec, exe_module_sp,
 315       executable_search_paths.GetSize() ? &executable_search_paths : NULL);
 316   if (!error.Success())
 317     return error;
 318
 319   // Fix the target architecture if necessary
 320   const ArchSpec &module_arch = exe_module_sp->GetArchitecture();
 321   if (module_arch.IsValid() &&
 322       !GetTarget().GetArchitecture().IsExactMatch(module_arch))
 323     GetTarget().SetArchitecture(module_arch);
 324
 325   // Initialize the target module list
 326   GetTarget().SetExecutableModule(exe_module_sp, eLoadDependentsYes);
 327
 328   SetSTDIOFileDescriptor(m_monitor->GetTerminalFD());
 329
 330   SetID(pid);
 331
 332   return error;
 333 }
 334
 335 Status ProcessFreeBSD::WillLaunch(Module *module) {
 336   Status error;
 337   return error;
 338 }
 339
 340 FileSpec
 341 ProcessFreeBSD::GetFileSpec(const lldb_private::FileAction *file_action,
 342                             const FileSpec &default_file_spec,
 343                             const FileSpec &dbg_pts_file_spec) {
 344   FileSpec file_spec{};
 345
 346   if (file_action && file_action->GetAction() == FileAction::eFileActionOpen) {
 347     file_spec = file_action->GetFileSpec();
 348     // By default the stdio paths passed in will be pseudo-terminal (/dev/pts).
 349     // If so, convert to using a different default path instead to redirect I/O
 350     // to the debugger console. This should also handle user overrides to
 351     // /dev/null or a different file.
 352     if (!file_spec || file_spec == dbg_pts_file_spec)
 353       file_spec = default_file_spec;
 354   }
 355   return file_spec;
 356 }
 357
 358 Status ProcessFreeBSD::DoLaunch(Module *module,
 359                                 ProcessLaunchInfo &launch_info) {
 360   Status error;
 361   assert(m_monitor == NULL);
 362
 363   FileSpec working_dir = launch_info.GetWorkingDirectory();
 364   if (working_dir) {
 365     FileSystem::Instance().Resolve(working_dir);
 366     if (!FileSystem::Instance().IsDirectory(working_dir.GetPath())) {
 367       error.SetErrorStringWithFormat("No such file or directory: %s",
 368                                    working_dir.GetCString());
 369       return error;
 370     }
 371   }
 372
 373   SetPrivateState(eStateLaunching);
 374
 375   const lldb_private::FileAction *file_action;
 376
 377   // Default of empty will mean to use existing open file descriptors
 378   FileSpec stdin_file_spec{};
 379   FileSpec stdout_file_spec{};
 380   FileSpec stderr_file_spec{};
 381
 382   const FileSpec dbg_pts_file_spec{launch_info.GetPTY().GetSlaveName(NULL, 0)};
 383
 384   file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
 385   stdin_file_spec =
 386       GetFileSpec(file_action, stdin_file_spec, dbg_pts_file_spec);
 387
 388   file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
 389   stdout_file_spec =
 390       GetFileSpec(file_action, stdout_file_spec, dbg_pts_file_spec);
 391
 392   file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
 393   stderr_file_spec =
 394       GetFileSpec(file_action, stderr_file_spec, dbg_pts_file_spec);
 395
 396   m_monitor = new ProcessMonitor(
 397       this, module, launch_info.GetArguments().GetConstArgumentVector(),
 398       launch_info.GetEnvironment(), stdin_file_spec, stdout_file_spec,
 399       stderr_file_spec, working_dir, launch_info, error);
 400
 401   m_module = module;
 402
 403   if (!error.Success())
 404     return error;
 405
 406   int terminal = m_monitor->GetTerminalFD();
 407   if (terminal >= 0) {
 408 // The reader thread will close the file descriptor when done, so we pass it a
 409 // copy.
 410 #ifdef F_DUPFD_CLOEXEC
 411     int stdio = fcntl(terminal, F_DUPFD_CLOEXEC, 0);
 412     if (stdio == -1) {
 413       error.SetErrorToErrno();
 414       return error;
 415     }
 416 #else
 417     // Special case when F_DUPFD_CLOEXEC does not exist (Debian kFreeBSD)
 418     int stdio = fcntl(terminal, F_DUPFD, 0);
 419     if (stdio == -1) {
 420       error.SetErrorToErrno();
 421       return error;
 422     }
 423     stdio = fcntl(terminal, F_SETFD, FD_CLOEXEC);
 424     if (stdio == -1) {
 425       error.SetErrorToErrno();
 426       return error;
 427     }
 428 #endif
 429     SetSTDIOFileDescriptor(stdio);
 430   }
 431
 432   SetID(m_monitor->GetPID());
 433   return error;
 434 }
 435
 436 void ProcessFreeBSD::DidLaunch() {}
 437
 438 addr_t ProcessFreeBSD::GetImageInfoAddress() {
 439   Target *target = &GetTarget();
 440   ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
 441   Address addr = obj_file->GetImageInfoAddress(target);
 442
 443   if (addr.IsValid())
 444     return addr.GetLoadAddress(target);
 445   return LLDB_INVALID_ADDRESS;
 446 }
 447
 448 Status ProcessFreeBSD::DoHalt(bool &caused_stop) {
 449   Status error;
 450
 451   if (IsStopped()) {
 452     caused_stop = false;
 453   } else if (kill(GetID(), SIGSTOP)) {
 454     caused_stop = false;
 455     error.SetErrorToErrno();
 456   } else {
 457     caused_stop = true;
 458   }
 459   return error;
 460 }
 461
 462 Status ProcessFreeBSD::DoSignal(int signal) {
 463   Status error;
 464
 465   if (kill(GetID(), signal))
 466     error.SetErrorToErrno();
 467
 468   return error;
 469 }
 470
 471 Status ProcessFreeBSD::DoDestroy() {
 472   Status error;
 473
 474   if (!HasExited()) {
 475     assert(m_monitor);
 476     m_exit_now = true;
 477     if (GetID() == LLDB_INVALID_PROCESS_ID) {
 478       error.SetErrorString("invalid process id");
 479       return error;
 480     }
 481     if (!m_monitor->Kill()) {
 482       error.SetErrorToErrno();
 483       return error;
 484     }
 485
 486     SetPrivateState(eStateExited);
 487   }
 488
 489   return error;
 490 }
 491
 492 void ProcessFreeBSD::DoDidExec() {
 493   Target *target = &GetTarget();
 494   if (target) {
 495     PlatformSP platform_sp(target->GetPlatform());
 496     assert(platform_sp.get());
 497     if (platform_sp) {
 498       ProcessInstanceInfo process_info;
 499       platform_sp->GetProcessInfo(GetID(), process_info);
 500       ModuleSP exe_module_sp;
 501       ModuleSpec exe_module_spec(process_info.GetExecutableFile(),
 502                                  target->GetArchitecture());
 503       FileSpecList executable_search_paths(
 504           Target::GetDefaultExecutableSearchPaths());
 505       Status error = platform_sp->ResolveExecutable(
 506           exe_module_spec, exe_module_sp,
 507           executable_search_paths.GetSize() ? &executable_search_paths : NULL);
 508       if (!error.Success())
 509         return;
 510       target->SetExecutableModule(exe_module_sp, eLoadDependentsYes);
 511     }
 512   }
 513 }
 514
 515 bool ProcessFreeBSD::AddThreadForInitialStopIfNeeded(lldb::tid_t stop_tid) {
 516   bool added_to_set = false;
 517   ThreadStopSet::iterator it = m_seen_initial_stop.find(stop_tid);
 518   if (it == m_seen_initial_stop.end()) {
 519     m_seen_initial_stop.insert(stop_tid);
 520     added_to_set = true;
 521   }
 522   return added_to_set;
 523 }
 524
 525 bool ProcessFreeBSD::WaitingForInitialStop(lldb::tid_t stop_tid) {
 526   return (m_seen_initial_stop.find(stop_tid) == m_seen_initial_stop.end());
 527 }
 528
 529 FreeBSDThread *
 530 ProcessFreeBSD::CreateNewFreeBSDThread(lldb_private::Process &process,
 531                                        lldb::tid_t tid) {
 532   return new FreeBSDThread(process, tid);
 533 }
 534
 535 void ProcessFreeBSD::RefreshStateAfterStop() {
 536   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 537   LLDB_LOGV(log, "message_queue size = {0}", m_message_queue.size());
 538
 539   std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
 540
 541   // This method used to only handle one message.  Changing it to loop allows
 542   // it to handle the case where we hit a breakpoint while handling a different
 543   // breakpoint.
 544   while (!m_message_queue.empty()) {
 545     ProcessMessage &message = m_message_queue.front();
 546
 547     // Resolve the thread this message corresponds to and pass it along.
 548     lldb::tid_t tid = message.GetTID();
 549     LLDB_LOGV(log, " message_queue size = {0}, pid = {1}",
 550               m_message_queue.size(), tid);
 551
 552     m_thread_list.RefreshStateAfterStop();
 553
 554     FreeBSDThread *thread = static_cast<FreeBSDThread *>(
 555         GetThreadList().FindThreadByID(tid, false).get());
 556     if (thread)
 557       thread->Notify(message);
 558
 559     if (message.GetKind() == ProcessMessage::eExitMessage) {
 560       // FIXME: We should tell the user about this, but the limbo message is
 561       // probably better for that.
 562       LLDB_LOG(log, "removing thread, tid = {0}", tid);
 563       std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 564
 565       ThreadSP thread_sp = m_thread_list.RemoveThreadByID(tid, false);
 566       thread_sp.reset();
 567       m_seen_initial_stop.erase(tid);
 568     }
 569
 570     m_message_queue.pop();
 571   }
 572 }
 573
 574 bool ProcessFreeBSD::IsAlive() {
 575   StateType state = GetPrivateState();
 576   return state != eStateDetached && state != eStateExited &&
 577          state != eStateInvalid && state != eStateUnloaded;
 578 }
 579
 580 size_t ProcessFreeBSD::DoReadMemory(addr_t vm_addr, void *buf, size_t size,
 581                                     Status &error) {
 582   assert(m_monitor);
 583   return m_monitor->ReadMemory(vm_addr, buf, size, error);
 584 }
 585
 586 size_t ProcessFreeBSD::DoWriteMemory(addr_t vm_addr, const void *buf,
 587                                      size_t size, Status &error) {
 588   assert(m_monitor);
 589   return m_monitor->WriteMemory(vm_addr, buf, size, error);
 590 }
 591
 592 addr_t ProcessFreeBSD::DoAllocateMemory(size_t size, uint32_t permissions,
 593                                         Status &error) {
 594   addr_t allocated_addr = LLDB_INVALID_ADDRESS;
 595
 596   unsigned prot = 0;
 597   if (permissions & lldb::ePermissionsReadable)
 598     prot |= eMmapProtRead;
 599   if (permissions & lldb::ePermissionsWritable)
 600     prot |= eMmapProtWrite;
 601   if (permissions & lldb::ePermissionsExecutable)
 602     prot |= eMmapProtExec;
 603
 604   if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
 605                        eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) {
 606     m_addr_to_mmap_size[allocated_addr] = size;
 607     error.Clear();
 608   } else {
 609     allocated_addr = LLDB_INVALID_ADDRESS;
 610     error.SetErrorStringWithFormat(
 611         "unable to allocate %zu bytes of memory with permissions %s", size,
 612         GetPermissionsAsCString(permissions));
 613   }
 614
 615   return allocated_addr;
 616 }
 617
 618 Status ProcessFreeBSD::DoDeallocateMemory(lldb::addr_t addr) {
 619   Status error;
 620   MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
 621   if (pos != m_addr_to_mmap_size.end() &&
 622       InferiorCallMunmap(this, addr, pos->second))
 623     m_addr_to_mmap_size.erase(pos);
 624   else
 625     error.SetErrorStringWithFormat("unable to deallocate memory at 0x%" PRIx64,
 626                                    addr);
 627
 628   return error;
 629 }
 630
 631 size_t
 632 ProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
 633   static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xD4};
 634   static const uint8_t g_i386_opcode[] = {0xCC};
 635
 636   ArchSpec arch = GetTarget().GetArchitecture();
 637   const uint8_t *opcode = NULL;
 638   size_t opcode_size = 0;
 639
 640   switch (arch.GetMachine()) {
 641   default:
 642     assert(false && "CPU type not supported!");
 643     break;
 644
 645   case llvm::Triple::arm: {
 646     // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
 647     // linux kernel does otherwise.
 648     static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
 649     static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
 650
 651     lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
 652     AddressClass addr_class = AddressClass::eUnknown;
 653
 654     if (bp_loc_sp)
 655       addr_class = bp_loc_sp->GetAddress().GetAddressClass();
 656
 657     if (addr_class == AddressClass::eCodeAlternateISA ||
 658         (addr_class == AddressClass::eUnknown &&
 659          bp_loc_sp->GetAddress().GetOffset() & 1)) {
 660       opcode = g_thumb_breakpoint_opcode;
 661       opcode_size = sizeof(g_thumb_breakpoint_opcode);
 662     } else {
 663       opcode = g_arm_breakpoint_opcode;
 664       opcode_size = sizeof(g_arm_breakpoint_opcode);
 665     }
 666   } break;
 667   case llvm::Triple::aarch64:
 668     opcode = g_aarch64_opcode;
 669     opcode_size = sizeof(g_aarch64_opcode);
 670     break;
 671
 672   case llvm::Triple::x86:
 673   case llvm::Triple::x86_64:
 674     opcode = g_i386_opcode;
 675     opcode_size = sizeof(g_i386_opcode);
 676     break;
 677   }
 678
 679   bp_site->SetTrapOpcode(opcode, opcode_size);
 680   return opcode_size;
 681 }
 682
 683 Status ProcessFreeBSD::EnableBreakpointSite(BreakpointSite *bp_site) {
 684   return EnableSoftwareBreakpoint(bp_site);
 685 }
 686
 687 Status ProcessFreeBSD::DisableBreakpointSite(BreakpointSite *bp_site) {
 688   return DisableSoftwareBreakpoint(bp_site);
 689 }
 690
 691 Status ProcessFreeBSD::EnableWatchpoint(Watchpoint *wp, bool notify) {
 692   Status error;
 693   if (wp) {
 694     user_id_t watchID = wp->GetID();
 695     addr_t addr = wp->GetLoadAddress();
 696     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
 697     LLDB_LOGF(log, "ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64 ")",
 698               watchID);
 699     if (wp->IsEnabled()) {
 700       LLDB_LOGF(log,
 701                 "ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64
 702                 ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
 703                 watchID, (uint64_t)addr);
 704       return error;
 705     }
 706
 707     // Try to find a vacant watchpoint slot in the inferiors' main thread
 708     uint32_t wp_hw_index = LLDB_INVALID_INDEX32;
 709     std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 710     FreeBSDThread *thread = static_cast<FreeBSDThread *>(
 711         m_thread_list.GetThreadAtIndex(0, false).get());
 712
 713     if (thread)
 714       wp_hw_index = thread->FindVacantWatchpointIndex();
 715
 716     if (wp_hw_index == LLDB_INVALID_INDEX32) {
 717       error.SetErrorString("Setting hardware watchpoint failed.");
 718     } else {
 719       wp->SetHardwareIndex(wp_hw_index);
 720       bool wp_enabled = true;
 721       uint32_t thread_count = m_thread_list.GetSize(false);
 722       for (uint32_t i = 0; i < thread_count; ++i) {
 723         thread = static_cast<FreeBSDThread *>(
 724             m_thread_list.GetThreadAtIndex(i, false).get());
 725         if (thread)
 726           wp_enabled &= thread->EnableHardwareWatchpoint(wp);
 727         else
 728           wp_enabled = false;
 729       }
 730       if (wp_enabled) {
 731         wp->SetEnabled(true, notify);
 732         return error;
 733       } else {
 734         // Watchpoint enabling failed on at least one of the threads so roll
 735         // back all of them
 736         DisableWatchpoint(wp, false);
 737         error.SetErrorString("Setting hardware watchpoint failed");
 738       }
 739     }
 740   } else
 741     error.SetErrorString("Watchpoint argument was NULL.");
 742   return error;
 743 }
 744
 745 Status ProcessFreeBSD::DisableWatchpoint(Watchpoint *wp, bool notify) {
 746   Status error;
 747   if (wp) {
 748     user_id_t watchID = wp->GetID();
 749     addr_t addr = wp->GetLoadAddress();
 750     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
 751     LLDB_LOGF(log, "ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64 ")",
 752               watchID);
 753     if (!wp->IsEnabled()) {
 754       LLDB_LOGF(log,
 755                 "ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64
 756                 ") addr = 0x%8.8" PRIx64 ": watchpoint already disabled.",
 757                 watchID, (uint64_t)addr);
 758       // This is needed (for now) to keep watchpoints disabled correctly
 759       wp->SetEnabled(false, notify);
 760       return error;
 761     }
 762
 763     if (wp->IsHardware()) {
 764       bool wp_disabled = true;
 765       std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 766       uint32_t thread_count = m_thread_list.GetSize(false);
 767       for (uint32_t i = 0; i < thread_count; ++i) {
 768         FreeBSDThread *thread = static_cast<FreeBSDThread *>(
 769             m_thread_list.GetThreadAtIndex(i, false).get());
 770         if (thread)
 771           wp_disabled &= thread->DisableHardwareWatchpoint(wp);
 772         else
 773           wp_disabled = false;
 774       }
 775       if (wp_disabled) {
 776         wp->SetHardwareIndex(LLDB_INVALID_INDEX32);
 777         wp->SetEnabled(false, notify);
 778         return error;
 779       } else
 780         error.SetErrorString("Disabling hardware watchpoint failed");
 781     }
 782   } else
 783     error.SetErrorString("Watchpoint argument was NULL.");
 784   return error;
 785 }
 786
 787 Status ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num) {
 788   Status error;
 789   std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 790   FreeBSDThread *thread = static_cast<FreeBSDThread *>(
 791       m_thread_list.GetThreadAtIndex(0, false).get());
 792   if (thread)
 793     num = thread->NumSupportedHardwareWatchpoints();
 794   else
 795     error.SetErrorString("Process does not exist.");
 796   return error;
 797 }
 798
 799 Status ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num, bool &after) {
 800   Status error = GetWatchpointSupportInfo(num);
 801   // Watchpoints trigger and halt the inferior after the corresponding
 802   // instruction has been executed.
 803   after = true;
 804   return error;
 805 }
 806
 807 uint32_t ProcessFreeBSD::UpdateThreadListIfNeeded() {
 808   std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 809   // Do not allow recursive updates.
 810   return m_thread_list.GetSize(false);
 811 }
 812
 813 ByteOrder ProcessFreeBSD::GetByteOrder() const {
 814   // FIXME: We should be able to extract this value directly.  See comment in
 815   // ProcessFreeBSD().
 816   return m_byte_order;
 817 }
 818
 819 size_t ProcessFreeBSD::PutSTDIN(const char *buf, size_t len, Status &error) {
 820   ssize_t status;
 821   if ((status = write(m_monitor->GetTerminalFD(), buf, len)) < 0) {
 822     error.SetErrorToErrno();
 823     return 0;
 824   }
 825   return status;
 826 }
 827
 828 // Utility functions.
 829
 830 bool ProcessFreeBSD::HasExited() {
 831   switch (GetPrivateState()) {
 832   default:
 833     break;
 834
 835   case eStateDetached:
 836   case eStateExited:
 837     return true;
 838   }
 839
 840   return false;
 841 }
 842
 843 bool ProcessFreeBSD::IsStopped() {
 844   switch (GetPrivateState()) {
 845   default:
 846     break;
 847
 848   case eStateStopped:
 849   case eStateCrashed:
 850   case eStateSuspended:
 851     return true;
 852   }
 853
 854   return false;
 855 }
 856
 857 bool ProcessFreeBSD::IsAThreadRunning() {
 858   bool is_running = false;
 859   std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 860   uint32_t thread_count = m_thread_list.GetSize(false);
 861   for (uint32_t i = 0; i < thread_count; ++i) {
 862     FreeBSDThread *thread = static_cast<FreeBSDThread *>(
 863         m_thread_list.GetThreadAtIndex(i, false).get());
 864     StateType thread_state = thread->GetState();
 865     if (thread_state == eStateRunning || thread_state == eStateStepping) {
 866       is_running = true;
 867       break;
 868     }
 869   }
 870   return is_running;
 871 }
 872
 873 lldb_private::DataExtractor ProcessFreeBSD::GetAuxvData() {
 874   // If we're the local platform, we can ask the host for auxv data.
 875   PlatformSP platform_sp = GetTarget().GetPlatform();
 876   assert(platform_sp && platform_sp->IsHost());
 877
 878   int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_AUXV, (int)m_process->GetID()};
 879   size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
 880   DataBufferSP buf_sp(new DataBufferHeap(auxv_size, 0));
 881
 882   if (::sysctl(mib, 4, buf_sp->GetBytes(), &auxv_size, NULL, 0) != 0) {
 883     perror("sysctl failed on auxv");
 884     buf_sp.reset();
 885   }
 886
 887   return DataExtractor(buf_sp, GetByteOrder(), GetAddressByteSize());
 888 }
 889
 890 struct EmulatorBaton {
 891   ProcessFreeBSD *m_process;
 892   RegisterContext *m_reg_context;
 893
 894   // eRegisterKindDWARF -> RegisterValue
 895   std::unordered_map<uint32_t, RegisterValue> m_register_values;
 896
 897   EmulatorBaton(ProcessFreeBSD *process, RegisterContext *reg_context)
 898       : m_process(process), m_reg_context(reg_context) {}
 899 };
 900
 901 static size_t ReadMemoryCallback(EmulateInstruction *instruction, void *baton,
 902                                  const EmulateInstruction::Context &context,
 903                                  lldb::addr_t addr, void *dst, size_t length) {
 904   EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
 905
 906   Status error;
 907   size_t bytes_read =
 908       emulator_baton->m_process->DoReadMemory(addr, dst, length, error);
 909   if (!error.Success())
 910     bytes_read = 0;
 911   return bytes_read;
 912 }
 913
 914 static bool ReadRegisterCallback(EmulateInstruction *instruction, void *baton,
 915                                  const RegisterInfo *reg_info,
 916                                  RegisterValue &reg_value) {
 917   EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
 918
 919   auto it = emulator_baton->m_register_values.find(
 920       reg_info->kinds[eRegisterKindDWARF]);
 921   if (it != emulator_baton->m_register_values.end()) {
 922     reg_value = it->second;
 923     return true;
 924   }
 925
 926   // The emulator only fills in the dwarf register numbers (and in some cases
 927   // the generic register numbers). Get the full register info from the
 928   // register context based on the dwarf register numbers.
 929   const RegisterInfo *full_reg_info =
 930       emulator_baton->m_reg_context->GetRegisterInfo(
 931           eRegisterKindDWARF, reg_info->kinds[eRegisterKindDWARF]);
 932
 933   bool error =
 934       emulator_baton->m_reg_context->ReadRegister(full_reg_info, reg_value);
 935   return error;
 936 }
 937
 938 static bool WriteRegisterCallback(EmulateInstruction *instruction, void *baton,
 939                                   const EmulateInstruction::Context &context,
 940                                   const RegisterInfo *reg_info,
 941                                   const RegisterValue &reg_value) {
 942   EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
 943   emulator_baton->m_register_values[reg_info->kinds[eRegisterKindDWARF]] =
 944       reg_value;
 945   return true;
 946 }
 947
 948 static size_t WriteMemoryCallback(EmulateInstruction *instruction, void *baton,
 949                                   const EmulateInstruction::Context &context,
 950                                   lldb::addr_t addr, const void *dst,
 951                                   size_t length) {
 952   return length;
 953 }
 954
 955 bool ProcessFreeBSD::SingleStepBreakpointHit(
 956     void *baton, lldb_private::StoppointCallbackContext *context,
 957     lldb::user_id_t break_id, lldb::user_id_t break_loc_id) {
 958   return false;
 959 }
 960
 961 Status ProcessFreeBSD::SetSoftwareSingleStepBreakpoint(lldb::tid_t tid,
 962                                                        lldb::addr_t addr) {
 963   Status error;
 964
 965   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 966   if (log) {
 967     LLDB_LOGF(log, "ProcessFreeBSD::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
 968     LLDB_LOGF(log, "SoftwareBreakpoint::%s addr = 0x%" PRIx64, __FUNCTION__,
 969               addr);
 970   }
 971
 972   // Validate the address.
 973   if (addr == LLDB_INVALID_ADDRESS)
 974     return Status("ProcessFreeBSD::%s invalid load address specified.",
 975                   __FUNCTION__);
 976
 977   Breakpoint *const sw_step_break =
 978       m_process->GetTarget().CreateBreakpoint(addr, true, false).get();
 979   sw_step_break->SetCallback(SingleStepBreakpointHit, this, true);
 980   sw_step_break->SetBreakpointKind("software-single-step");
 981
 982   LLDB_LOGF(log, "ProcessFreeBSD::%s addr = 0x%" PRIx64 " -- SUCCESS",
 983             __FUNCTION__, addr);
 984
 985   m_threads_stepping_with_breakpoint.insert({tid, sw_step_break->GetID()});
 986   return Status();
 987 }
 988
 989 bool ProcessFreeBSD::IsSoftwareStepBreakpoint(lldb::tid_t tid) {
 990   ThreadSP thread = GetThreadList().FindThreadByID(tid);
 991   if (!thread)
 992     return false;
 993
 994   assert(thread->GetRegisterContext());
 995   lldb::addr_t stop_pc = thread->GetRegisterContext()->GetPC();
 996
 997   const auto &iter = m_threads_stepping_with_breakpoint.find(tid);
 998   if (iter == m_threads_stepping_with_breakpoint.end())
 999     return false;
1000
1001   lldb::break_id_t bp_id = iter->second;
1002   BreakpointSP bp = GetTarget().GetBreakpointByID(bp_id);
1003   if (!bp)
1004     return false;
1005
1006   BreakpointLocationSP bp_loc = bp->FindLocationByAddress(stop_pc);
1007   if (!bp_loc)
1008     return false;
1009
1010   GetTarget().RemoveBreakpointByID(bp_id);
1011   m_threads_stepping_with_breakpoint.erase(tid);
1012   return true;
1013 }
1014
1015 bool ProcessFreeBSD::SupportHardwareSingleStepping() const {
1016   lldb_private::ArchSpec arch = GetTarget().GetArchitecture();
1017   if (arch.GetMachine() == llvm::Triple::arm || arch.IsMIPS())
1018     return false;
1019   return true;
1020 }
1021
1022 Status ProcessFreeBSD::SetupSoftwareSingleStepping(lldb::tid_t tid) {
1023   std::unique_ptr<EmulateInstruction> emulator_up(
1024       EmulateInstruction::FindPlugin(GetTarget().GetArchitecture(),
1025                                      eInstructionTypePCModifying, nullptr));
1026
1027   if (emulator_up == nullptr)
1028     return Status("Instruction emulator not found!");
1029
1030   FreeBSDThread *thread = static_cast<FreeBSDThread *>(
1031       m_thread_list.FindThreadByID(tid, false).get());
1032   if (thread == NULL)
1033     return Status("Thread not found not found!");
1034
1035   lldb::RegisterContextSP register_context_sp = thread->GetRegisterContext();
1036
1037   EmulatorBaton baton(this, register_context_sp.get());
1038   emulator_up->SetBaton(&baton);
1039   emulator_up->SetReadMemCallback(&ReadMemoryCallback);
1040   emulator_up->SetReadRegCallback(&ReadRegisterCallback);
1041   emulator_up->SetWriteMemCallback(&WriteMemoryCallback);
1042   emulator_up->SetWriteRegCallback(&WriteRegisterCallback);
1043
1044   if (!emulator_up->ReadInstruction())
1045     return Status("Read instruction failed!");
1046
1047   bool emulation_result =
1048       emulator_up->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC);
1049   const RegisterInfo *reg_info_pc = register_context_sp->GetRegisterInfo(
1050       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1051   auto pc_it =
1052       baton.m_register_values.find(reg_info_pc->kinds[eRegisterKindDWARF]);
1053
1054   lldb::addr_t next_pc;
1055   if (emulation_result) {
1056     assert(pc_it != baton.m_register_values.end() &&
1057            "Emulation was successful but PC wasn't updated");
1058     next_pc = pc_it->second.GetAsUInt64();
1059   } else if (pc_it == baton.m_register_values.end()) {
1060     // Emulate instruction failed and it haven't changed PC. Advance PC with
1061     // the size of the current opcode because the emulation of all
1062     // PC modifying instruction should be successful. The failure most
1063     // likely caused by a not supported instruction which don't modify PC.
1064     next_pc =
1065         register_context_sp->GetPC() + emulator_up->GetOpcode().GetByteSize();
1066   } else {
1067     // The instruction emulation failed after it modified the PC. It is an
1068     // unknown error where we can't continue because the next instruction is
1069     // modifying the PC but we don't  know how.
1070     return Status("Instruction emulation failed unexpectedly");
1071   }
1072
1073   SetSoftwareSingleStepBreakpoint(tid, next_pc);
1074   return Status();
1075 }