contrib/llvm/tools/lldb/source/Plugins/Process/POSIX/ProcessPOSIX.cpp

   1 //===-- ProcessPOSIX.cpp ----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/lldb-python.h"
  11
  12 // C Includes
  13 #include <errno.h>
  14
  15 // C++ Includes
  16 // Other libraries and framework includes
  17 #include "lldb/Breakpoint/Watchpoint.h"
  18 #include "lldb/Core/Module.h"
  19 #include "lldb/Core/PluginManager.h"
  20 #include "lldb/Core/State.h"
  21 #include "lldb/Host/FileSpec.h"
  22 #include "lldb/Host/Host.h"
  23 #include "lldb/Symbol/ObjectFile.h"
  24 #include "lldb/Target/DynamicLoader.h"
  25 #include "lldb/Target/Platform.h"
  26 #include "lldb/Target/Target.h"
  27
  28 #include "ProcessPOSIX.h"
  29 #include "ProcessPOSIXLog.h"
  30 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
  31 #include "ProcessMonitor.h"
  32 #include "POSIXThread.h"
  33
  34 using namespace lldb;
  35 using namespace lldb_private;
  36
  37 //------------------------------------------------------------------------------
  38 // Static functions.
  39 #if 0
  40 Process*
  41 ProcessPOSIX::CreateInstance(Target& target, Listener &listener)
  42 {
  43     return new ProcessPOSIX(target, listener);
  44 }
  45
  46
  47 void
  48 ProcessPOSIX::Initialize()
  49 {
  50     static bool g_initialized = false;
  51
  52     if (!g_initialized)
  53     {
  54         g_initialized = true;
  55         PluginManager::RegisterPlugin(GetPluginNameStatic(),
  56                                       GetPluginDescriptionStatic(),
  57                                       CreateInstance);
  58
  59         Log::Callbacks log_callbacks = {
  60             ProcessPOSIXLog::DisableLog,
  61             ProcessPOSIXLog::EnableLog,
  62             ProcessPOSIXLog::ListLogCategories
  63         };
  64
  65         Log::RegisterLogChannel (ProcessPOSIX::GetPluginNameStatic(), log_callbacks);
  66     }
  67 }
  68 #endif
  69
  70 //------------------------------------------------------------------------------
  71 // Constructors and destructors.
  72
  73 ProcessPOSIX::ProcessPOSIX(Target& target, Listener &listener)
  74     : Process(target, listener),
  75       m_byte_order(lldb::endian::InlHostByteOrder()),
  76       m_monitor(NULL),
  77       m_module(NULL),
  78       m_message_mutex (Mutex::eMutexTypeRecursive),
  79       m_exit_now(false),
  80       m_seen_initial_stop()
  81 {
  82     // FIXME: Putting this code in the ctor and saving the byte order in a
  83     // member variable is a hack to avoid const qual issues in GetByteOrder.
  84         lldb::ModuleSP module = GetTarget().GetExecutableModule();
  85         if (module && module->GetObjectFile())
  86                 m_byte_order = module->GetObjectFile()->GetByteOrder();
  87 }
  88
  89 ProcessPOSIX::~ProcessPOSIX()
  90 {
  91     delete m_monitor;
  92 }
  93
  94 //------------------------------------------------------------------------------
  95 // Process protocol.
  96 void
  97 ProcessPOSIX::Finalize()
  98 {
  99   Process::Finalize();
 100
 101   if (m_monitor)
 102     m_monitor->StopMonitor();
 103 }
 104
 105 bool
 106 ProcessPOSIX::CanDebug(Target &target, bool plugin_specified_by_name)
 107 {
 108     // For now we are just making sure the file exists for a given module
 109     ModuleSP exe_module_sp(target.GetExecutableModule());
 110     if (exe_module_sp.get())
 111         return exe_module_sp->GetFileSpec().Exists();
 112     // If there is no executable module, we return true since we might be preparing to attach.
 113     return true;
 114 }
 115
 116 Error
 117 ProcessPOSIX::DoAttachToProcessWithID(lldb::pid_t pid)
 118 {
 119     Error error;
 120     assert(m_monitor == NULL);
 121
 122     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
 123     if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
 124         log->Printf ("ProcessPOSIX::%s(pid = %" PRIi64 ")", __FUNCTION__, GetID());
 125
 126     m_monitor = new ProcessMonitor(this, pid, error);
 127
 128     if (!error.Success())
 129         return error;
 130
 131     PlatformSP platform_sp (m_target.GetPlatform ());
 132     assert (platform_sp.get());
 133     if (!platform_sp)
 134         return error;  // FIXME: Detatch?
 135
 136     // Find out what we can about this process
 137     ProcessInstanceInfo process_info;
 138     platform_sp->GetProcessInfo (pid, process_info);
 139
 140     // Resolve the executable module
 141     ModuleSP exe_module_sp;
 142     FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths());
 143     error = platform_sp->ResolveExecutable(process_info.GetExecutableFile(),
 144                                            m_target.GetArchitecture(),
 145                                            exe_module_sp,
 146                                            executable_search_paths.GetSize() ? &executable_search_paths : NULL);
 147     if (!error.Success())
 148         return error;
 149
 150     // Fix the target architecture if necessary
 151     const ArchSpec &module_arch = exe_module_sp->GetArchitecture();
 152     if (module_arch.IsValid() && !m_target.GetArchitecture().IsExactMatch(module_arch))
 153         m_target.SetArchitecture(module_arch);
 154
 155     // Initialize the target module list
 156     m_target.SetExecutableModule (exe_module_sp, true);
 157
 158     SetSTDIOFileDescriptor(m_monitor->GetTerminalFD());
 159
 160     SetID(pid);
 161
 162     return error;
 163 }
 164
 165 Error
 166 ProcessPOSIX::DoAttachToProcessWithID (lldb::pid_t pid,  const ProcessAttachInfo &attach_info)
 167 {
 168     return DoAttachToProcessWithID(pid);
 169 }
 170
 171 Error
 172 ProcessPOSIX::WillLaunch(Module* module)
 173 {
 174     Error error;
 175     return error;
 176 }
 177
 178 const char *
 179 ProcessPOSIX::GetFilePath(
 180     const lldb_private::ProcessLaunchInfo::FileAction *file_action,
 181     const char *default_path)
 182 {
 183     const char *pts_name = "/dev/pts/";
 184     const char *path = NULL;
 185
 186     if (file_action)
 187     {
 188         if (file_action->GetAction () == ProcessLaunchInfo::FileAction::eFileActionOpen)
 189             path = file_action->GetPath();
 190             // By default the stdio paths passed in will be pseudo-terminal
 191             // (/dev/pts). If so, convert to using a different default path
 192             // instead to redirect I/O to the debugger console. This should
 193             //  also handle user overrides to /dev/null or a different file.
 194             if (::strncmp(path, pts_name, ::strlen(pts_name)) == 0)
 195                 path = default_path;
 196     }
 197
 198     return path;
 199 }
 200
 201 Error
 202 ProcessPOSIX::DoLaunch (Module *module,
 203                        const ProcessLaunchInfo &launch_info)
 204 {
 205     Error error;
 206     assert(m_monitor == NULL);
 207
 208     const char* working_dir = launch_info.GetWorkingDirectory();
 209     if (working_dir) {
 210       FileSpec WorkingDir(working_dir, true);
 211       if (!WorkingDir || WorkingDir.GetFileType() != FileSpec::eFileTypeDirectory)
 212       {
 213           error.SetErrorStringWithFormat("No such file or directory: %s", working_dir);
 214           return error;
 215       }
 216     }
 217
 218     SetPrivateState(eStateLaunching);
 219
 220     const lldb_private::ProcessLaunchInfo::FileAction *file_action;
 221
 222     // Default of NULL will mean to use existing open file descriptors
 223     const char *stdin_path = NULL;
 224     const char *stdout_path = NULL;
 225     const char *stderr_path = NULL;
 226
 227     file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
 228     stdin_path = GetFilePath(file_action, stdin_path);
 229
 230     file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
 231     stdout_path = GetFilePath(file_action, stdout_path);
 232
 233     file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
 234     stderr_path = GetFilePath(file_action, stderr_path);
 235
 236     m_monitor = new ProcessMonitor (this,
 237                                     module,
 238                                     launch_info.GetArguments().GetConstArgumentVector(),
 239                                     launch_info.GetEnvironmentEntries().GetConstArgumentVector(),
 240                                     stdin_path,
 241                                     stdout_path,
 242                                     stderr_path,
 243                                     working_dir,
 244                                     error);
 245
 246     m_module = module;
 247
 248     if (!error.Success())
 249         return error;
 250
 251     SetSTDIOFileDescriptor(m_monitor->GetTerminalFD());
 252
 253     SetID(m_monitor->GetPID());
 254     return error;
 255 }
 256
 257 void
 258 ProcessPOSIX::DidLaunch()
 259 {
 260 }
 261
 262 Error
 263 ProcessPOSIX::DoResume()
 264 {
 265     StateType state = GetPrivateState();
 266
 267     assert(state == eStateStopped);
 268
 269     SetPrivateState(eStateRunning);
 270
 271     bool did_resume = false;
 272
 273     Mutex::Locker lock(m_thread_list.GetMutex());
 274
 275     uint32_t thread_count = m_thread_list.GetSize(false);
 276     for (uint32_t i = 0; i < thread_count; ++i)
 277     {
 278         POSIXThread *thread = static_cast<POSIXThread*>(
 279             m_thread_list.GetThreadAtIndex(i, false).get());
 280         did_resume = thread->Resume() || did_resume;
 281     }
 282     assert(did_resume && "Process resume failed!");
 283
 284     return Error();
 285 }
 286
 287 addr_t
 288 ProcessPOSIX::GetImageInfoAddress()
 289 {
 290     Target *target = &GetTarget();
 291     ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
 292     Address addr = obj_file->GetImageInfoAddress();
 293
 294     if (addr.IsValid())
 295         return addr.GetLoadAddress(target);
 296     else
 297         return LLDB_INVALID_ADDRESS;
 298 }
 299
 300 Error
 301 ProcessPOSIX::DoHalt(bool &caused_stop)
 302 {
 303     Error error;
 304
 305     if (IsStopped())
 306     {
 307         caused_stop = false;
 308     }
 309     else if (kill(GetID(), SIGSTOP))
 310     {
 311         caused_stop = false;
 312         error.SetErrorToErrno();
 313     }
 314     else
 315     {
 316         caused_stop = true;
 317     }
 318     return error;
 319 }
 320
 321 Error
 322 ProcessPOSIX::DoDetach(bool keep_stopped)
 323 {
 324     Error error;
 325     if (keep_stopped)
 326     {
 327         // FIXME: If you want to implement keep_stopped,
 328         // this would be the place to do it.
 329         error.SetErrorString("Detaching with keep_stopped true is not currently supported on this platform.");
 330         return error;
 331     }
 332
 333     Mutex::Locker lock(m_thread_list.GetMutex());
 334
 335     uint32_t thread_count = m_thread_list.GetSize(false);
 336     for (uint32_t i = 0; i < thread_count; ++i)
 337     {
 338         POSIXThread *thread = static_cast<POSIXThread*>(
 339             m_thread_list.GetThreadAtIndex(i, false).get());
 340         error = m_monitor->Detach(thread->GetID());
 341     }
 342
 343     if (error.Success())
 344         SetPrivateState(eStateDetached);
 345
 346     return error;
 347 }
 348
 349 Error
 350 ProcessPOSIX::DoSignal(int signal)
 351 {
 352     Error error;
 353
 354     if (kill(GetID(), signal))
 355         error.SetErrorToErrno();
 356
 357     return error;
 358 }
 359
 360 Error
 361 ProcessPOSIX::DoDestroy()
 362 {
 363     Error error;
 364
 365     if (!HasExited())
 366     {
 367         // Drive the exit event to completion (do not keep the inferior in
 368         // limbo).
 369         m_exit_now = true;
 370
 371         if ((m_monitor == NULL || kill(m_monitor->GetPID(), SIGKILL)) && error.Success())
 372         {
 373             error.SetErrorToErrno();
 374             return error;
 375         }
 376
 377         SetPrivateState(eStateExited);
 378     }
 379
 380     return error;
 381 }
 382
 383 void
 384 ProcessPOSIX::SendMessage(const ProcessMessage &message)
 385 {
 386     Mutex::Locker lock(m_message_mutex);
 387
 388     Mutex::Locker thread_lock(m_thread_list.GetMutex());
 389
 390     POSIXThread *thread = static_cast<POSIXThread*>(
 391         m_thread_list.FindThreadByID(message.GetTID(), false).get());
 392
 393     switch (message.GetKind())
 394     {
 395     case ProcessMessage::eInvalidMessage:
 396         return;
 397
 398     case ProcessMessage::eLimboMessage:
 399         assert(thread);
 400         thread->SetState(eStateStopped);
 401         if (message.GetTID() == GetID())
 402         {
 403             m_exit_status = message.GetExitStatus();
 404             if (m_exit_now)
 405             {
 406                 SetPrivateState(eStateExited);
 407                 m_monitor->Detach(GetID());
 408             }
 409             else
 410             {
 411                 StopAllThreads(message.GetTID());
 412                 SetPrivateState(eStateStopped);
 413             }
 414         }
 415         else
 416         {
 417             StopAllThreads(message.GetTID());
 418             SetPrivateState(eStateStopped);
 419         }
 420         break;
 421
 422     case ProcessMessage::eExitMessage:
 423         assert(thread);
 424         thread->SetState(eStateExited);
 425         // FIXME: I'm not sure we need to do this.
 426         if (message.GetTID() == GetID())
 427         {
 428             m_exit_status = message.GetExitStatus();
 429             SetExitStatus(m_exit_status, NULL);
 430         }
 431         else if (!IsAThreadRunning())
 432             SetPrivateState(eStateStopped);
 433         break;
 434
 435     case ProcessMessage::eSignalMessage:
 436     case ProcessMessage::eSignalDeliveredMessage:
 437         if (message.GetSignal() == SIGSTOP &&
 438             AddThreadForInitialStopIfNeeded(message.GetTID()))
 439             return;
 440         // Intentional fall-through
 441
 442     case ProcessMessage::eBreakpointMessage:
 443     case ProcessMessage::eTraceMessage:
 444     case ProcessMessage::eWatchpointMessage:
 445     case ProcessMessage::eNewThreadMessage:
 446     case ProcessMessage::eCrashMessage:
 447         assert(thread);
 448         thread->SetState(eStateStopped);
 449         StopAllThreads(message.GetTID());
 450         SetPrivateState(eStateStopped);
 451         break;
 452     }
 453
 454     m_message_queue.push(message);
 455 }
 456
 457 void
 458 ProcessPOSIX::StopAllThreads(lldb::tid_t stop_tid)
 459 {
 460     // FIXME: Will this work the same way on FreeBSD and Linux?
 461 }
 462
 463 bool
 464 ProcessPOSIX::AddThreadForInitialStopIfNeeded(lldb::tid_t stop_tid)
 465 {
 466     bool added_to_set = false;
 467     ThreadStopSet::iterator it = m_seen_initial_stop.find(stop_tid);
 468     if (it == m_seen_initial_stop.end())
 469     {
 470         m_seen_initial_stop.insert(stop_tid);
 471         added_to_set = true;
 472     }
 473     return added_to_set;
 474 }
 475
 476 POSIXThread *
 477 ProcessPOSIX::CreateNewPOSIXThread(lldb_private::Process &process, lldb::tid_t tid)
 478 {
 479     return new POSIXThread(process, tid);
 480 }
 481
 482 void
 483 ProcessPOSIX::RefreshStateAfterStop()
 484 {
 485     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
 486     if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
 487         log->Printf ("ProcessPOSIX::%s(), message_queue size = %d", __FUNCTION__, (int)m_message_queue.size());
 488
 489     Mutex::Locker lock(m_message_mutex);
 490
 491     // This method used to only handle one message.  Changing it to loop allows
 492     // it to handle the case where we hit a breakpoint while handling a different
 493     // breakpoint.
 494     while (!m_message_queue.empty())
 495     {
 496         ProcessMessage &message = m_message_queue.front();
 497
 498         // Resolve the thread this message corresponds to and pass it along.
 499         lldb::tid_t tid = message.GetTID();
 500         if (log)
 501             log->Printf ("ProcessPOSIX::%s(), message_queue size = %d, pid = %" PRIi64, __FUNCTION__, (int)m_message_queue.size(), tid);
 502         POSIXThread *thread = static_cast<POSIXThread*>(
 503             GetThreadList().FindThreadByID(tid, false).get());
 504
 505         if (message.GetKind() == ProcessMessage::eNewThreadMessage)
 506         {
 507             if (log)
 508                 log->Printf ("ProcessPOSIX::%s() adding thread, tid = %" PRIi64, __FUNCTION__, message.GetChildTID());
 509             lldb::tid_t child_tid = message.GetChildTID();
 510             ThreadSP thread_sp;
 511             thread_sp.reset(CreateNewPOSIXThread(*this, child_tid));
 512
 513             Mutex::Locker lock(m_thread_list.GetMutex());
 514
 515             m_thread_list.AddThread(thread_sp);
 516         }
 517
 518         m_thread_list.RefreshStateAfterStop();
 519
 520         if (thread)
 521             thread->Notify(message);
 522
 523         if (message.GetKind() == ProcessMessage::eExitMessage)
 524         {
 525             // FIXME: We should tell the user about this, but the limbo message is probably better for that.
 526             if (log)
 527                 log->Printf ("ProcessPOSIX::%s() removing thread, tid = %" PRIi64, __FUNCTION__, tid);
 528
 529             Mutex::Locker lock(m_thread_list.GetMutex());
 530
 531             ThreadSP thread_sp = m_thread_list.RemoveThreadByID(tid, false);
 532             thread_sp.reset();
 533             m_seen_initial_stop.erase(tid);
 534         }
 535
 536         m_message_queue.pop();
 537     }
 538 }
 539
 540 bool
 541 ProcessPOSIX::IsAlive()
 542 {
 543     StateType state = GetPrivateState();
 544     return state != eStateDetached
 545         && state != eStateExited
 546         && state != eStateInvalid
 547         && state != eStateUnloaded;
 548 }
 549
 550 size_t
 551 ProcessPOSIX::DoReadMemory(addr_t vm_addr,
 552                            void *buf, size_t size, Error &error)
 553 {
 554     assert(m_monitor);
 555     return m_monitor->ReadMemory(vm_addr, buf, size, error);
 556 }
 557
 558 size_t
 559 ProcessPOSIX::DoWriteMemory(addr_t vm_addr, const void *buf, size_t size,
 560                             Error &error)
 561 {
 562     assert(m_monitor);
 563     return m_monitor->WriteMemory(vm_addr, buf, size, error);
 564 }
 565
 566 addr_t
 567 ProcessPOSIX::DoAllocateMemory(size_t size, uint32_t permissions,
 568                                Error &error)
 569 {
 570     addr_t allocated_addr = LLDB_INVALID_ADDRESS;
 571
 572     unsigned prot = 0;
 573     if (permissions & lldb::ePermissionsReadable)
 574         prot |= eMmapProtRead;
 575     if (permissions & lldb::ePermissionsWritable)
 576         prot |= eMmapProtWrite;
 577     if (permissions & lldb::ePermissionsExecutable)
 578         prot |= eMmapProtExec;
 579
 580     if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
 581                          eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) {
 582         m_addr_to_mmap_size[allocated_addr] = size;
 583         error.Clear();
 584     } else {
 585         allocated_addr = LLDB_INVALID_ADDRESS;
 586         error.SetErrorStringWithFormat("unable to allocate %zu bytes of memory with permissions %s", size, GetPermissionsAsCString (permissions));
 587     }
 588
 589     return allocated_addr;
 590 }
 591
 592 Error
 593 ProcessPOSIX::DoDeallocateMemory(lldb::addr_t addr)
 594 {
 595     Error error;
 596     MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
 597     if (pos != m_addr_to_mmap_size.end() &&
 598         InferiorCallMunmap(this, addr, pos->second))
 599         m_addr_to_mmap_size.erase (pos);
 600     else
 601         error.SetErrorStringWithFormat("unable to deallocate memory at 0x%" PRIx64, addr);
 602
 603     return error;
 604 }
 605
 606 addr_t
 607 ProcessPOSIX::ResolveIndirectFunction(const Address *address, Error &error)
 608 {
 609     addr_t function_addr = LLDB_INVALID_ADDRESS;
 610     if (address == NULL) {
 611         error.SetErrorStringWithFormat("unable to determine direct function call for NULL address");
 612     } else if (!InferiorCall(this, address, function_addr)) {
 613         function_addr = LLDB_INVALID_ADDRESS;
 614         error.SetErrorStringWithFormat("unable to determine direct function call for indirect function %s",
 615                                        address->CalculateSymbolContextSymbol()->GetName().AsCString());
 616     }
 617     return function_addr;
 618 }
 619
 620 size_t
 621 ProcessPOSIX::GetSoftwareBreakpointTrapOpcode(BreakpointSite* bp_site)
 622 {
 623     static const uint8_t g_i386_opcode[] = { 0xCC };
 624
 625     ArchSpec arch = GetTarget().GetArchitecture();
 626     const uint8_t *opcode = NULL;
 627     size_t opcode_size = 0;
 628
 629     switch (arch.GetCore())
 630     {
 631     default:
 632         assert(false && "CPU type not supported!");
 633         break;
 634
 635     case ArchSpec::eCore_x86_32_i386:
 636     case ArchSpec::eCore_x86_64_x86_64:
 637         opcode = g_i386_opcode;
 638         opcode_size = sizeof(g_i386_opcode);
 639         break;
 640     }
 641
 642     bp_site->SetTrapOpcode(opcode, opcode_size);
 643     return opcode_size;
 644 }
 645
 646 Error
 647 ProcessPOSIX::EnableBreakpointSite(BreakpointSite *bp_site)
 648 {
 649     return EnableSoftwareBreakpoint(bp_site);
 650 }
 651
 652 Error
 653 ProcessPOSIX::DisableBreakpointSite(BreakpointSite *bp_site)
 654 {
 655     return DisableSoftwareBreakpoint(bp_site);
 656 }
 657
 658 Error
 659 ProcessPOSIX::EnableWatchpoint(Watchpoint *wp, bool notify)
 660 {
 661     Error error;
 662     if (wp)
 663     {
 664         user_id_t watchID = wp->GetID();
 665         addr_t addr = wp->GetLoadAddress();
 666         Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
 667         if (log)
 668             log->Printf ("ProcessPOSIX::EnableWatchpoint(watchID = %" PRIu64 ")",
 669                          watchID);
 670         if (wp->IsEnabled())
 671         {
 672             if (log)
 673                 log->Printf("ProcessPOSIX::EnableWatchpoint(watchID = %" PRIu64
 674                             ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
 675                             watchID, (uint64_t)addr);
 676             return error;
 677         }
 678
 679         // Try to find a vacant watchpoint slot in the inferiors' main thread
 680         uint32_t wp_hw_index = LLDB_INVALID_INDEX32;
 681         Mutex::Locker lock(m_thread_list.GetMutex());
 682         POSIXThread *thread = static_cast<POSIXThread*>(
 683                                m_thread_list.GetThreadAtIndex(0, false).get());
 684
 685         if (thread)
 686             wp_hw_index = thread->FindVacantWatchpointIndex();
 687
 688         if (wp_hw_index == LLDB_INVALID_INDEX32)
 689         {
 690             error.SetErrorString("Setting hardware watchpoint failed.");
 691         }
 692         else
 693         {
 694             wp->SetHardwareIndex(wp_hw_index);
 695             bool wp_enabled = true;
 696             uint32_t thread_count = m_thread_list.GetSize(false);
 697             for (uint32_t i = 0; i < thread_count; ++i)
 698             {
 699                 thread = static_cast<POSIXThread*>(
 700                          m_thread_list.GetThreadAtIndex(i, false).get());
 701                 if (thread)
 702                     wp_enabled &= thread->EnableHardwareWatchpoint(wp);
 703                 else
 704                     wp_enabled = false;
 705             }
 706             if (wp_enabled)
 707             {
 708                 wp->SetEnabled(true, notify);
 709                 return error;
 710             }
 711             else
 712             {
 713                 // Watchpoint enabling failed on at least one
 714                 // of the threads so roll back all of them
 715                 DisableWatchpoint(wp, false);
 716                 error.SetErrorString("Setting hardware watchpoint failed");
 717             }
 718         }
 719     }
 720     else
 721         error.SetErrorString("Watchpoint argument was NULL.");
 722     return error;
 723 }
 724
 725 Error
 726 ProcessPOSIX::DisableWatchpoint(Watchpoint *wp, bool notify)
 727 {
 728     Error error;
 729     if (wp)
 730     {
 731         user_id_t watchID = wp->GetID();
 732         addr_t addr = wp->GetLoadAddress();
 733         Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
 734         if (log)
 735             log->Printf("ProcessPOSIX::DisableWatchpoint(watchID = %" PRIu64 ")",
 736                         watchID);
 737         if (!wp->IsEnabled())
 738         {
 739             if (log)
 740                 log->Printf("ProcessPOSIX::DisableWatchpoint(watchID = %" PRIu64
 741                             ") addr = 0x%8.8" PRIx64 ": watchpoint already disabled.",
 742                             watchID, (uint64_t)addr);
 743             // This is needed (for now) to keep watchpoints disabled correctly
 744             wp->SetEnabled(false, notify);
 745             return error;
 746         }
 747
 748         if (wp->IsHardware())
 749         {
 750             bool wp_disabled = true;
 751             Mutex::Locker lock(m_thread_list.GetMutex());
 752             uint32_t thread_count = m_thread_list.GetSize(false);
 753             for (uint32_t i = 0; i < thread_count; ++i)
 754             {
 755                 POSIXThread *thread = static_cast<POSIXThread*>(
 756                                       m_thread_list.GetThreadAtIndex(i, false).get());
 757                 if (thread)
 758                     wp_disabled &= thread->DisableHardwareWatchpoint(wp);
 759                 else
 760                     wp_disabled = false;
 761             }
 762             if (wp_disabled)
 763             {
 764                 wp->SetHardwareIndex(LLDB_INVALID_INDEX32);
 765                 wp->SetEnabled(false, notify);
 766                 return error;
 767             }
 768             else
 769                 error.SetErrorString("Disabling hardware watchpoint failed");
 770         }
 771     }
 772     else
 773         error.SetErrorString("Watchpoint argument was NULL.");
 774     return error;
 775 }
 776
 777 Error
 778 ProcessPOSIX::GetWatchpointSupportInfo(uint32_t &num)
 779 {
 780     Error error;
 781     Mutex::Locker lock(m_thread_list.GetMutex());
 782     POSIXThread *thread = static_cast<POSIXThread*>(
 783                           m_thread_list.GetThreadAtIndex(0, false).get());
 784     if (thread)
 785         num = thread->NumSupportedHardwareWatchpoints();
 786     else
 787         error.SetErrorString("Process does not exist.");
 788     return error;
 789 }
 790
 791 Error
 792 ProcessPOSIX::GetWatchpointSupportInfo(uint32_t &num, bool &after)
 793 {
 794     Error error = GetWatchpointSupportInfo(num);
 795     // Watchpoints trigger and halt the inferior after
 796     // the corresponding instruction has been executed.
 797     after = true;
 798     return error;
 799 }
 800
 801 uint32_t
 802 ProcessPOSIX::UpdateThreadListIfNeeded()
 803 {
 804     Mutex::Locker lock(m_thread_list.GetMutex());
 805     // Do not allow recursive updates.
 806     return m_thread_list.GetSize(false);
 807 }
 808
 809 bool
 810 ProcessPOSIX::UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list)
 811 {
 812     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
 813     if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
 814         log->Printf ("ProcessPOSIX::%s() (pid = %" PRIi64 ")", __FUNCTION__, GetID());
 815
 816     // Update the process thread list with this new thread.
 817     // FIXME: We should be using tid, not pid.
 818     assert(m_monitor);
 819     ThreadSP thread_sp (old_thread_list.FindThreadByID (GetID(), false));
 820     if (!thread_sp) {
 821         thread_sp.reset(CreateNewPOSIXThread(*this, GetID()));
 822     }
 823
 824     if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
 825         log->Printf ("ProcessPOSIX::%s() updated pid = %" PRIi64, __FUNCTION__, GetID());
 826     new_thread_list.AddThread(thread_sp);
 827
 828     return new_thread_list.GetSize(false) > 0;
 829 }
 830
 831 ByteOrder
 832 ProcessPOSIX::GetByteOrder() const
 833 {
 834     // FIXME: We should be able to extract this value directly.  See comment in
 835     // ProcessPOSIX().
 836     return m_byte_order;
 837 }
 838
 839 size_t
 840 ProcessPOSIX::PutSTDIN(const char *buf, size_t len, Error &error)
 841 {
 842     ssize_t status;
 843     if ((status = write(m_monitor->GetTerminalFD(), buf, len)) < 0)
 844     {
 845         error.SetErrorToErrno();
 846         return 0;
 847     }
 848     return status;
 849 }
 850
 851 UnixSignals &
 852 ProcessPOSIX::GetUnixSignals()
 853 {
 854     return m_signals;
 855 }
 856
 857 //------------------------------------------------------------------------------
 858 // Utility functions.
 859
 860 bool
 861 ProcessPOSIX::HasExited()
 862 {
 863     switch (GetPrivateState())
 864     {
 865     default:
 866         break;
 867
 868     case eStateDetached:
 869     case eStateExited:
 870         return true;
 871     }
 872
 873     return false;
 874 }
 875
 876 bool
 877 ProcessPOSIX::IsStopped()
 878 {
 879     switch (GetPrivateState())
 880     {
 881     default:
 882         break;
 883
 884     case eStateStopped:
 885     case eStateCrashed:
 886     case eStateSuspended:
 887         return true;
 888     }
 889
 890     return false;
 891 }
 892
 893 bool
 894 ProcessPOSIX::IsAThreadRunning()
 895 {
 896     bool is_running = false;
 897     Mutex::Locker lock(m_thread_list.GetMutex());
 898     uint32_t thread_count = m_thread_list.GetSize(false);
 899     for (uint32_t i = 0; i < thread_count; ++i)
 900     {
 901         POSIXThread *thread = static_cast<POSIXThread*>(
 902             m_thread_list.GetThreadAtIndex(i, false).get());
 903         StateType thread_state = thread->GetState();
 904         if (thread_state == eStateRunning || thread_state == eStateStepping)
 905         {
 906             is_running = true;
 907             break;
 908         }
 909     }
 910     return is_running;
 911 }