contrib/llvm/tools/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

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