ProcessGDBRemote.cpp revision 6e889b142d6acbe1c318bc1b690dd9c3722d7095 
1//===-- ProcessGDBRemote.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#include <spawn.h>
13#include <sys/types.h>
14#include <sys/stat.h>
15
16// C++ Includes
17#include <algorithm>
18#include <map>
19
20// Other libraries and framework includes
21
22#include "lldb/Breakpoint/WatchpointLocation.h"
23#include "lldb/Interpreter/Args.h"
24#include "lldb/Core/ArchSpec.h"
25#include "lldb/Core/Debugger.h"
26#include "lldb/Core/ConnectionFileDescriptor.h"
27#include "lldb/Core/FileSpec.h"
28#include "lldb/Core/InputReader.h"
29#include "lldb/Core/Module.h"
30#include "lldb/Core/PluginManager.h"
31#include "lldb/Core/State.h"
32#include "lldb/Core/StreamString.h"
33#include "lldb/Core/Timer.h"
34#include "lldb/Host/TimeValue.h"
35#include "lldb/Symbol/ObjectFile.h"
36#include "lldb/Target/DynamicLoader.h"
37#include "lldb/Target/Target.h"
38#include "lldb/Target/TargetList.h"
39#include "lldb/Utility/PseudoTerminal.h"
40
41// Project includes
42#include "lldb/Host/Host.h"
43#include "Utility/StringExtractorGDBRemote.h"
44#include "GDBRemoteRegisterContext.h"
45#include "ProcessGDBRemote.h"
46#include "ProcessGDBRemoteLog.h"
47#include "ThreadGDBRemote.h"
48#include "StopInfoMachException.h"
49
50
51
52#define DEBUGSERVER_BASENAME    "debugserver"
53using namespace lldb;
54using namespace lldb_private;
55
56static inline uint16_t
57get_random_port ()
58{
59    return (arc4random() % (UINT16_MAX - 1000u)) + 1000u;
60}
61
62
63const char *
64ProcessGDBRemote::GetPluginNameStatic()
65{
66    return "process.gdb-remote";
67}
68
69const char *
70ProcessGDBRemote::GetPluginDescriptionStatic()
71{
72    return "GDB Remote protocol based debugging plug-in.";
73}
74
75void
76ProcessGDBRemote::Terminate()
77{
78    PluginManager::UnregisterPlugin (ProcessGDBRemote::CreateInstance);
79}
80
81
82Process*
83ProcessGDBRemote::CreateInstance (Target &target, Listener &listener)
84{
85    return new ProcessGDBRemote (target, listener);
86}
87
88bool
89ProcessGDBRemote::CanDebug(Target &target)
90{
91    // For now we are just making sure the file exists for a given module
92    ModuleSP exe_module_sp(target.GetExecutableModule());
93    if (exe_module_sp.get())
94        return exe_module_sp->GetFileSpec().Exists();
95    // However, if there is no executable module, we return true since we might be preparing to attach.
96    return true;
97}
98
99//----------------------------------------------------------------------
100// ProcessGDBRemote constructor
101//----------------------------------------------------------------------
102ProcessGDBRemote::ProcessGDBRemote(Target& target, Listener &listener) :
103    Process (target, listener),
104    m_dynamic_loader_ap (),
105    m_flags (0),
106    m_stdio_mutex (Mutex::eMutexTypeRecursive),
107    m_gdb_comm(),
108    m_debugserver_pid (LLDB_INVALID_PROCESS_ID),
109    m_debugserver_thread (LLDB_INVALID_HOST_THREAD),
110    m_last_stop_packet (),
111    m_register_info (),
112    m_async_broadcaster ("lldb.process.gdb-remote.async-broadcaster"),
113    m_async_thread (LLDB_INVALID_HOST_THREAD),
114    m_curr_tid (LLDB_INVALID_THREAD_ID),
115    m_curr_tid_run (LLDB_INVALID_THREAD_ID),
116    m_z0_supported (1),
117    m_continue_packet(),
118    m_dispatch_queue_offsets_addr (LLDB_INVALID_ADDRESS),
119    m_packet_timeout (1),
120    m_max_memory_size (512),
121    m_waiting_for_attach (false),
122    m_local_debugserver (true)
123{
124}
125
126//----------------------------------------------------------------------
127// Destructor
128//----------------------------------------------------------------------
129ProcessGDBRemote::~ProcessGDBRemote()
130{
131    m_dynamic_loader_ap.reset();
132
133    if (m_debugserver_thread != LLDB_INVALID_HOST_THREAD)
134    {
135        Host::ThreadCancel (m_debugserver_thread, NULL);
136        thread_result_t thread_result;
137        Host::ThreadJoin (m_debugserver_thread, &thread_result, NULL);
138        m_debugserver_thread = LLDB_INVALID_HOST_THREAD;
139    }
140    //  m_mach_process.UnregisterNotificationCallbacks (this);
141    Clear();
142}
143
144//----------------------------------------------------------------------
145// PluginInterface
146//----------------------------------------------------------------------
147const char *
148ProcessGDBRemote::GetPluginName()
149{
150    return "Process debugging plug-in that uses the GDB remote protocol";
151}
152
153const char *
154ProcessGDBRemote::GetShortPluginName()
155{
156    return GetPluginNameStatic();
157}
158
159uint32_t
160ProcessGDBRemote::GetPluginVersion()
161{
162    return 1;
163}
164
165void
166ProcessGDBRemote::GetPluginCommandHelp (const char *command, Stream *strm)
167{
168    strm->Printf("TODO: fill this in\n");
169}
170
171Error
172ProcessGDBRemote::ExecutePluginCommand (Args &command, Stream *strm)
173{
174    Error error;
175    error.SetErrorString("No plug-in commands are currently supported.");
176    return error;
177}
178
179Log *
180ProcessGDBRemote::EnablePluginLogging (Stream *strm, Args &command)
181{
182    return NULL;
183}
184
185void
186ProcessGDBRemote::BuildDynamicRegisterInfo ()
187{
188    char register_info_command[64];
189    m_register_info.Clear();
190    StringExtractorGDBRemote::Type packet_type = StringExtractorGDBRemote::eResponse;
191    uint32_t reg_offset = 0;
192    uint32_t reg_num = 0;
193    for (; packet_type == StringExtractorGDBRemote::eResponse; ++reg_num)
194    {
195        ::snprintf (register_info_command, sizeof(register_info_command), "qRegisterInfo%x", reg_num);
196        StringExtractorGDBRemote response;
197        if (m_gdb_comm.SendPacketAndWaitForResponse(register_info_command, response, 2, false))
198        {
199            packet_type = response.GetType();
200            if (packet_type == StringExtractorGDBRemote::eResponse)
201            {
202                std::string name;
203                std::string value;
204                ConstString reg_name;
205                ConstString alt_name;
206                ConstString set_name;
207                RegisterInfo reg_info = { NULL,                 // Name
208                    NULL,                 // Alt name
209                    0,                    // byte size
210                    reg_offset,           // offset
211                    eEncodingUint,        // encoding
212                    eFormatHex,           // formate
213                    {
214                        LLDB_INVALID_REGNUM, // GCC reg num
215                        LLDB_INVALID_REGNUM, // DWARF reg num
216                        LLDB_INVALID_REGNUM, // generic reg num
217                        reg_num,             // GDB reg num
218                        reg_num           // native register number
219                    }
220                };
221
222                while (response.GetNameColonValue(name, value))
223                {
224                    if (name.compare("name") == 0)
225                    {
226                        reg_name.SetCString(value.c_str());
227                    }
228                    else if (name.compare("alt-name") == 0)
229                    {
230                        alt_name.SetCString(value.c_str());
231                    }
232                    else if (name.compare("bitsize") == 0)
233                    {
234                        reg_info.byte_size = Args::StringToUInt32(value.c_str(), 0, 0) / CHAR_BIT;
235                    }
236                    else if (name.compare("offset") == 0)
237                    {
238                        uint32_t offset = Args::StringToUInt32(value.c_str(), UINT32_MAX, 0);
239                        if (reg_offset != offset)
240                        {
241                            reg_offset = offset;
242                        }
243                    }
244                    else if (name.compare("encoding") == 0)
245                    {
246                        if (value.compare("uint") == 0)
247                            reg_info.encoding = eEncodingUint;
248                        else if (value.compare("sint") == 0)
249                            reg_info.encoding = eEncodingSint;
250                        else if (value.compare("ieee754") == 0)
251                            reg_info.encoding = eEncodingIEEE754;
252                        else if (value.compare("vector") == 0)
253                            reg_info.encoding = eEncodingVector;
254                    }
255                    else if (name.compare("format") == 0)
256                    {
257                        if (value.compare("binary") == 0)
258                            reg_info.format = eFormatBinary;
259                        else if (value.compare("decimal") == 0)
260                            reg_info.format = eFormatDecimal;
261                        else if (value.compare("hex") == 0)
262                            reg_info.format = eFormatHex;
263                        else if (value.compare("float") == 0)
264                            reg_info.format = eFormatFloat;
265                        else if (value.compare("vector-sint8") == 0)
266                            reg_info.format = eFormatVectorOfSInt8;
267                        else if (value.compare("vector-uint8") == 0)
268                            reg_info.format = eFormatVectorOfUInt8;
269                        else if (value.compare("vector-sint16") == 0)
270                            reg_info.format = eFormatVectorOfSInt16;
271                        else if (value.compare("vector-uint16") == 0)
272                            reg_info.format = eFormatVectorOfUInt16;
273                        else if (value.compare("vector-sint32") == 0)
274                            reg_info.format = eFormatVectorOfSInt32;
275                        else if (value.compare("vector-uint32") == 0)
276                            reg_info.format = eFormatVectorOfUInt32;
277                        else if (value.compare("vector-float32") == 0)
278                            reg_info.format = eFormatVectorOfFloat32;
279                        else if (value.compare("vector-uint128") == 0)
280                            reg_info.format = eFormatVectorOfUInt128;
281                    }
282                    else if (name.compare("set") == 0)
283                    {
284                        set_name.SetCString(value.c_str());
285                    }
286                    else if (name.compare("gcc") == 0)
287                    {
288                        reg_info.kinds[eRegisterKindGCC] = Args::StringToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0);
289                    }
290                    else if (name.compare("dwarf") == 0)
291                    {
292                        reg_info.kinds[eRegisterKindDWARF] = Args::StringToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0);
293                    }
294                    else if (name.compare("generic") == 0)
295                    {
296                        if (value.compare("pc") == 0)
297                            reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
298                        else if (value.compare("sp") == 0)
299                            reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
300                        else if (value.compare("fp") == 0)
301                            reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
302                        else if (value.compare("ra") == 0)
303                            reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
304                        else if (value.compare("flags") == 0)
305                            reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
306                    }
307                }
308
309                reg_info.byte_offset = reg_offset;
310                assert (reg_info.byte_size != 0);
311                reg_offset += reg_info.byte_size;
312                m_register_info.AddRegister(reg_info, reg_name, alt_name, set_name);
313            }
314        }
315        else
316        {
317            packet_type = StringExtractorGDBRemote::eError;
318        }
319    }
320
321    if (reg_num == 0)
322    {
323        // We didn't get anything. See if we are debugging ARM and fill with
324        // a hard coded register set until we can get an updated debugserver
325        // down on the devices.
326        ArchSpec arm_arch ("arm");
327        if (GetTarget().GetArchitecture() == arm_arch)
328            m_register_info.HardcodeARMRegisters();
329    }
330    m_register_info.Finalize ();
331}
332
333Error
334ProcessGDBRemote::WillLaunch (Module* module)
335{
336    return WillLaunchOrAttach ();
337}
338
339Error
340ProcessGDBRemote::WillAttachToProcessWithID (lldb::pid_t pid)
341{
342    return WillLaunchOrAttach ();
343}
344
345Error
346ProcessGDBRemote::WillAttachToProcessWithName (const char *process_name, bool wait_for_launch)
347{
348    return WillLaunchOrAttach ();
349}
350
351Error
352ProcessGDBRemote::WillLaunchOrAttach ()
353{
354    Error error;
355    // TODO: this is hardcoded for macosx right now. We need this to be more dynamic
356    m_dynamic_loader_ap.reset(DynamicLoader::FindPlugin(this, "dynamic-loader.macosx-dyld"));
357
358    if (m_dynamic_loader_ap.get() == NULL)
359        error.SetErrorString("unable to find the dynamic loader named 'dynamic-loader.macosx-dyld'");
360    m_stdio_communication.Clear ();
361
362    return error;
363}
364
365//----------------------------------------------------------------------
366// Process Control
367//----------------------------------------------------------------------
368Error
369ProcessGDBRemote::DoLaunch
370(
371    Module* module,
372    char const *argv[],
373    char const *envp[],
374    uint32_t launch_flags,
375    const char *stdin_path,
376    const char *stdout_path,
377    const char *stderr_path
378)
379{
380    Error error;
381    //  ::LogSetBitMask (GDBR_LOG_DEFAULT);
382    //  ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE | LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
383    //  ::LogSetLogFile ("/dev/stdout");
384
385    ObjectFile * object_file = module->GetObjectFile();
386    if (object_file)
387    {
388        ArchSpec inferior_arch(module->GetArchitecture());
389        char host_port[128];
390        snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ());
391
392        const bool launch_process = true;
393        bool start_debugserver_with_inferior_args = false;
394        if (start_debugserver_with_inferior_args)
395        {
396            // We want to launch debugserver with the inferior program and its
397            // arguments on the command line. We should only do this if we
398            // the GDB server we are talking to doesn't support the 'A' packet.
399            error = StartDebugserverProcess (host_port,
400                                             argv,
401                                             envp,
402                                             NULL, //stdin_path,
403                                             launch_process,
404                                             LLDB_INVALID_PROCESS_ID,
405                                             NULL, false,
406                                             launch_flags,
407                                             inferior_arch);
408            if (error.Fail())
409                return error;
410
411            error = ConnectToDebugserver (host_port);
412            if (error.Success())
413            {
414                SetID (m_gdb_comm.GetCurrentProcessID (m_packet_timeout));
415            }
416        }
417        else
418        {
419            error = StartDebugserverProcess (host_port,
420                                             NULL,
421                                             NULL,
422                                             NULL, //stdin_path
423                                             launch_process,
424                                             LLDB_INVALID_PROCESS_ID,
425                                             NULL, false,
426                                             launch_flags,
427                                             inferior_arch);
428            if (error.Fail())
429                return error;
430
431            error = ConnectToDebugserver (host_port);
432            if (error.Success())
433            {
434                // Send the environment and the program + arguments after we connect
435                if (envp)
436                {
437                    const char *env_entry;
438                    for (int i=0; (env_entry = envp[i]); ++i)
439                    {
440                        if (m_gdb_comm.SendEnvironmentPacket(env_entry, m_packet_timeout) != 0)
441                            break;
442                    }
443                }
444
445				// FIXME: convert this to use the new set/show variables when they are available
446#if 0
447                if (::getenv ("LLDB_DEBUG_DEBUGSERVER"))
448                {
449                    const uint32_t attach_debugserver_secs = 10;
450                    ::printf ("attach to debugserver (pid = %i)\n", m_debugserver_pid);
451                    for (uint32_t i=0; i<attach_debugserver_secs; ++i)
452                    {
453                        printf ("%i\n", attach_debugserver_secs - i);
454                        sleep (1);
455                    }
456                }
457#endif
458
459                const uint32_t arg_timeout_seconds = 10;
460                int arg_packet_err = m_gdb_comm.SendArgumentsPacket (argv, arg_timeout_seconds);
461                if (arg_packet_err == 0)
462                {
463                    std::string error_str;
464                    if (m_gdb_comm.GetLaunchSuccess (m_packet_timeout, error_str))
465                    {
466                        SetID (m_gdb_comm.GetCurrentProcessID (m_packet_timeout));
467                    }
468                    else
469                    {
470                        error.SetErrorString (error_str.c_str());
471                    }
472                }
473                else
474                {
475                    error.SetErrorStringWithFormat("'A' packet returned an error: %i.\n", arg_packet_err);
476                }
477
478                SetID (m_gdb_comm.GetCurrentProcessID (m_packet_timeout));
479            }
480        }
481
482        if (GetID() == LLDB_INVALID_PROCESS_ID)
483        {
484            KillDebugserverProcess ();
485            return error;
486        }
487
488        StringExtractorGDBRemote response;
489        if (m_gdb_comm.SendPacketAndWaitForResponse("?", 1, response, m_packet_timeout, false))
490            SetPrivateState (SetThreadStopInfo (response));
491
492    }
493    else
494    {
495        // Set our user ID to an invalid process ID.
496        SetID(LLDB_INVALID_PROCESS_ID);
497        error.SetErrorStringWithFormat("Failed to get object file from '%s' for arch %s.\n", module->GetFileSpec().GetFilename().AsCString(), module->GetArchitecture().AsCString());
498    }
499    return error;
500
501}
502
503
504Error
505ProcessGDBRemote::ConnectToDebugserver (const char *host_port)
506{
507    Error error;
508    // Sleep and wait a bit for debugserver to start to listen...
509    std::auto_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor());
510    if (conn_ap.get())
511    {
512        std::string connect_url("connect://");
513        connect_url.append (host_port);
514        const uint32_t max_retry_count = 50;
515        uint32_t retry_count = 0;
516        while (!m_gdb_comm.IsConnected())
517        {
518            if (conn_ap->Connect(connect_url.c_str(), &error) == eConnectionStatusSuccess)
519            {
520                m_gdb_comm.SetConnection (conn_ap.release());
521                break;
522            }
523            retry_count++;
524
525            if (retry_count >= max_retry_count)
526                break;
527
528            usleep (100000);
529        }
530    }
531
532    if (!m_gdb_comm.IsConnected())
533    {
534        if (error.Success())
535            error.SetErrorString("not connected to remote gdb server");
536        return error;
537    }
538
539    m_gdb_comm.SetAckMode (true);
540    if (m_gdb_comm.StartReadThread(&error))
541    {
542        // Send an initial ack
543        m_gdb_comm.SendAck('+');
544
545        if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID)
546            m_debugserver_thread = Host::StartMonitoringChildProcess (MonitorDebugserverProcess,
547                                                                      this,
548                                                                      m_debugserver_pid,
549                                                                      false);
550
551        StringExtractorGDBRemote response;
552        if (m_gdb_comm.SendPacketAndWaitForResponse("QStartNoAckMode", response, 1, false))
553        {
554            if (response.IsOKPacket())
555                m_gdb_comm.SetAckMode (false);
556        }
557    }
558    return error;
559}
560
561void
562ProcessGDBRemote::DidLaunchOrAttach ()
563{
564    ProcessGDBRemoteLog::LogIf (GDBR_LOG_PROCESS, "ProcessGDBRemote::DidLaunch()");
565    if (GetID() == LLDB_INVALID_PROCESS_ID)
566    {
567        m_dynamic_loader_ap.reset();
568    }
569    else
570    {
571        m_dispatch_queue_offsets_addr = LLDB_INVALID_ADDRESS;
572
573        BuildDynamicRegisterInfo ();
574
575        m_byte_order = m_gdb_comm.GetByteOrder();
576
577        Module * exe_module = GetTarget().GetExecutableModule().get();
578        assert(exe_module);
579
580        ObjectFile *exe_objfile = exe_module->GetObjectFile();
581        assert(exe_objfile);
582
583        StreamString strm;
584
585        ArchSpec inferior_arch;
586        // See if the GDB server supports the qHostInfo information
587        const char *vendor = m_gdb_comm.GetVendorString().AsCString();
588        const char *os_type = m_gdb_comm.GetOSString().AsCString();
589        ArchSpec arch_spec (GetTarget().GetArchitecture());
590
591        if (arch_spec.IsValid() && arch_spec == ArchSpec ("arm"))
592        {
593            // For ARM we can't trust the arch of the process as it could
594            // have an armv6 object file, but be running on armv7 kernel.
595            inferior_arch = m_gdb_comm.GetHostArchitecture();
596        }
597
598        if (!inferior_arch.IsValid())
599            inferior_arch = arch_spec;
600
601        if (vendor == NULL)
602            vendor = Host::GetVendorString().AsCString("apple");
603
604        if (os_type == NULL)
605            os_type = Host::GetOSString().AsCString("darwin");
606
607        strm.Printf ("%s-%s-%s", inferior_arch.AsCString(), vendor, os_type);
608
609        std::transform (strm.GetString().begin(),
610                        strm.GetString().end(),
611                        strm.GetString().begin(),
612                        ::tolower);
613
614        m_target_triple.SetCString(strm.GetString().c_str());
615    }
616}
617
618void
619ProcessGDBRemote::DidLaunch ()
620{
621    DidLaunchOrAttach ();
622    if (m_dynamic_loader_ap.get())
623        m_dynamic_loader_ap->DidLaunch();
624}
625
626Error
627ProcessGDBRemote::DoAttachToProcessWithID (lldb::pid_t attach_pid)
628{
629    Error error;
630    // Clear out and clean up from any current state
631    Clear();
632    ArchSpec arch_spec = GetTarget().GetArchitecture();
633
634    //LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
635
636
637    if (attach_pid != LLDB_INVALID_PROCESS_ID)
638    {
639        char host_port[128];
640        snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ());
641        error = StartDebugserverProcess (host_port,                 // debugserver_url
642                                         NULL,                      // inferior_argv
643                                         NULL,                      // inferior_envp
644                                         NULL,                      // stdin_path
645                                         false,                     // launch_process == false (we are attaching)
646                                         LLDB_INVALID_PROCESS_ID,   // Don't send any attach to pid options to debugserver
647                                         NULL,                      // Don't send any attach by process name option to debugserver
648                                         false,                     // Don't send any attach wait_for_launch flag as an option to debugserver
649                                         0,                         // launch_flags
650                                         arch_spec);
651
652        if (error.Fail())
653        {
654            const char *error_string = error.AsCString();
655            if (error_string == NULL)
656                error_string = "unable to launch " DEBUGSERVER_BASENAME;
657
658            SetExitStatus (-1, error_string);
659        }
660        else
661        {
662            error = ConnectToDebugserver (host_port);
663            if (error.Success())
664            {
665                char packet[64];
666                const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%x", attach_pid);
667                StringExtractorGDBRemote response;
668                StateType stop_state = m_gdb_comm.SendContinuePacketAndWaitForResponse (this,
669                                                                                        packet,
670                                                                                        packet_len,
671                                                                                        response);
672                switch (stop_state)
673                {
674                case eStateStopped:
675                case eStateCrashed:
676                case eStateSuspended:
677                    SetID (attach_pid);
678                    m_last_stop_packet = response;
679                    m_last_stop_packet.SetFilePos (0);
680                    SetPrivateState (stop_state);
681                    break;
682
683                case eStateExited:
684                    m_last_stop_packet = response;
685                    m_last_stop_packet.SetFilePos (0);
686                    response.SetFilePos(1);
687                    SetExitStatus(response.GetHexU8(), NULL);
688                    break;
689
690                default:
691                    SetExitStatus(-1, "unable to attach to process");
692                    break;
693                }
694
695            }
696        }
697    }
698
699    lldb::pid_t pid = GetID();
700    if (pid == LLDB_INVALID_PROCESS_ID)
701    {
702        KillDebugserverProcess();
703    }
704    return error;
705}
706
707size_t
708ProcessGDBRemote::AttachInputReaderCallback
709(
710    void *baton,
711    InputReader *reader,
712    lldb::InputReaderAction notification,
713    const char *bytes,
714    size_t bytes_len
715)
716{
717    if (notification == eInputReaderGotToken)
718    {
719        ProcessGDBRemote *gdb_process = (ProcessGDBRemote *)baton;
720        if (gdb_process->m_waiting_for_attach)
721            gdb_process->m_waiting_for_attach = false;
722        reader->SetIsDone(true);
723        return 1;
724    }
725    return 0;
726}
727
728Error
729ProcessGDBRemote::DoAttachToProcessWithName (const char *process_name, bool wait_for_launch)
730{
731    Error error;
732    // Clear out and clean up from any current state
733    Clear();
734    // HACK: require arch be set correctly at the target level until we can
735    // figure out a good way to determine the arch of what we are attaching to
736
737    //LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
738    if (process_name && process_name[0])
739    {
740        char host_port[128];
741        ArchSpec arch_spec = GetTarget().GetArchitecture();
742        snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ());
743        error = StartDebugserverProcess (host_port,                 // debugserver_url
744                                         NULL,                      // inferior_argv
745                                         NULL,                      // inferior_envp
746                                         NULL,                      // stdin_path
747                                         false,                     // launch_process == false (we are attaching)
748                                         LLDB_INVALID_PROCESS_ID,   // Don't send any attach to pid options to debugserver
749                                         NULL,                      // Don't send any attach by process name option to debugserver
750                                         false,                     // Don't send any attach wait_for_launch flag as an option to debugserver
751                                         0,                         // launch_flags
752                                         arch_spec);
753        if (error.Fail())
754        {
755            const char *error_string = error.AsCString();
756            if (error_string == NULL)
757                error_string = "unable to launch " DEBUGSERVER_BASENAME;
758
759            SetExitStatus (-1, error_string);
760        }
761        else
762        {
763            error = ConnectToDebugserver (host_port);
764            if (error.Success())
765            {
766                StreamString packet;
767
768                if (wait_for_launch)
769                    packet.PutCString("vAttachWait");
770                else
771                    packet.PutCString("vAttachName");
772                packet.PutChar(';');
773                packet.PutBytesAsRawHex8(process_name, strlen(process_name), eByteOrderHost, eByteOrderHost);
774                StringExtractorGDBRemote response;
775                StateType stop_state = m_gdb_comm.SendContinuePacketAndWaitForResponse (this,
776                                                                                        packet.GetData(),
777                                                                                        packet.GetSize(),
778                                                                                        response);
779                switch (stop_state)
780                {
781                case eStateStopped:
782                case eStateCrashed:
783                case eStateSuspended:
784                    SetID (m_gdb_comm.GetCurrentProcessID(m_packet_timeout));
785                    m_last_stop_packet = response;
786                    m_last_stop_packet.SetFilePos (0);
787                    SetPrivateState (stop_state);
788                    break;
789
790                case eStateExited:
791                    m_last_stop_packet = response;
792                    m_last_stop_packet.SetFilePos (0);
793                    response.SetFilePos(1);
794                    SetExitStatus(response.GetHexU8(), NULL);
795                    break;
796
797                default:
798                    SetExitStatus(-1, "unable to attach to process");
799                    break;
800                }
801            }
802        }
803    }
804
805    lldb::pid_t pid = GetID();
806    if (pid == LLDB_INVALID_PROCESS_ID)
807    {
808        KillDebugserverProcess();
809
810        if (error.Success())
811            error.SetErrorStringWithFormat("unable to attach to process named '%s'", process_name);
812    }
813
814    return error;
815}
816
817//
818//        if (wait_for_launch)
819//        {
820//            InputReaderSP reader_sp (new InputReader());
821//            StreamString instructions;
822//            instructions.Printf("Hit any key to cancel waiting for '%s' to launch...", process_name);
823//            error = reader_sp->Initialize (AttachInputReaderCallback, // callback
824//                                                this, // baton
825//                                                eInputReaderGranularityByte,
826//                                                NULL, // End token
827//                                                false);
828//
829//            StringExtractorGDBRemote response;
830//            m_waiting_for_attach = true;
831//            FILE *reader_out_fh = reader_sp->GetOutputFileHandle();
832//            while (m_waiting_for_attach)
833//            {
834//                // Wait for one second for the stop reply packet
835//                if (m_gdb_comm.WaitForPacket(response, 1))
836//                {
837//                    // Got some sort of packet, see if it is the stop reply packet?
838//                    char ch = response.GetChar(0);
839//                    if (ch == 'T')
840//                    {
841//                        m_waiting_for_attach = false;
842//                    }
843//                }
844//                else
845//                {
846//                    // Put a period character every second
847//                    fputc('.', reader_out_fh);
848//                }
849//            }
850//        }
851//    }
852//    return GetID();
853//}
854
855void
856ProcessGDBRemote::DidAttach ()
857{
858    if (m_dynamic_loader_ap.get())
859        m_dynamic_loader_ap->DidAttach();
860    DidLaunchOrAttach ();
861}
862
863Error
864ProcessGDBRemote::WillResume ()
865{
866    m_continue_packet.Clear();
867    // Start the continue packet we will use to run the target. Each thread
868    // will append what it is supposed to be doing to this packet when the
869    // ThreadList::WillResume() is called. If a thread it supposed
870    // to stay stopped, then don't append anything to this string.
871    m_continue_packet.Printf("vCont");
872    return Error();
873}
874
875Error
876ProcessGDBRemote::DoResume ()
877{
878    Error error;
879    ProcessGDBRemoteLog::LogIf (GDBR_LOG_PROCESS, "ProcessGDBRemote::Resume()");
880
881    Listener listener ("gdb-remote.resume-packet-sent");
882    if (listener.StartListeningForEvents (&m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent))
883    {
884        EventSP event_sp;
885        TimeValue timeout;
886        timeout = TimeValue::Now();
887        timeout.OffsetWithSeconds (5);
888        m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (m_continue_packet.GetData(), m_continue_packet.GetSize()));
889
890        if (listener.WaitForEvent (&timeout, event_sp) == false)
891            error.SetErrorString("Resume timed out.");
892    }
893
894    return error;
895}
896
897size_t
898ProcessGDBRemote::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
899{
900    const uint8_t *trap_opcode = NULL;
901    uint32_t trap_opcode_size = 0;
902
903    static const uint8_t g_arm_breakpoint_opcode[] = { 0xFE, 0xDE, 0xFF, 0xE7 };
904    //static const uint8_t g_thumb_breakpooint_opcode[] = { 0xFE, 0xDE };
905    static const uint8_t g_ppc_breakpoint_opcode[] = { 0x7F, 0xC0, 0x00, 0x08 };
906    static const uint8_t g_i386_breakpoint_opcode[] = { 0xCC };
907
908    ArchSpec::CPU arch_cpu = GetTarget().GetArchitecture().GetGenericCPUType();
909    switch (arch_cpu)
910    {
911    case ArchSpec::eCPU_i386:
912    case ArchSpec::eCPU_x86_64:
913        trap_opcode = g_i386_breakpoint_opcode;
914        trap_opcode_size = sizeof(g_i386_breakpoint_opcode);
915        break;
916
917    case ArchSpec::eCPU_arm:
918        // TODO: fill this in for ARM. We need to dig up the symbol for
919        // the address in the breakpoint locaiton and figure out if it is
920        // an ARM or Thumb breakpoint.
921        trap_opcode = g_arm_breakpoint_opcode;
922        trap_opcode_size = sizeof(g_arm_breakpoint_opcode);
923        break;
924
925    case ArchSpec::eCPU_ppc:
926    case ArchSpec::eCPU_ppc64:
927        trap_opcode = g_ppc_breakpoint_opcode;
928        trap_opcode_size = sizeof(g_ppc_breakpoint_opcode);
929        break;
930
931    default:
932        assert(!"Unhandled architecture in ProcessMacOSX::GetSoftwareBreakpointTrapOpcode()");
933        break;
934    }
935
936    if (trap_opcode && trap_opcode_size)
937    {
938        if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
939            return trap_opcode_size;
940    }
941    return 0;
942}
943
944uint32_t
945ProcessGDBRemote::UpdateThreadListIfNeeded ()
946{
947    // locker will keep a mutex locked until it goes out of scope
948    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_THREAD));
949    if (log && log->GetMask().Test(GDBR_LOG_VERBOSE))
950        log->Printf ("ProcessGDBRemote::%s (pid = %i)", __FUNCTION__, GetID());
951
952    Mutex::Locker locker (m_thread_list.GetMutex ());
953    const uint32_t stop_id = GetStopID();
954    if (m_thread_list.GetSize(false) == 0 || stop_id != m_thread_list.GetStopID())
955    {
956        // Update the thread list's stop id immediately so we don't recurse into this function.
957        ThreadList curr_thread_list (this);
958        curr_thread_list.SetStopID(stop_id);
959
960        Error err;
961        StringExtractorGDBRemote response;
962        for (m_gdb_comm.SendPacketAndWaitForResponse("qfThreadInfo", response, 1, false);
963             response.IsNormalPacket();
964             m_gdb_comm.SendPacketAndWaitForResponse("qsThreadInfo", response, 1, false))
965        {
966            char ch = response.GetChar();
967            if (ch == 'l')
968                break;
969            if (ch == 'm')
970            {
971                do
972                {
973                    tid_t tid = response.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID);
974
975                    if (tid != LLDB_INVALID_THREAD_ID)
976                    {
977                        ThreadSP thread_sp (GetThreadList().FindThreadByID (tid, false));
978                        if (thread_sp)
979                            thread_sp->GetRegisterContext()->Invalidate();
980                        else
981                            thread_sp.reset (new ThreadGDBRemote (*this, tid));
982                        curr_thread_list.AddThread(thread_sp);
983                    }
984
985                    ch = response.GetChar();
986                } while (ch == ',');
987            }
988        }
989
990        m_thread_list = curr_thread_list;
991
992        SetThreadStopInfo (m_last_stop_packet);
993    }
994    return GetThreadList().GetSize(false);
995}
996
997
998StateType
999ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
1000{
1001    const char stop_type = stop_packet.GetChar();
1002    switch (stop_type)
1003    {
1004    case 'T':
1005    case 'S':
1006        {
1007            // Stop with signal and thread info
1008            const uint8_t signo = stop_packet.GetHexU8();
1009            std::string name;
1010            std::string value;
1011            std::string thread_name;
1012            uint32_t exc_type = 0;
1013            std::vector<addr_t> exc_data;
1014            uint32_t tid = LLDB_INVALID_THREAD_ID;
1015            addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
1016            uint32_t exc_data_count = 0;
1017            while (stop_packet.GetNameColonValue(name, value))
1018            {
1019                if (name.compare("metype") == 0)
1020                {
1021                    // exception type in big endian hex
1022                    exc_type = Args::StringToUInt32 (value.c_str(), 0, 16);
1023                }
1024                else if (name.compare("mecount") == 0)
1025                {
1026                    // exception count in big endian hex
1027                    exc_data_count = Args::StringToUInt32 (value.c_str(), 0, 16);
1028                }
1029                else if (name.compare("medata") == 0)
1030                {
1031                    // exception data in big endian hex
1032                    exc_data.push_back(Args::StringToUInt64 (value.c_str(), 0, 16));
1033                }
1034                else if (name.compare("thread") == 0)
1035                {
1036                    // thread in big endian hex
1037                    tid = Args::StringToUInt32 (value.c_str(), 0, 16);
1038                }
1039                else if (name.compare("name") == 0)
1040                {
1041                    thread_name.swap (value);
1042                }
1043                else if (name.compare("qaddr") == 0)
1044                {
1045                    thread_dispatch_qaddr = Args::StringToUInt64 (value.c_str(), 0, 16);
1046                }
1047            }
1048            ThreadSP thread_sp (m_thread_list.FindThreadByID(tid, false));
1049
1050            if (thread_sp)
1051            {
1052                ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get());
1053
1054                gdb_thread->SetThreadDispatchQAddr (thread_dispatch_qaddr);
1055                gdb_thread->SetName (thread_name.empty() ? thread_name.c_str() : NULL);
1056                if (exc_type != 0)
1057                {
1058                    const size_t exc_data_count = exc_data.size();
1059
1060                    gdb_thread->SetStopInfo (StopInfoMachException::CreateStopReasonWithMachException (*thread_sp,
1061                                                                                                       exc_type,
1062                                                                                                       exc_data_count,
1063                                                                                                       exc_data_count >= 1 ? exc_data[0] : 0,
1064                                                                                                       exc_data_count >= 2 ? exc_data[1] : 0));
1065                }
1066                else if (signo)
1067                {
1068                    gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo));
1069                }
1070                else
1071                {
1072                    StopInfoSP invalid_stop_info_sp;
1073                    gdb_thread->SetStopInfo (invalid_stop_info_sp);
1074                }
1075            }
1076            return eStateStopped;
1077        }
1078        break;
1079
1080    case 'W':
1081        // process exited
1082        return eStateExited;
1083
1084    default:
1085        break;
1086    }
1087    return eStateInvalid;
1088}
1089
1090void
1091ProcessGDBRemote::RefreshStateAfterStop ()
1092{
1093    // FIXME - add a variable to tell that we're in the middle of attaching if we
1094    // need to know that.
1095    // We must be attaching if we don't already have a valid architecture
1096//    if (!GetTarget().GetArchitecture().IsValid())
1097//    {
1098//        Module *exe_module = GetTarget().GetExecutableModule().get();
1099//        if (exe_module)
1100//            m_arch_spec = exe_module->GetArchitecture();
1101//    }
1102
1103    // Let all threads recover from stopping and do any clean up based
1104    // on the previous thread state (if any).
1105    m_thread_list.RefreshStateAfterStop();
1106
1107    // Discover new threads:
1108    UpdateThreadListIfNeeded ();
1109}
1110
1111Error
1112ProcessGDBRemote::DoHalt (bool &caused_stop)
1113{
1114    Error error;
1115
1116    if (m_gdb_comm.IsRunning())
1117    {
1118        caused_stop = true;
1119        bool timed_out = false;
1120        Mutex::Locker locker;
1121
1122        if (!m_gdb_comm.SendInterrupt (locker, 2, &timed_out))
1123        {
1124            if (timed_out)
1125                error.SetErrorString("timed out sending interrupt packet");
1126            else
1127                error.SetErrorString("unknown error sending interrupt packet");
1128        }
1129    }
1130    else
1131    {
1132        caused_stop = false;
1133    }
1134
1135    return error;
1136}
1137
1138Error
1139ProcessGDBRemote::WillDetach ()
1140{
1141    Error error;
1142
1143    if (m_gdb_comm.IsRunning())
1144    {
1145        bool timed_out = false;
1146        Mutex::Locker locker;
1147        PausePrivateStateThread();
1148        m_thread_list.DiscardThreadPlans();
1149        m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
1150        if (!m_gdb_comm.SendInterrupt (locker, 2, &timed_out))
1151        {
1152            if (timed_out)
1153                error.SetErrorString("timed out sending interrupt packet");
1154            else
1155                error.SetErrorString("unknown error sending interrupt packet");
1156            ResumePrivateStateThread();
1157        }
1158        TimeValue timeout_time;
1159        timeout_time = TimeValue::Now();
1160        timeout_time.OffsetWithSeconds(2);
1161
1162        EventSP event_sp;
1163        StateType state = WaitForStateChangedEventsPrivate (&timeout_time, event_sp);
1164        if (state != eStateStopped)
1165            error.SetErrorString("unable to stop target");
1166    }
1167    return error;
1168}
1169
1170Error
1171ProcessGDBRemote::DoDetach()
1172{
1173    Error error;
1174    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
1175    if (log)
1176        log->Printf ("ProcessGDBRemote::DoDetach()");
1177
1178    DisableAllBreakpointSites ();
1179
1180    m_thread_list.DiscardThreadPlans();
1181
1182    size_t response_size = m_gdb_comm.SendPacket ("D", 1);
1183    if (log)
1184    {
1185        if (response_size)
1186            log->PutCString ("ProcessGDBRemote::DoDetach() detach packet sent successfully");
1187        else
1188            log->PutCString ("ProcessGDBRemote::DoDetach() detach packet send failed");
1189    }
1190    // Sleep for one second to let the process get all detached...
1191    StopAsyncThread ();
1192
1193    m_gdb_comm.StopReadThread();
1194    m_gdb_comm.Disconnect();    // Disconnect from the debug server.
1195
1196    SetPrivateState (eStateDetached);
1197    ResumePrivateStateThread();
1198
1199    //KillDebugserverProcess ();
1200    return error;
1201}
1202
1203Error
1204ProcessGDBRemote::DoDestroy ()
1205{
1206    Error error;
1207    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
1208    if (log)
1209        log->Printf ("ProcessGDBRemote::DoDestroy()");
1210
1211    // Interrupt if our inferior is running...
1212    Mutex::Locker locker;
1213    m_gdb_comm.SendInterrupt (locker, 1);
1214    DisableAllBreakpointSites ();
1215    SetExitStatus(-1, "process killed");
1216
1217    StringExtractorGDBRemote response;
1218    if (m_gdb_comm.SendPacketAndWaitForResponse("k", response, 1, false))
1219    {
1220        log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS);
1221        if (log)
1222        {
1223            if (response.IsOKPacket())
1224                log->Printf ("ProcessGDBRemote::DoDestroy() kill was successful");
1225            else
1226                log->Printf ("ProcessGDBRemote::DoDestroy() kill failed: %s", response.GetStringRef().c_str());
1227        }
1228    }
1229
1230    StopAsyncThread ();
1231    m_gdb_comm.StopReadThread();
1232    KillDebugserverProcess ();
1233    m_gdb_comm.Disconnect();    // Disconnect from the debug server.
1234    return error;
1235}
1236
1237//------------------------------------------------------------------
1238// Process Queries
1239//------------------------------------------------------------------
1240
1241bool
1242ProcessGDBRemote::IsAlive ()
1243{
1244    return m_gdb_comm.IsConnected() && m_private_state.GetValue() != eStateExited;
1245}
1246
1247addr_t
1248ProcessGDBRemote::GetImageInfoAddress()
1249{
1250    if (!m_gdb_comm.IsRunning())
1251    {
1252        StringExtractorGDBRemote response;
1253        if (m_gdb_comm.SendPacketAndWaitForResponse("qShlibInfoAddr", ::strlen ("qShlibInfoAddr"), response, 2, false))
1254        {
1255            if (response.IsNormalPacket())
1256                return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
1257        }
1258    }
1259    return LLDB_INVALID_ADDRESS;
1260}
1261
1262DynamicLoader *
1263ProcessGDBRemote::GetDynamicLoader()
1264{
1265    return m_dynamic_loader_ap.get();
1266}
1267
1268//------------------------------------------------------------------
1269// Process Memory
1270//------------------------------------------------------------------
1271size_t
1272ProcessGDBRemote::DoReadMemory (addr_t addr, void *buf, size_t size, Error &error)
1273{
1274    if (size > m_max_memory_size)
1275    {
1276        // Keep memory read sizes down to a sane limit. This function will be
1277        // called multiple times in order to complete the task by
1278        // lldb_private::Process so it is ok to do this.
1279        size = m_max_memory_size;
1280    }
1281
1282    char packet[64];
1283    const int packet_len = ::snprintf (packet, sizeof(packet), "m%llx,%zx", (uint64_t)addr, size);
1284    assert (packet_len + 1 < sizeof(packet));
1285    StringExtractorGDBRemote response;
1286    if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, true))
1287    {
1288        if (response.IsNormalPacket())
1289        {
1290            error.Clear();
1291            return response.GetHexBytes(buf, size, '\xdd');
1292        }
1293        else if (response.IsErrorPacket())
1294            error.SetErrorStringWithFormat("gdb remote returned an error: %s", response.GetStringRef().c_str());
1295        else if (response.IsUnsupportedPacket())
1296            error.SetErrorStringWithFormat("'%s' packet unsupported", packet);
1297        else
1298            error.SetErrorStringWithFormat("unexpected response to '%s': '%s'", packet, response.GetStringRef().c_str());
1299    }
1300    else
1301    {
1302        error.SetErrorStringWithFormat("failed to sent packet: '%s'", packet);
1303    }
1304    return 0;
1305}
1306
1307size_t
1308ProcessGDBRemote::DoWriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
1309{
1310    StreamString packet;
1311    packet.Printf("M%llx,%zx:", addr, size);
1312    packet.PutBytesAsRawHex8(buf, size, eByteOrderHost, eByteOrderHost);
1313    StringExtractorGDBRemote response;
1314    if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, 2, true))
1315    {
1316        if (response.IsOKPacket())
1317        {
1318            error.Clear();
1319            return size;
1320        }
1321        else if (response.IsErrorPacket())
1322            error.SetErrorStringWithFormat("gdb remote returned an error: %s", response.GetStringRef().c_str());
1323        else if (response.IsUnsupportedPacket())
1324            error.SetErrorStringWithFormat("'%s' packet unsupported", packet.GetString().c_str());
1325        else
1326            error.SetErrorStringWithFormat("unexpected response to '%s': '%s'", packet.GetString().c_str(), response.GetStringRef().c_str());
1327    }
1328    else
1329    {
1330        error.SetErrorStringWithFormat("failed to sent packet: '%s'", packet.GetString().c_str());
1331    }
1332    return 0;
1333}
1334
1335lldb::addr_t
1336ProcessGDBRemote::DoAllocateMemory (size_t size, uint32_t permissions, Error &error)
1337{
1338    addr_t allocated_addr = m_gdb_comm.AllocateMemory (size, permissions, m_packet_timeout);
1339    if (allocated_addr == LLDB_INVALID_ADDRESS)
1340        error.SetErrorStringWithFormat("unable to allocate %zu bytes of memory with permissions %u", size, permissions);
1341    else
1342        error.Clear();
1343    return allocated_addr;
1344}
1345
1346Error
1347ProcessGDBRemote::DoDeallocateMemory (lldb::addr_t addr)
1348{
1349    Error error;
1350    if (!m_gdb_comm.DeallocateMemory (addr, m_packet_timeout))
1351        error.SetErrorStringWithFormat("unable to deallocate memory at 0x%llx", addr);
1352    return error;
1353}
1354
1355
1356//------------------------------------------------------------------
1357// Process STDIO
1358//------------------------------------------------------------------
1359
1360size_t
1361ProcessGDBRemote::GetSTDOUT (char *buf, size_t buf_size, Error &error)
1362{
1363    Mutex::Locker locker(m_stdio_mutex);
1364    size_t bytes_available = m_stdout_data.size();
1365    if (bytes_available > 0)
1366    {
1367        ProcessGDBRemoteLog::LogIf (GDBR_LOG_PROCESS, "ProcessGDBRemote::%s (&%p[%u]) ...", __FUNCTION__, buf, buf_size);
1368        if (bytes_available > buf_size)
1369        {
1370            memcpy(buf, m_stdout_data.c_str(), buf_size);
1371            m_stdout_data.erase(0, buf_size);
1372            bytes_available = buf_size;
1373        }
1374        else
1375        {
1376            memcpy(buf, m_stdout_data.c_str(), bytes_available);
1377            m_stdout_data.clear();
1378
1379            //ResetEventBits(eBroadcastBitSTDOUT);
1380        }
1381    }
1382    return bytes_available;
1383}
1384
1385size_t
1386ProcessGDBRemote::GetSTDERR (char *buf, size_t buf_size, Error &error)
1387{
1388    // Can we get STDERR through the remote protocol?
1389    return 0;
1390}
1391
1392size_t
1393ProcessGDBRemote::PutSTDIN (const char *src, size_t src_len, Error &error)
1394{
1395    if (m_stdio_communication.IsConnected())
1396    {
1397        ConnectionStatus status;
1398        m_stdio_communication.Write(src, src_len, status, NULL);
1399    }
1400    return 0;
1401}
1402
1403Error
1404ProcessGDBRemote::EnableBreakpoint (BreakpointSite *bp_site)
1405{
1406    Error error;
1407    assert (bp_site != NULL);
1408
1409    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS));
1410    user_id_t site_id = bp_site->GetID();
1411    const addr_t addr = bp_site->GetLoadAddress();
1412    if (log)
1413        log->Printf ("ProcessGDBRemote::EnableBreakpoint (size_id = %d) address = 0x%llx", site_id, (uint64_t)addr);
1414
1415    if (bp_site->IsEnabled())
1416    {
1417        if (log)
1418            log->Printf ("ProcessGDBRemote::EnableBreakpoint (size_id = %d) address = 0x%llx -- SUCCESS (already enabled)", site_id, (uint64_t)addr);
1419        return error;
1420    }
1421    else
1422    {
1423        const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode (bp_site);
1424
1425        if (bp_site->HardwarePreferred())
1426        {
1427            // Try and set hardware breakpoint, and if that fails, fall through
1428            // and set a software breakpoint?
1429        }
1430
1431        if (m_z0_supported)
1432        {
1433            char packet[64];
1434            const int packet_len = ::snprintf (packet, sizeof(packet), "Z0,%llx,%zx", addr, bp_op_size);
1435            assert (packet_len + 1 < sizeof(packet));
1436            StringExtractorGDBRemote response;
1437            if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, true))
1438            {
1439                if (response.IsUnsupportedPacket())
1440                {
1441                    // Disable z packet support and try again
1442                    m_z0_supported = 0;
1443                    return EnableBreakpoint (bp_site);
1444                }
1445                else if (response.IsOKPacket())
1446                {
1447                    bp_site->SetEnabled(true);
1448                    bp_site->SetType (BreakpointSite::eExternal);
1449                    return error;
1450                }
1451                else
1452                {
1453                    uint8_t error_byte = response.GetError();
1454                    if (error_byte)
1455                        error.SetErrorStringWithFormat("%x packet failed with error: %i (0x%2.2x).\n", packet, error_byte, error_byte);
1456                }
1457            }
1458        }
1459        else
1460        {
1461            return EnableSoftwareBreakpoint (bp_site);
1462        }
1463    }
1464
1465    if (log)
1466    {
1467        const char *err_string = error.AsCString();
1468        log->Printf ("ProcessGDBRemote::EnableBreakpoint() error for breakpoint at 0x%8.8llx: %s",
1469                     bp_site->GetLoadAddress(),
1470                     err_string ? err_string : "NULL");
1471    }
1472    // We shouldn't reach here on a successful breakpoint enable...
1473    if (error.Success())
1474        error.SetErrorToGenericError();
1475    return error;
1476}
1477
1478Error
1479ProcessGDBRemote::DisableBreakpoint (BreakpointSite *bp_site)
1480{
1481    Error error;
1482    assert (bp_site != NULL);
1483    addr_t addr = bp_site->GetLoadAddress();
1484    user_id_t site_id = bp_site->GetID();
1485    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS));
1486    if (log)
1487        log->Printf ("ProcessGDBRemote::DisableBreakpoint (site_id = %d) addr = 0x%8.8llx", site_id, (uint64_t)addr);
1488
1489    if (bp_site->IsEnabled())
1490    {
1491        const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode (bp_site);
1492
1493        if (bp_site->IsHardware())
1494        {
1495            // TODO: disable hardware breakpoint...
1496        }
1497        else
1498        {
1499            if (m_z0_supported)
1500            {
1501                char packet[64];
1502                const int packet_len = ::snprintf (packet, sizeof(packet), "z0,%llx,%zx", addr, bp_op_size);
1503                assert (packet_len + 1 < sizeof(packet));
1504                StringExtractorGDBRemote response;
1505                if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, true))
1506                {
1507                    if (response.IsUnsupportedPacket())
1508                    {
1509                        error.SetErrorString("Breakpoint site was set with Z packet, yet remote debugserver states z packets are not supported.");
1510                    }
1511                    else if (response.IsOKPacket())
1512                    {
1513                        if (log)
1514                            log->Printf ("ProcessGDBRemote::DisableBreakpoint (site_id = %d) addr = 0x%8.8llx -- SUCCESS", site_id, (uint64_t)addr);
1515                        bp_site->SetEnabled(false);
1516                        return error;
1517                    }
1518                    else
1519                    {
1520                        uint8_t error_byte = response.GetError();
1521                        if (error_byte)
1522                            error.SetErrorStringWithFormat("%x packet failed with error: %i (0x%2.2x).\n", packet, error_byte, error_byte);
1523                    }
1524                }
1525            }
1526            else
1527            {
1528                return DisableSoftwareBreakpoint (bp_site);
1529            }
1530        }
1531    }
1532    else
1533    {
1534        if (log)
1535            log->Printf ("ProcessGDBRemote::DisableBreakpoint (site_id = %d) addr = 0x%8.8llx -- SUCCESS (already disabled)", site_id, (uint64_t)addr);
1536        return error;
1537    }
1538
1539    if (error.Success())
1540        error.SetErrorToGenericError();
1541    return error;
1542}
1543
1544Error
1545ProcessGDBRemote::EnableWatchpoint (WatchpointLocation *wp)
1546{
1547    Error error;
1548    if (wp)
1549    {
1550        user_id_t watchID = wp->GetID();
1551        addr_t addr = wp->GetLoadAddress();
1552        LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS));
1553        if (log)
1554            log->Printf ("ProcessGDBRemote::EnableWatchpoint(watchID = %d)", watchID);
1555        if (wp->IsEnabled())
1556        {
1557            if (log)
1558                log->Printf("ProcessGDBRemote::EnableWatchpoint(watchID = %d) addr = 0x%8.8llx: watchpoint already enabled.", watchID, (uint64_t)addr);
1559            return error;
1560        }
1561        else
1562        {
1563            // Pass down an appropriate z/Z packet...
1564            error.SetErrorString("watchpoints not supported");
1565        }
1566    }
1567    else
1568    {
1569        error.SetErrorString("Watchpoint location argument was NULL.");
1570    }
1571    if (error.Success())
1572        error.SetErrorToGenericError();
1573    return error;
1574}
1575
1576Error
1577ProcessGDBRemote::DisableWatchpoint (WatchpointLocation *wp)
1578{
1579    Error error;
1580    if (wp)
1581    {
1582        user_id_t watchID = wp->GetID();
1583
1584        LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS));
1585
1586        addr_t addr = wp->GetLoadAddress();
1587        if (log)
1588            log->Printf ("ProcessGDBRemote::DisableWatchpoint (watchID = %d) addr = 0x%8.8llx", watchID, (uint64_t)addr);
1589
1590        if (wp->IsHardware())
1591        {
1592            // Pass down an appropriate z/Z packet...
1593            error.SetErrorString("watchpoints not supported");
1594        }
1595        // TODO: clear software watchpoints if we implement them
1596    }
1597    else
1598    {
1599        error.SetErrorString("Watchpoint location argument was NULL.");
1600    }
1601    if (error.Success())
1602        error.SetErrorToGenericError();
1603    return error;
1604}
1605
1606void
1607ProcessGDBRemote::Clear()
1608{
1609    m_flags = 0;
1610    m_thread_list.Clear();
1611    {
1612        Mutex::Locker locker(m_stdio_mutex);
1613        m_stdout_data.clear();
1614    }
1615}
1616
1617Error
1618ProcessGDBRemote::DoSignal (int signo)
1619{
1620    Error error;
1621    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
1622    if (log)
1623        log->Printf ("ProcessGDBRemote::DoSignal (signal = %d)", signo);
1624
1625    if (!m_gdb_comm.SendAsyncSignal (signo))
1626        error.SetErrorStringWithFormat("failed to send signal %i", signo);
1627    return error;
1628}
1629
1630//void
1631//ProcessGDBRemote::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
1632//{
1633//    ProcessGDBRemote *process = (ProcessGDBRemote *)baton;
1634//    process->AppendSTDOUT(static_cast<const char *>(src), src_len);
1635//}
1636
1637//void
1638//ProcessGDBRemote::AppendSTDOUT (const char* s, size_t len)
1639//{
1640//    ProcessGDBRemoteLog::LogIf (GDBR_LOG_PROCESS, "ProcessGDBRemote::%s (<%d> %s) ...", __FUNCTION__, len, s);
1641//    Mutex::Locker locker(m_stdio_mutex);
1642//    m_stdout_data.append(s, len);
1643//
1644//    // FIXME: Make a real data object for this and put it out.
1645//    BroadcastEventIfUnique (eBroadcastBitSTDOUT);
1646//}
1647
1648
1649Error
1650ProcessGDBRemote::StartDebugserverProcess
1651(
1652    const char *debugserver_url,    // The connection string to use in the spawned debugserver ("localhost:1234" or "/dev/tty...")
1653    char const *inferior_argv[],    // Arguments for the inferior program including the path to the inferior itself as the first argument
1654    char const *inferior_envp[],    // Environment to pass along to the inferior program
1655    char const *stdio_path,
1656    bool launch_process,            // Set to true if we are going to be launching a the process
1657    lldb::pid_t attach_pid,         // If inferior inferior_argv == NULL, and attach_pid != LLDB_INVALID_PROCESS_ID send this pid as an argument to debugserver
1658    const char *attach_name,        // Wait for the next process to launch whose basename matches "attach_name"
1659    bool wait_for_launch,           // Wait for the process named "attach_name" to launch
1660    uint32_t launch_flags,          // Launch flags
1661    ArchSpec& inferior_arch         // The arch of the inferior that we will launch
1662)
1663{
1664    Error error;
1665    bool disable_aslr = (launch_flags & eLaunchFlagDisableASLR) != 0;
1666    bool no_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
1667    if (m_debugserver_pid == LLDB_INVALID_PROCESS_ID)
1668    {
1669        // If we locate debugserver, keep that located version around
1670        static FileSpec g_debugserver_file_spec;
1671
1672        FileSpec debugserver_file_spec;
1673        char debugserver_path[PATH_MAX];
1674
1675        // Always check to see if we have an environment override for the path
1676        // to the debugserver to use and use it if we do.
1677        const char *env_debugserver_path = getenv("LLDB_DEBUGSERVER_PATH");
1678        if (env_debugserver_path)
1679            debugserver_file_spec.SetFile (env_debugserver_path, false);
1680        else
1681            debugserver_file_spec = g_debugserver_file_spec;
1682        bool debugserver_exists = debugserver_file_spec.Exists();
1683        if (!debugserver_exists)
1684        {
1685            // The debugserver binary is in the LLDB.framework/Resources
1686            // directory.
1687            if (Host::GetLLDBPath (ePathTypeSupportExecutableDir, debugserver_file_spec))
1688            {
1689                debugserver_file_spec.GetFilename().SetCString(DEBUGSERVER_BASENAME);
1690                debugserver_exists = debugserver_file_spec.Exists();
1691                if (debugserver_exists)
1692                {
1693                    g_debugserver_file_spec = debugserver_file_spec;
1694                }
1695                else
1696                {
1697                    g_debugserver_file_spec.Clear();
1698                    debugserver_file_spec.Clear();
1699                }
1700            }
1701        }
1702
1703        if (debugserver_exists)
1704        {
1705            debugserver_file_spec.GetPath (debugserver_path, sizeof(debugserver_path));
1706
1707            m_stdio_communication.Clear();
1708            posix_spawnattr_t attr;
1709
1710            LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
1711
1712            Error local_err;    // Errors that don't affect the spawning.
1713            if (log)
1714                log->Printf ("%s ( path='%s', argv=%p, envp=%p, arch=%s )", __FUNCTION__, debugserver_path, inferior_argv, inferior_envp, inferior_arch.AsCString());
1715            error.SetError( ::posix_spawnattr_init (&attr), eErrorTypePOSIX);
1716            if (error.Fail() || log)
1717                error.PutToLog(log.get(), "::posix_spawnattr_init ( &attr )");
1718            if (error.Fail())
1719                return error;;
1720
1721#if !defined (__arm__)
1722
1723            // We don't need to do this for ARM, and we really shouldn't now
1724            // that we have multiple CPU subtypes and no posix_spawnattr call
1725            // that allows us to set which CPU subtype to launch...
1726            if (inferior_arch.GetType() == eArchTypeMachO)
1727            {
1728                cpu_type_t cpu = inferior_arch.GetCPUType();
1729                if (cpu != 0 && cpu != UINT32_MAX && cpu != LLDB_INVALID_CPUTYPE)
1730                {
1731                    size_t ocount = 0;
1732                    error.SetError( ::posix_spawnattr_setbinpref_np (&attr, 1, &cpu, &ocount), eErrorTypePOSIX);
1733                    if (error.Fail() || log)
1734                        error.PutToLog(log.get(), "::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = 0x%8.8x, count => %zu )", cpu, ocount);
1735
1736                    if (error.Fail() != 0 || ocount != 1)
1737                        return error;
1738                }
1739            }
1740
1741#endif
1742
1743            Args debugserver_args;
1744            char arg_cstr[PATH_MAX];
1745
1746            lldb_utility::PseudoTerminal pty;
1747            if (launch_process && stdio_path == NULL && m_local_debugserver && !no_stdio)
1748            {
1749                if (pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY, NULL, 0))
1750                    stdio_path = pty.GetSlaveName (NULL, 0);
1751            }
1752
1753            // Start args with "debugserver /file/path -r --"
1754            debugserver_args.AppendArgument(debugserver_path);
1755            debugserver_args.AppendArgument(debugserver_url);
1756            // use native registers, not the GDB registers
1757            debugserver_args.AppendArgument("--native-regs");
1758            // make debugserver run in its own session so signals generated by
1759            // special terminal key sequences (^C) don't affect debugserver
1760            debugserver_args.AppendArgument("--setsid");
1761
1762            if (disable_aslr)
1763                debugserver_args.AppendArguments("--disable-aslr");
1764
1765            // Only set the inferior
1766            if (launch_process && stdio_path)
1767            {
1768                debugserver_args.AppendArgument("--stdio-path");
1769                debugserver_args.AppendArgument(stdio_path);
1770            }
1771            else if (launch_process && no_stdio)
1772            {
1773                debugserver_args.AppendArgument("--no-stdio");
1774            }
1775
1776            const char *env_debugserver_log_file = getenv("LLDB_DEBUGSERVER_LOG_FILE");
1777            if (env_debugserver_log_file)
1778            {
1779                ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-file=%s", env_debugserver_log_file);
1780                debugserver_args.AppendArgument(arg_cstr);
1781            }
1782
1783            const char *env_debugserver_log_flags = getenv("LLDB_DEBUGSERVER_LOG_FLAGS");
1784            if (env_debugserver_log_flags)
1785            {
1786                ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-flags=%s", env_debugserver_log_flags);
1787                debugserver_args.AppendArgument(arg_cstr);
1788            }
1789//            debugserver_args.AppendArgument("--log-file=/tmp/debugserver.txt");
1790//            debugserver_args.AppendArgument("--log-flags=0x800e0e");
1791
1792            // Now append the program arguments
1793            if (launch_process)
1794            {
1795                if (inferior_argv)
1796                {
1797                    // Terminate the debugserver args so we can now append the inferior args
1798                    debugserver_args.AppendArgument("--");
1799
1800                    for (int i = 0; inferior_argv[i] != NULL; ++i)
1801                        debugserver_args.AppendArgument (inferior_argv[i]);
1802                }
1803                else
1804                {
1805                    // Will send environment entries with the 'QEnvironment:' packet
1806                    // Will send arguments with the 'A' packet
1807                }
1808            }
1809            else if (attach_pid != LLDB_INVALID_PROCESS_ID)
1810            {
1811                ::snprintf (arg_cstr, sizeof(arg_cstr), "--attach=%u", attach_pid);
1812                debugserver_args.AppendArgument (arg_cstr);
1813            }
1814            else if (attach_name && attach_name[0])
1815            {
1816                if (wait_for_launch)
1817                    debugserver_args.AppendArgument ("--waitfor");
1818                else
1819                    debugserver_args.AppendArgument ("--attach");
1820                debugserver_args.AppendArgument (attach_name);
1821            }
1822
1823            Error file_actions_err;
1824            posix_spawn_file_actions_t file_actions;
1825#if DONT_CLOSE_DEBUGSERVER_STDIO
1826            file_actions_err.SetErrorString ("Remove this after uncommenting the code block below.");
1827#else
1828            file_actions_err.SetError( ::posix_spawn_file_actions_init (&file_actions), eErrorTypePOSIX);
1829            if (file_actions_err.Success())
1830            {
1831                ::posix_spawn_file_actions_addclose (&file_actions, STDIN_FILENO);
1832                ::posix_spawn_file_actions_addclose (&file_actions, STDOUT_FILENO);
1833                ::posix_spawn_file_actions_addclose (&file_actions, STDERR_FILENO);
1834            }
1835#endif
1836
1837            if (log)
1838            {
1839                StreamString strm;
1840                debugserver_args.Dump (&strm);
1841                log->Printf("%s arguments:\n%s", debugserver_args.GetArgumentAtIndex(0), strm.GetData());
1842            }
1843
1844            error.SetError(::posix_spawnp (&m_debugserver_pid,
1845                                             debugserver_path,
1846                                             file_actions_err.Success() ? &file_actions : NULL,
1847                                             &attr,
1848                                             debugserver_args.GetArgumentVector(),
1849                                             (char * const*)inferior_envp),
1850                             eErrorTypePOSIX);
1851
1852
1853            ::posix_spawnattr_destroy (&attr);
1854
1855            if (file_actions_err.Success())
1856                ::posix_spawn_file_actions_destroy (&file_actions);
1857
1858            // We have seen some cases where posix_spawnp was returning a valid
1859            // looking pid even when an error was returned, so clear it out
1860            if (error.Fail())
1861                m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
1862
1863            if (error.Fail() || log)
1864                error.PutToLog(log.get(), "::posix_spawnp ( pid => %i, path = '%s', file_actions = %p, attr = %p, argv = %p, envp = %p )", m_debugserver_pid, debugserver_path, NULL, &attr, inferior_argv, inferior_envp);
1865
1866            if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID && !no_stdio)
1867            {
1868                if (pty.GetMasterFileDescriptor() != lldb_utility::PseudoTerminal::invalid_fd)
1869                    SetUpProcessInputReader (pty.ReleaseMasterFileDescriptor());
1870            }
1871        }
1872        else
1873        {
1874            error.SetErrorStringWithFormat ("Unable to locate " DEBUGSERVER_BASENAME ".\n");
1875        }
1876
1877        if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID)
1878            StartAsyncThread ();
1879    }
1880    return error;
1881}
1882
1883bool
1884ProcessGDBRemote::MonitorDebugserverProcess
1885(
1886    void *callback_baton,
1887    lldb::pid_t debugserver_pid,
1888    int signo,          // Zero for no signal
1889    int exit_status     // Exit value of process if signal is zero
1890)
1891{
1892    // We pass in the ProcessGDBRemote inferior process it and name it
1893    // "gdb_remote_pid". The process ID is passed in the "callback_baton"
1894    // pointer value itself, thus we need the double cast...
1895
1896    // "debugserver_pid" argument passed in is the process ID for
1897    // debugserver that we are tracking...
1898
1899    ProcessGDBRemote *process = (ProcessGDBRemote *)callback_baton;
1900
1901    if (process)
1902    {
1903        // Sleep for a half a second to make sure our inferior process has
1904        // time to set its exit status before we set it incorrectly when
1905        // both the debugserver and the inferior process shut down.
1906        usleep (500000);
1907        // If our process hasn't yet exited, debugserver might have died.
1908        // If the process did exit, the we are reaping it.
1909        const StateType state = process->GetState();
1910
1911        if (process->m_debugserver_pid != LLDB_INVALID_PROCESS_ID &&
1912            state != eStateInvalid &&
1913            state != eStateUnloaded &&
1914            state != eStateExited &&
1915            state != eStateDetached)
1916        {
1917            char error_str[1024];
1918            if (signo)
1919            {
1920                const char *signal_cstr = process->GetUnixSignals().GetSignalAsCString (signo);
1921                if (signal_cstr)
1922                    ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %s", signal_cstr);
1923                else
1924                    ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %i", signo);
1925            }
1926            else
1927            {
1928                ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with an exit status of 0x%8.8x", exit_status);
1929            }
1930
1931            process->SetExitStatus (-1, error_str);
1932        }
1933        // Debugserver has exited we need to let our ProcessGDBRemote
1934        // know that it no longer has a debugserver instance
1935        process->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
1936        // We are returning true to this function below, so we can
1937        // forget about the monitor handle.
1938        process->m_debugserver_thread = LLDB_INVALID_HOST_THREAD;
1939    }
1940    return true;
1941}
1942
1943void
1944ProcessGDBRemote::KillDebugserverProcess ()
1945{
1946    if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID)
1947    {
1948        ::kill (m_debugserver_pid, SIGINT);
1949        m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
1950    }
1951}
1952
1953void
1954ProcessGDBRemote::Initialize()
1955{
1956    static bool g_initialized = false;
1957
1958    if (g_initialized == false)
1959    {
1960        g_initialized = true;
1961        PluginManager::RegisterPlugin (GetPluginNameStatic(),
1962                                       GetPluginDescriptionStatic(),
1963                                       CreateInstance);
1964
1965        Log::Callbacks log_callbacks = {
1966            ProcessGDBRemoteLog::DisableLog,
1967            ProcessGDBRemoteLog::EnableLog,
1968            ProcessGDBRemoteLog::ListLogCategories
1969        };
1970
1971        Log::RegisterLogChannel (ProcessGDBRemote::GetPluginNameStatic(), log_callbacks);
1972    }
1973}
1974
1975bool
1976ProcessGDBRemote::SetCurrentGDBRemoteThread (int tid)
1977{
1978    if (m_curr_tid == tid)
1979        return true;
1980
1981    char packet[32];
1982    const int packet_len = ::snprintf (packet, sizeof(packet), "Hg%x", tid);
1983    assert (packet_len + 1 < sizeof(packet));
1984    StringExtractorGDBRemote response;
1985    if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, false))
1986    {
1987        if (response.IsOKPacket())
1988        {
1989            m_curr_tid = tid;
1990            return true;
1991        }
1992    }
1993    return false;
1994}
1995
1996bool
1997ProcessGDBRemote::SetCurrentGDBRemoteThreadForRun (int tid)
1998{
1999    if (m_curr_tid_run == tid)
2000        return true;
2001
2002    char packet[32];
2003    const int packet_len = ::snprintf (packet, sizeof(packet), "Hg%x", tid);
2004    assert (packet_len + 1 < sizeof(packet));
2005    StringExtractorGDBRemote response;
2006    if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, false))
2007    {
2008        if (response.IsOKPacket())
2009        {
2010            m_curr_tid_run = tid;
2011            return true;
2012        }
2013    }
2014    return false;
2015}
2016
2017void
2018ProcessGDBRemote::ResetGDBRemoteState ()
2019{
2020    // Reset and GDB remote state
2021    m_curr_tid = LLDB_INVALID_THREAD_ID;
2022    m_curr_tid_run = LLDB_INVALID_THREAD_ID;
2023    m_z0_supported = 1;
2024}
2025
2026
2027bool
2028ProcessGDBRemote::StartAsyncThread ()
2029{
2030    ResetGDBRemoteState ();
2031
2032    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
2033
2034    if (log)
2035        log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
2036
2037    // Create a thread that watches our internal state and controls which
2038    // events make it to clients (into the DCProcess event queue).
2039    m_async_thread = Host::ThreadCreate ("<lldb.process.gdb-remote.async>", ProcessGDBRemote::AsyncThread, this, NULL);
2040    return m_async_thread != LLDB_INVALID_HOST_THREAD;
2041}
2042
2043void
2044ProcessGDBRemote::StopAsyncThread ()
2045{
2046    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
2047
2048    if (log)
2049        log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
2050
2051    m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit);
2052
2053    // Stop the stdio thread
2054    if (m_async_thread != LLDB_INVALID_HOST_THREAD)
2055    {
2056        Host::ThreadJoin (m_async_thread, NULL, NULL);
2057    }
2058}
2059
2060
2061void *
2062ProcessGDBRemote::AsyncThread (void *arg)
2063{
2064    ProcessGDBRemote *process = (ProcessGDBRemote*) arg;
2065
2066    LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
2067    if (log)
2068        log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) thread starting...", __FUNCTION__, arg, process->GetID());
2069
2070    Listener listener ("ProcessGDBRemote::AsyncThread");
2071    EventSP event_sp;
2072    const uint32_t desired_event_mask = eBroadcastBitAsyncContinue |
2073                                        eBroadcastBitAsyncThreadShouldExit;
2074
2075    if (listener.StartListeningForEvents (&process->m_async_broadcaster, desired_event_mask) == desired_event_mask)
2076    {
2077        bool done = false;
2078        while (!done)
2079        {
2080            log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
2081            if (log)
2082                log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) listener.WaitForEvent (NULL, event_sp)...", __FUNCTION__, arg, process->GetID());
2083            if (listener.WaitForEvent (NULL, event_sp))
2084            {
2085                const uint32_t event_type = event_sp->GetType();
2086                if (log)
2087                    log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) Got an event of type: %d...", __FUNCTION__, arg, process->GetID(), event_type);
2088
2089                switch (event_type)
2090                {
2091                    case eBroadcastBitAsyncContinue:
2092                        {
2093                            const EventDataBytes *continue_packet = EventDataBytes::GetEventDataFromEvent(event_sp.get());
2094
2095                            if (continue_packet)
2096                            {
2097                                const char *continue_cstr = (const char *)continue_packet->GetBytes ();
2098                                const size_t continue_cstr_len = continue_packet->GetByteSize ();
2099                                log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
2100                                if (log)
2101                                    log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got eBroadcastBitAsyncContinue: %s", __FUNCTION__, arg, process->GetID(), continue_cstr);
2102
2103                                process->SetPrivateState(eStateRunning);
2104                                StringExtractorGDBRemote response;
2105                                StateType stop_state = process->GetGDBRemote().SendContinuePacketAndWaitForResponse (process, continue_cstr, continue_cstr_len, response);
2106
2107                                switch (stop_state)
2108                                {
2109                                case eStateStopped:
2110                                case eStateCrashed:
2111                                case eStateSuspended:
2112                                    process->m_last_stop_packet = response;
2113                                    process->m_last_stop_packet.SetFilePos (0);
2114                                    process->SetPrivateState (stop_state);
2115                                    break;
2116
2117                                case eStateExited:
2118                                    process->m_last_stop_packet = response;
2119                                    process->m_last_stop_packet.SetFilePos (0);
2120                                    response.SetFilePos(1);
2121                                    process->SetExitStatus(response.GetHexU8(), NULL);
2122                                    done = true;
2123                                    break;
2124
2125                                case eStateInvalid:
2126                                    break;
2127
2128                                default:
2129                                    process->SetPrivateState (stop_state);
2130                                    break;
2131                                }
2132                            }
2133                        }
2134                        break;
2135
2136                    case eBroadcastBitAsyncThreadShouldExit:
2137                        log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
2138                        if (log)
2139                            log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got eBroadcastBitAsyncThreadShouldExit...", __FUNCTION__, arg, process->GetID());
2140                        done = true;
2141                        break;
2142
2143                    default:
2144                        log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
2145                        if (log)
2146                            log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got unknown event 0x%8.8x", __FUNCTION__, arg, process->GetID(), event_type);
2147                        done = true;
2148                        break;
2149                }
2150            }
2151            else
2152            {
2153                log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
2154                if (log)
2155                    log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) listener.WaitForEvent (NULL, event_sp) => false", __FUNCTION__, arg, process->GetID());
2156                done = true;
2157            }
2158        }
2159    }
2160
2161    log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
2162    if (log)
2163        log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) thread exiting...", __FUNCTION__, arg, process->GetID());
2164
2165    process->m_async_thread = LLDB_INVALID_HOST_THREAD;
2166    return NULL;
2167}
2168
2169const char *
2170ProcessGDBRemote::GetDispatchQueueNameForThread
2171(
2172    addr_t thread_dispatch_qaddr,
2173    std::string &dispatch_queue_name
2174)
2175{
2176    dispatch_queue_name.clear();
2177    if (thread_dispatch_qaddr != 0 && thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
2178    {
2179        // Cache the dispatch_queue_offsets_addr value so we don't always have
2180        // to look it up
2181        if (m_dispatch_queue_offsets_addr == LLDB_INVALID_ADDRESS)
2182        {
2183            static ConstString g_dispatch_queue_offsets_symbol_name ("dispatch_queue_offsets");
2184            const Symbol *dispatch_queue_offsets_symbol = NULL;
2185            ModuleSP module_sp(GetTarget().GetImages().FindFirstModuleForFileSpec (FileSpec("libSystem.B.dylib", false)));
2186            if (module_sp)
2187                dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
2188
2189            if (dispatch_queue_offsets_symbol == NULL)
2190            {
2191                module_sp = GetTarget().GetImages().FindFirstModuleForFileSpec (FileSpec("libdispatch.dylib", false));
2192                if (module_sp)
2193                    dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
2194            }
2195            if (dispatch_queue_offsets_symbol)
2196                m_dispatch_queue_offsets_addr = dispatch_queue_offsets_symbol->GetValue().GetLoadAddress(&m_target);
2197
2198            if (m_dispatch_queue_offsets_addr == LLDB_INVALID_ADDRESS)
2199                return NULL;
2200        }
2201
2202        uint8_t memory_buffer[8];
2203        DataExtractor data(memory_buffer, sizeof(memory_buffer), GetByteOrder(), GetAddressByteSize());
2204
2205        // Excerpt from src/queue_private.h
2206        struct dispatch_queue_offsets_s
2207        {
2208            uint16_t dqo_version;
2209            uint16_t dqo_label;
2210            uint16_t dqo_label_size;
2211        } dispatch_queue_offsets;
2212
2213
2214        Error error;
2215        if (ReadMemory (m_dispatch_queue_offsets_addr, memory_buffer, sizeof(dispatch_queue_offsets), error) == sizeof(dispatch_queue_offsets))
2216        {
2217            uint32_t data_offset = 0;
2218            if (data.GetU16(&data_offset, &dispatch_queue_offsets.dqo_version, sizeof(dispatch_queue_offsets)/sizeof(uint16_t)))
2219            {
2220                if (ReadMemory (thread_dispatch_qaddr, &memory_buffer, data.GetAddressByteSize(), error) == data.GetAddressByteSize())
2221                {
2222                    data_offset = 0;
2223                    lldb::addr_t queue_addr = data.GetAddress(&data_offset);
2224                    lldb::addr_t label_addr = queue_addr + dispatch_queue_offsets.dqo_label;
2225                    dispatch_queue_name.resize(dispatch_queue_offsets.dqo_label_size, '\0');
2226                    size_t bytes_read = ReadMemory (label_addr, &dispatch_queue_name[0], dispatch_queue_offsets.dqo_label_size, error);
2227                    if (bytes_read < dispatch_queue_offsets.dqo_label_size)
2228                        dispatch_queue_name.erase (bytes_read);
2229                }
2230            }
2231        }
2232    }
2233    if (dispatch_queue_name.empty())
2234        return NULL;
2235    return dispatch_queue_name.c_str();
2236}
2237
2238uint32_t
2239ProcessGDBRemote::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
2240{
2241    // If we are planning to launch the debugserver remotely, then we need to fire up a debugserver
2242    // process and ask it for the list of processes. But if we are local, we can let the Host do it.
2243    if (m_local_debugserver)
2244    {
2245        return Host::ListProcessesMatchingName (name, matches, pids);
2246    }
2247    else
2248    {
2249        // FIXME: Implement talking to the remote debugserver.
2250        return 0;
2251    }
2252
2253}
2254