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
34using namespace lldb;
35using namespace lldb_private;
36
37//------------------------------------------------------------------------------
38// Static functions.
39#if 0
40Process*
41ProcessPOSIX::CreateInstance(Target& target, Listener &listener)
42{
43    return new ProcessPOSIX(target, listener);
44}
45
46
47void
48ProcessPOSIX::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
73ProcessPOSIX::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
89ProcessPOSIX::~ProcessPOSIX()
90{
91    delete m_monitor;
92}
93
94//------------------------------------------------------------------------------
95// Process protocol.
96void
97ProcessPOSIX::Finalize()
98{
99  Process::Finalize();
100
101  if (m_monitor)
102    m_monitor->StopMonitor();
103}
104
105bool
106ProcessPOSIX::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
116Error
117ProcessPOSIX::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
165Error
166ProcessPOSIX::DoAttachToProcessWithID (lldb::pid_t pid,  const ProcessAttachInfo &attach_info)
167{
168    return DoAttachToProcessWithID(pid);
169}
170
171Error
172ProcessPOSIX::WillLaunch(Module* module)
173{
174    Error error;
175    return error;
176}
177
178const char *
179ProcessPOSIX::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
201Error
202ProcessPOSIX::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
257void
258ProcessPOSIX::DidLaunch()
259{
260}
261
262Error
263ProcessPOSIX::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
287addr_t
288ProcessPOSIX::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
300Error
301ProcessPOSIX::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
321Error
322ProcessPOSIX::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
349Error
350ProcessPOSIX::DoSignal(int signal)
351{
352    Error error;
353
354    if (kill(GetID(), signal))
355        error.SetErrorToErrno();
356
357    return error;
358}
359
360Error
361ProcessPOSIX::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
383void
384ProcessPOSIX::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
457void
458ProcessPOSIX::StopAllThreads(lldb::tid_t stop_tid)
459{
460    // FIXME: Will this work the same way on FreeBSD and Linux?
461}
462
463bool
464ProcessPOSIX::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
476POSIXThread *
477ProcessPOSIX::CreateNewPOSIXThread(lldb_private::Process &process, lldb::tid_t tid)
478{
479    return new POSIXThread(process, tid);
480}
481
482void
483ProcessPOSIX::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
540bool
541ProcessPOSIX::IsAlive()
542{
543    StateType state = GetPrivateState();
544    return state != eStateDetached
545        && state != eStateExited
546        && state != eStateInvalid
547        && state != eStateUnloaded;
548}
549
550size_t
551ProcessPOSIX::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
558size_t
559ProcessPOSIX::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
566addr_t
567ProcessPOSIX::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
592Error
593ProcessPOSIX::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
606addr_t
607ProcessPOSIX::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
620size_t
621ProcessPOSIX::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
646Error
647ProcessPOSIX::EnableBreakpointSite(BreakpointSite *bp_site)
648{
649    return EnableSoftwareBreakpoint(bp_site);
650}
651
652Error
653ProcessPOSIX::DisableBreakpointSite(BreakpointSite *bp_site)
654{
655    return DisableSoftwareBreakpoint(bp_site);
656}
657
658Error
659ProcessPOSIX::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
725Error
726ProcessPOSIX::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
777Error
778ProcessPOSIX::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
791Error
792ProcessPOSIX::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
801uint32_t
802ProcessPOSIX::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
809bool
810ProcessPOSIX::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
831ByteOrder
832ProcessPOSIX::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
839size_t
840ProcessPOSIX::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
851UnixSignals &
852ProcessPOSIX::GetUnixSignals()
853{
854    return m_signals;
855}
856
857//------------------------------------------------------------------------------
858// Utility functions.
859
860bool
861ProcessPOSIX::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
876bool
877ProcessPOSIX::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
893bool
894ProcessPOSIX::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}
912