1 
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 //  Created by Greg Clayton on 12/12/07.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef __RNBRemote_h__
15 #define __RNBRemote_h__
16 
17 #include "RNBDefs.h"
18 #include "DNB.h"
19 #include "RNBContext.h"
20 #include "RNBSocket.h"
21 #include "PThreadMutex.h"
22 #include <string>
23 #include <vector>
24 #include <deque>
25 #include <map>
26 
27 class RNBSocket;
28 class RNBContext;
29 class PThreadEvents;
30 
31 enum event_loop_mode { debug_nub, gdb_remote_protocol, done };
32 
33 enum class compression_types { zlib_deflate, lz4, lzma, lzfse, none };
34 
35 class RNBRemote
36 {
37 public:
38 
39     typedef enum {
40         invalid_packet = 0,
41         ack,                            // '+'
42         nack,                           // '-'
43         halt,                           // ^C  (async halt)
44         use_extended_mode,              // '!'
45         why_halted,                     // '?'
46         set_argv,                       // 'A'
47         set_bp,                         // 'B'
48         cont,                           // 'c'
49         continue_with_sig,              // 'C'
50         detach,                         // 'D'
51         read_general_regs,              // 'g'
52         write_general_regs,             // 'G'
53         set_thread,                     // 'H'
54         step_inferior_one_cycle,        // 'i'
55         signal_and_step_inf_one_cycle,  // 'I'
56         kill,                           // 'k'
57         read_memory,                    // 'm'
58         write_memory,                   // 'M'
59         read_register,                  // 'p'
60         write_register,                 // 'P'
61         restart,                        // 'R'
62         single_step,                    // 's'
63         single_step_with_sig,           // 'S'
64         search_mem_backwards,           // 't'
65         thread_alive_p,                 // 'T'
66         vattach,                        // 'vAttach;pid'
67         vattachwait,                    // 'vAttachWait:XX...' where XX is one or more hex encoded process name ASCII bytes
68         vattachorwait,                  // 'vAttachOrWait:XX...' where XX is one or more hex encoded process name ASCII bytes
69         vattachname,                    // 'vAttachName:XX...' where XX is one or more hex encoded process name ASCII bytes
70         vcont,                          // 'vCont'
71         vcont_list_actions,             // 'vCont?'
72         read_data_from_memory,          // 'x'
73         write_data_to_memory,           // 'X'
74         insert_mem_bp,                  // 'Z0'
75         remove_mem_bp,                  // 'z0'
76         insert_hardware_bp,             // 'Z1'
77         remove_hardware_bp,             // 'z1'
78         insert_write_watch_bp,          // 'Z2'
79         remove_write_watch_bp,          // 'z2'
80         insert_read_watch_bp,           // 'Z3'
81         remove_read_watch_bp,           // 'z3'
82         insert_access_watch_bp,         // 'Z4'
83         remove_access_watch_bp,         // 'z4'
84 
85         query_monitor,                  // 'qRcmd'
86         query_current_thread_id,        // 'qC'
87         query_get_pid,                  // 'qGetPid'
88         query_echo,                     // 'qEcho'
89         query_thread_ids_first,         // 'qfThreadInfo'
90         query_thread_ids_subsequent,    // 'qsThreadInfo'
91         query_thread_extra_info,        // 'qThreadExtraInfo'
92         query_thread_stop_info,         // 'qThreadStopInfo'
93         query_image_offsets,            // 'qOffsets'
94         query_symbol_lookup,            // 'qSymbol'
95         query_launch_success,           // 'qLaunchSuccess'
96         query_register_info,            // 'qRegisterInfo'
97         query_shlib_notify_info_addr,   // 'qShlibInfoAddr'
98         query_step_packet_supported,    // 'qStepPacketSupported'
99         query_supported_features,       // 'qSupported'
100         query_vattachorwait_supported,  // 'qVAttachOrWaitSupported'
101         query_sync_thread_state_supported,// 'QSyncThreadState'
102         query_host_info,                // 'qHostInfo'
103         query_gdb_server_version,       // 'qGDBServerVersion'
104         query_process_info,             // 'qProcessInfo'
105         json_query_thread_extended_info,// 'jThreadExtendedInfo'
106         json_query_threads_info,        // 'jThreadsInfo'
107         pass_signals_to_inferior,       // 'QPassSignals'
108         start_noack_mode,               // 'QStartNoAckMode'
109         prefix_reg_packets_with_tid,    // 'QPrefixRegisterPacketsWithThreadID
110         set_logging_mode,               // 'QSetLogging:'
111         set_max_packet_size,            // 'QSetMaxPacketSize:'
112         set_max_payload_size,           // 'QSetMaxPayloadSize:'
113         set_environment_variable,       // 'QEnvironment:'
114         set_environment_variable_hex,   // 'QEnvironmentHexEncoded:'
115         set_launch_arch,                // 'QLaunchArch:'
116         set_disable_aslr,               // 'QSetDisableASLR:'
117         set_stdin,                      // 'QSetSTDIN:'
118         set_stdout,                     // 'QSetSTDOUT:'
119         set_stderr,                     // 'QSetSTDERR:'
120         set_working_dir,                // 'QSetWorkingDir:'
121         set_list_threads_in_stop_reply, // 'QListThreadsInStopReply:'
122         sync_thread_state,              // 'QSyncThreadState:'
123         memory_region_info,             // 'qMemoryRegionInfo:'
124         get_profile_data,               // 'qGetProfileData'
125         set_enable_profiling,           // 'QSetEnableAsyncProfiling'
126         enable_compression,             // 'QEnableCompression:'
127         watchpoint_support_info,        // 'qWatchpointSupportInfo:'
128         allocate_memory,                // '_M'
129         deallocate_memory,              // '_m'
130         set_process_event,               // 'QSetProcessEvent:'
131         save_register_state,            // '_g'
132         restore_register_state,         // '_G'
133         speed_test,                     // 'qSpeedTest:'
134         set_detach_on_error,            // 'QSetDetachOnError:'
135         query_transfer,                 // 'qXfer:'
136         unknown_type
137     } PacketEnum;
138 
139     typedef rnb_err_t (RNBRemote::*HandlePacketCallback)(const char *p);
140 
141     RNBRemote ();
142     ~RNBRemote ();
143 
144     void            Initialize();
145 
146     bool            InitializeRegisters (bool force = false);
147 
148     rnb_err_t       HandleAsyncPacket(PacketEnum *type = NULL);
149     rnb_err_t       HandleReceivedPacket(PacketEnum *type = NULL);
150 
151     nub_thread_t    GetContinueThread () const
152                     {
153                         return m_continue_thread;
154                     }
155 
156     void            SetContinueThread (nub_thread_t tid)
157                     {
158                         m_continue_thread = tid;
159                     }
160 
161     nub_thread_t    GetCurrentThread () const
162                     {
163                         if (m_thread == 0 || m_thread == -1)
164                             return DNBProcessGetCurrentThread (m_ctx.ProcessID());
165                         return m_thread;
166                     }
167 
168     void            SetCurrentThread (nub_thread_t tid)
169                     {
170                         DNBProcessSetCurrentThread (m_ctx.ProcessID(), tid);
171                         m_thread = tid;
172                     }
173 
174     static void*    ThreadFunctionReadRemoteData(void *arg);
175     void            StartReadRemoteDataThread ();
176     void            StopReadRemoteDataThread ();
177 
178     void NotifyThatProcessStopped (void);
179 
180     rnb_err_t HandlePacket_A (const char *p);
181     rnb_err_t HandlePacket_H (const char *p);
182     rnb_err_t HandlePacket_qC (const char *p);
183     rnb_err_t HandlePacket_qRcmd (const char *p);
184     rnb_err_t HandlePacket_qGetPid (const char *p);
185     rnb_err_t HandlePacket_qEcho (const char *p);
186     rnb_err_t HandlePacket_qLaunchSuccess (const char *p);
187     rnb_err_t HandlePacket_qRegisterInfo (const char *p);
188     rnb_err_t HandlePacket_qShlibInfoAddr (const char *p);
189     rnb_err_t HandlePacket_qStepPacketSupported (const char *p);
190     rnb_err_t HandlePacket_qVAttachOrWaitSupported (const char *p);
191     rnb_err_t HandlePacket_qSyncThreadStateSupported (const char *p);
192     rnb_err_t HandlePacket_qThreadInfo (const char *p);
193     rnb_err_t HandlePacket_jThreadExtendedInfo (const char *p);
194     rnb_err_t HandlePacket_jThreadsInfo (const char *p);
195     rnb_err_t HandlePacket_qThreadExtraInfo (const char *p);
196     rnb_err_t HandlePacket_qThreadStopInfo (const char *p);
197     rnb_err_t HandlePacket_qHostInfo (const char *p);
198     rnb_err_t HandlePacket_qGDBServerVersion (const char *p);
199     rnb_err_t HandlePacket_qProcessInfo (const char *p);
200     rnb_err_t HandlePacket_qSymbol (const char *p);
201     rnb_err_t HandlePacket_QStartNoAckMode (const char *p);
202     rnb_err_t HandlePacket_QThreadSuffixSupported (const char *p);
203     rnb_err_t HandlePacket_QSetLogging (const char *p);
204     rnb_err_t HandlePacket_QSetDisableASLR (const char *p);
205     rnb_err_t HandlePacket_QSetSTDIO (const char *p);
206     rnb_err_t HandlePacket_QSetWorkingDir (const char *p);
207     rnb_err_t HandlePacket_QSetMaxPayloadSize (const char *p);
208     rnb_err_t HandlePacket_QSetMaxPacketSize (const char *p);
209     rnb_err_t HandlePacket_QEnvironment (const char *p);
210     rnb_err_t HandlePacket_QEnvironmentHexEncoded (const char *p);
211     rnb_err_t HandlePacket_QLaunchArch (const char *p);
212     rnb_err_t HandlePacket_QListThreadsInStopReply (const char *p);
213     rnb_err_t HandlePacket_QSyncThreadState (const char *p);
214     rnb_err_t HandlePacket_QPrefixRegisterPacketsWithThreadID (const char *p);
215     rnb_err_t HandlePacket_QSetProcessEvent (const char *p);
216     rnb_err_t HandlePacket_last_signal (const char *p);
217     rnb_err_t HandlePacket_m (const char *p);
218     rnb_err_t HandlePacket_M (const char *p);
219     rnb_err_t HandlePacket_x (const char *p);
220     rnb_err_t HandlePacket_X (const char *p);
221     rnb_err_t HandlePacket_g (const char *p);
222     rnb_err_t HandlePacket_G (const char *p);
223     rnb_err_t HandlePacket_z (const char *p);
224     rnb_err_t HandlePacket_T (const char *p);
225     rnb_err_t HandlePacket_p (const char *p);
226     rnb_err_t HandlePacket_P (const char *p);
227     rnb_err_t HandlePacket_c (const char *p);
228     rnb_err_t HandlePacket_C (const char *p);
229     rnb_err_t HandlePacket_D (const char *p);
230     rnb_err_t HandlePacket_k (const char *p);
231     rnb_err_t HandlePacket_s (const char *p);
232     rnb_err_t HandlePacket_S (const char *p);
233     rnb_err_t HandlePacket_qSupported (const char *p);
234     rnb_err_t HandlePacket_v (const char *p);
235     rnb_err_t HandlePacket_UNIMPLEMENTED (const char *p);
236     rnb_err_t HandlePacket_ILLFORMED (const char *file, int line, const char *p, const char *description);
237     rnb_err_t HandlePacket_AllocateMemory (const char *p);
238     rnb_err_t HandlePacket_DeallocateMemory (const char *p);
239     rnb_err_t HandlePacket_SaveRegisterState (const char *p);
240     rnb_err_t HandlePacket_RestoreRegisterState (const char *p);
241     rnb_err_t HandlePacket_MemoryRegionInfo (const char *p);
242     rnb_err_t HandlePacket_GetProfileData(const char *p);
243     rnb_err_t HandlePacket_SetEnableAsyncProfiling(const char *p);
244     rnb_err_t HandlePacket_QEnableCompression(const char *p);
245     rnb_err_t HandlePacket_WatchpointSupportInfo (const char *p);
246     rnb_err_t HandlePacket_qSpeedTest (const char *p);
247     rnb_err_t HandlePacket_qXfer (const char *p);
248     rnb_err_t HandlePacket_stop_process (const char *p);
249     rnb_err_t HandlePacket_QSetDetachOnError (const char *p);
250 
251     rnb_err_t SendStopReplyPacketForThread (nub_thread_t tid);
252     rnb_err_t SendHexEncodedBytePacket (const char *header, const void *buf, size_t buf_len, const char *footer);
253     rnb_err_t SendSTDOUTPacket (char *buf, nub_size_t buf_size);
254     rnb_err_t SendSTDERRPacket (char *buf, nub_size_t buf_size);
255     void      FlushSTDIO ();
256     void      SendAsyncProfileData ();
257     rnb_err_t SendAsyncProfileDataPacket (char *buf, nub_size_t buf_size);
258 
259     RNBContext&     Context() { return m_ctx; }
260     RNBSocket&      Comm() { return m_comm; }
261 
262 private:
263     // Outlaw some constructors
264     RNBRemote (const RNBRemote &);
265 
266 protected:
267 
268     rnb_err_t GetCommData ();
269     void CommDataReceived(const std::string& data);
270     struct Packet
271     {
272         typedef std::vector<Packet>         collection;
273         typedef collection::iterator        iterator;
274         typedef collection::const_iterator  const_iterator;
275         PacketEnum type;
276         HandlePacketCallback normal;    // Function to call when inferior is halted
277         HandlePacketCallback async;     // Function to call when inferior is running
278         std::string abbrev;
279         std::string printable_name;
280 
281         bool
282         IsPlatformPacket () const
283         {
284             switch (type)
285             {
286             case set_logging_mode:
287             case query_host_info:
288                 return true;
289             default:
290                     break;
291             }
292             return false;
293         }
294         Packet() :
295             type(invalid_packet),
296             normal (NULL),
297             async (NULL),
298             abbrev (),
299             printable_name ()
300         {
301         }
302 
303         Packet( PacketEnum in_type,
304                 HandlePacketCallback in_normal,
305                 HandlePacketCallback in_async,
306                 const char *in_abbrev,
307                 const char *in_printable_name) :
308             type    (in_type),
309             normal  (in_normal),
310             async   (in_async),
311             abbrev  (in_abbrev),
312             printable_name (in_printable_name)
313         {
314         }
315     };
316 
317 
318     struct DispatchQueueOffsets
319     {
320         uint16_t dqo_version;
321         uint16_t dqo_label;
322         uint16_t dqo_label_size;
323         uint16_t dqo_flags;
324         uint16_t dqo_flags_size;
325         uint16_t dqo_serialnum;
326         uint16_t dqo_serialnum_size;
327         uint16_t dqo_width;
328         uint16_t dqo_width_size;
329         uint16_t dqo_running;
330         uint16_t dqo_running_size;
331         uint16_t dqo_suspend_cnt;         // version 5 and later, starting with Mac OS X 10.10/iOS 8
332         uint16_t dqo_suspend_cnt_size;    // version 5 and later, starting with Mac OS X 10.10/iOS 8
333         uint16_t dqo_target_queue;        // version 5 and later, starting with Mac OS X 10.10/iOS 8
334         uint16_t dqo_target_queue_size;   // version 5 and later, starting with Mac OS X 10.10/iOS 8
335         uint16_t dqo_priority;            // version 5 and later, starting with Mac OS X 10.10/iOS 8
336         uint16_t dqo_priority_size;       // version 5 and later, starting with Mac OS X 10.10/iOS 8
337 
338         DispatchQueueOffsets ()
339         {
340             Clear();
341         }
342 
343         void
344         Clear()
345         {
346             dqo_version = UINT16_MAX;
347             dqo_label = UINT16_MAX;
348             dqo_label_size = UINT16_MAX;
349             dqo_flags = UINT16_MAX;
350             dqo_flags_size = UINT16_MAX;
351             dqo_serialnum = UINT16_MAX;
352             dqo_serialnum_size = UINT16_MAX;
353             dqo_width = UINT16_MAX;
354             dqo_width_size = UINT16_MAX;
355             dqo_running = UINT16_MAX;
356             dqo_running_size = UINT16_MAX;
357             dqo_suspend_cnt = UINT16_MAX;
358             dqo_suspend_cnt_size = UINT16_MAX;
359             dqo_target_queue = UINT16_MAX;
360             dqo_target_queue_size = UINT16_MAX;
361             dqo_priority = UINT16_MAX;
362             dqo_priority_size = UINT16_MAX;
363         }
364 
365         bool
366         IsValid () const
367         {
368             return dqo_version != UINT16_MAX;
369         }
370 
371         void
372         GetThreadQueueInfo (nub_process_t pid,
373                             nub_addr_t dispatch_qaddr,
374                             std::string &queue_name,
375                             uint64_t &queue_width,
376                             uint64_t &queue_serialnum) const;
377     };
378 
379     rnb_err_t       GetPacket (std::string &packet_data, RNBRemote::Packet& packet_info, bool wait);
380     rnb_err_t       SendPacket (const std::string &);
381     std::string     CompressString (const std::string &);
382 
383     void CreatePacketTable ();
384     rnb_err_t GetPacketPayload (std::string &);
385 
386     nub_thread_t
387     ExtractThreadIDFromThreadSuffix (const char *p);
388 
389     void
390     EnableCompressionNextSendPacket (compression_types);
391 
392     compression_types
393     GetCompressionType ();
394 
395     const DispatchQueueOffsets *
396     GetDispatchQueueOffsets();
397 
398     RNBContext      m_ctx;              // process context
399     RNBSocket       m_comm;             // communication port
400     std::string     m_arch;
401     nub_thread_t    m_continue_thread;  // thread to continue; 0 for any, -1 for all
402     nub_thread_t    m_thread;           // thread for other ops; 0 for any, -1 for all
403     PThreadMutex    m_mutex;            // Mutex that protects
404     DispatchQueueOffsets m_dispatch_queue_offsets;
405     nub_addr_t      m_dispatch_queue_offsets_addr;
406     uint32_t        m_qSymbol_index;
407     uint32_t        m_packets_recvd;
408     Packet::collection m_packets;
409     std::deque<std::string> m_rx_packets;
410     std::string     m_rx_partial_data;  // For packets that may come in more than one batch, anything left over can be left here
411     pthread_t       m_rx_pthread;
412     uint32_t        m_max_payload_size;  // the maximum sized payload we should send to gdb
413     bool            m_extended_mode;   // are we in extended mode?
414     bool            m_noack_mode;      // are we in no-ack mode?
415     bool            m_thread_suffix_supported; // Set to true if the 'p', 'P', 'g', and 'G' packets should be prefixed with the thread ID and colon:
416                                                                 // "$pRR;thread:TTTT;" instead of "$pRR"
417                                                                 // "$PRR=VVVVVVVV;thread:TTTT;" instead of "$PRR=VVVVVVVV"
418                                                                 // "$g;thread:TTTT" instead of "$g"
419                                                                 // "$GVVVVVVVVVVVVVV;thread:TTTT;#00 instead of "$GVVVVVVVVVVVVVV"
420     bool            m_list_threads_in_stop_reply;
421 
422     size_t          m_compression_minsize;                      // only packets larger than this size will be compressed
423     bool            m_enable_compression_next_send_packet;
424 
425     compression_types m_compression_mode;
426 };
427 
428 /* We translate the /usr/include/mach/exception_types.h exception types
429    (e.g. EXC_BAD_ACCESS) to the fake BSD signal numbers that gdb uses
430    in include/gdb/signals.h (e.g. TARGET_EXC_BAD_ACCESS).  These hard
431    coded values for TARGET_EXC_BAD_ACCESS et al must match the gdb
432    values in its include/gdb/signals.h.  */
433 
434 #define TARGET_EXC_BAD_ACCESS      0x91
435 #define TARGET_EXC_BAD_INSTRUCTION 0x92
436 #define TARGET_EXC_ARITHMETIC      0x93
437 #define TARGET_EXC_EMULATION       0x94
438 #define TARGET_EXC_SOFTWARE        0x95
439 #define TARGET_EXC_BREAKPOINT      0x96
440 
441 /* Generally speaking, you can't assume gdb can receive more than 399 bytes
442    at a time with a random gdb.  This bufsize constant is only specifying
443    how many bytes gdb can *receive* from debugserver -- it tells us nothing
444    about how many bytes gdb might try to send in a single packet.  */
445 #define DEFAULT_GDB_REMOTE_PROTOCOL_BUFSIZE 399
446 
447 #endif // #ifndef __RNBRemote_h__
448