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

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