1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
|
//===-- GDBRemoteCommunicationClient.h --------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_GDBRemoteCommunicationClient_h_
#define liblldb_GDBRemoteCommunicationClient_h_
// C Includes
// C++ Includes
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ArchSpec.h"
#include "lldb/Target/Process.h"
#include "GDBRemoteCommunication.h"
typedef enum
{
eBreakpointSoftware = 0,
eBreakpointHardware,
eWatchpointWrite,
eWatchpointRead,
eWatchpointReadWrite
} GDBStoppointType;
class GDBRemoteCommunicationClient : public GDBRemoteCommunication
{
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
GDBRemoteCommunicationClient(bool is_platform);
~GDBRemoteCommunicationClient();
//------------------------------------------------------------------
// After connecting, send the handshake to the server to make sure
// we are communicating with it.
//------------------------------------------------------------------
bool
HandshakeWithServer (lldb_private::Error *error_ptr);
size_t
SendPacketAndWaitForResponse (const char *send_payload,
StringExtractorGDBRemote &response,
bool send_async);
size_t
SendPacketAndWaitForResponse (const char *send_payload,
size_t send_length,
StringExtractorGDBRemote &response,
bool send_async);
lldb::StateType
SendContinuePacketAndWaitForResponse (ProcessGDBRemote *process,
const char *packet_payload,
size_t packet_length,
StringExtractorGDBRemote &response);
bool
GetThreadSuffixSupported ();
// This packet is usually sent first and the boolean return value
// indicates if the packet was send and any response was received
// even in the response is UNIMPLEMENTED. If the packet failed to
// get a response, then false is returned. This quickly tells us
// if we were able to connect and communicte with the remote GDB
// server
bool
QueryNoAckModeSupported ();
void
GetListThreadsInStopReplySupported ();
bool
SendAsyncSignal (int signo);
bool
SendInterrupt (lldb_private::Mutex::Locker &locker,
uint32_t seconds_to_wait_for_stop,
bool &timed_out);
lldb::pid_t
GetCurrentProcessID ();
bool
GetLaunchSuccess (std::string &error_str);
uint16_t
LaunchGDBserverAndGetPort (lldb::pid_t &pid);
bool
KillSpawnedProcess (lldb::pid_t pid);
//------------------------------------------------------------------
/// Sends a GDB remote protocol 'A' packet that delivers program
/// arguments to the remote server.
///
/// @param[in] argv
/// A NULL terminated array of const C strings to use as the
/// arguments.
///
/// @return
/// Zero if the response was "OK", a positive value if the
/// the response was "Exx" where xx are two hex digits, or
/// -1 if the call is unsupported or any other unexpected
/// response was received.
//------------------------------------------------------------------
int
SendArgumentsPacket (const lldb_private::ProcessLaunchInfo &launch_info);
//------------------------------------------------------------------
/// Sends a "QEnvironment:NAME=VALUE" packet that will build up the
/// environment that will get used when launching an application
/// in conjunction with the 'A' packet. This function can be called
/// multiple times in a row in order to pass on the desired
/// environment that the inferior should be launched with.
///
/// @param[in] name_equal_value
/// A NULL terminated C string that contains a single environment
/// in the format "NAME=VALUE".
///
/// @return
/// Zero if the response was "OK", a positive value if the
/// the response was "Exx" where xx are two hex digits, or
/// -1 if the call is unsupported or any other unexpected
/// response was received.
//------------------------------------------------------------------
int
SendEnvironmentPacket (char const *name_equal_value);
int
SendLaunchArchPacket (const char *arch);
//------------------------------------------------------------------
/// Sends a "vAttach:PID" where PID is in hex.
///
/// @param[in] pid
/// A process ID for the remote gdb server to attach to.
///
/// @param[out] response
/// The response received from the gdb server. If the return
/// value is zero, \a response will contain a stop reply
/// packet.
///
/// @return
/// Zero if the attach was successful, or an error indicating
/// an error code.
//------------------------------------------------------------------
int
SendAttach (lldb::pid_t pid,
StringExtractorGDBRemote& response);
//------------------------------------------------------------------
/// Sets the path to use for stdin/out/err for a process
/// that will be launched with the 'A' packet.
///
/// @param[in] path
/// The path to use for stdin/out/err
///
/// @return
/// Zero if the for success, or an error code for failure.
//------------------------------------------------------------------
int
SetSTDIN (char const *path);
int
SetSTDOUT (char const *path);
int
SetSTDERR (char const *path);
//------------------------------------------------------------------
/// Sets the disable ASLR flag to \a enable for a process that will
/// be launched with the 'A' packet.
///
/// @param[in] enable
/// A boolean value indicating wether to disable ASLR or not.
///
/// @return
/// Zero if the for success, or an error code for failure.
//------------------------------------------------------------------
int
SetDisableASLR (bool enable);
//------------------------------------------------------------------
/// Sets the working directory to \a path for a process that will
/// be launched with the 'A' packet for non platform based
/// connections. If this packet is sent to a GDB server that
/// implements the platform, it will change the current working
/// directory for the platform process.
///
/// @param[in] path
/// The path to a directory to use when launching our processs
///
/// @return
/// Zero if the for success, or an error code for failure.
//------------------------------------------------------------------
int
SetWorkingDir (char const *path);
//------------------------------------------------------------------
/// Gets the current working directory of a remote platform GDB
/// server.
///
/// @param[out] cwd
/// The current working directory on the remote platform.
///
/// @return
/// Boolean for success
//------------------------------------------------------------------
bool
GetWorkingDir (std::string &cwd);
lldb::addr_t
AllocateMemory (size_t size, uint32_t permissions);
bool
DeallocateMemory (lldb::addr_t addr);
lldb_private::Error
Detach (bool keep_stopped);
lldb_private::Error
GetMemoryRegionInfo (lldb::addr_t addr,
lldb_private::MemoryRegionInfo &range_info);
lldb_private::Error
GetWatchpointSupportInfo (uint32_t &num);
lldb_private::Error
GetWatchpointSupportInfo (uint32_t &num, bool& after);
lldb_private::Error
GetWatchpointsTriggerAfterInstruction (bool &after);
const lldb_private::ArchSpec &
GetHostArchitecture ();
uint32_t
GetHostDefaultPacketTimeout();
const lldb_private::ArchSpec &
GetProcessArchitecture ();
bool
GetVContSupported (char flavor);
bool
GetpPacketSupported (lldb::tid_t tid);
bool
GetVAttachOrWaitSupported ();
bool
GetSyncThreadStateSupported();
void
ResetDiscoverableSettings();
bool
GetHostInfo (bool force = false);
bool
GetOSVersion (uint32_t &major,
uint32_t &minor,
uint32_t &update);
bool
GetOSBuildString (std::string &s);
bool
GetOSKernelDescription (std::string &s);
lldb_private::ArchSpec
GetSystemArchitecture ();
bool
GetHostname (std::string &s);
lldb::addr_t
GetShlibInfoAddr();
bool
GetSupportsThreadSuffix ();
bool
GetProcessInfo (lldb::pid_t pid,
lldb_private::ProcessInstanceInfo &process_info);
uint32_t
FindProcesses (const lldb_private::ProcessInstanceInfoMatch &process_match_info,
lldb_private::ProcessInstanceInfoList &process_infos);
bool
GetUserName (uint32_t uid, std::string &name);
bool
GetGroupName (uint32_t gid, std::string &name);
bool
HasFullVContSupport ()
{
return GetVContSupported ('A');
}
bool
HasAnyVContSupport ()
{
return GetVContSupported ('a');
}
bool
GetStopReply (StringExtractorGDBRemote &response);
bool
GetThreadStopInfo (lldb::tid_t tid,
StringExtractorGDBRemote &response);
bool
SupportsGDBStoppointPacket (GDBStoppointType type)
{
switch (type)
{
case eBreakpointSoftware: return m_supports_z0;
case eBreakpointHardware: return m_supports_z1;
case eWatchpointWrite: return m_supports_z2;
case eWatchpointRead: return m_supports_z3;
case eWatchpointReadWrite: return m_supports_z4;
}
return false;
}
uint8_t
SendGDBStoppointTypePacket (GDBStoppointType type, // Type of breakpoint or watchpoint
bool insert, // Insert or remove?
lldb::addr_t addr, // Address of breakpoint or watchpoint
uint32_t length); // Byte Size of breakpoint or watchpoint
void
TestPacketSpeed (const uint32_t num_packets);
// This packet is for testing the speed of the interface only. Both
// the client and server need to support it, but this allows us to
// measure the packet speed without any other work being done on the
// other end and avoids any of that work affecting the packet send
// and response times.
bool
SendSpeedTestPacket (uint32_t send_size,
uint32_t recv_size);
bool
SetCurrentThread (uint64_t tid);
bool
SetCurrentThreadForRun (uint64_t tid);
lldb_private::LazyBool
SupportsAllocDeallocMemory () // const
{
// Uncomment this to have lldb pretend the debug server doesn't respond to alloc/dealloc memory packets.
// m_supports_alloc_dealloc_memory = lldb_private::eLazyBoolNo;
return m_supports_alloc_dealloc_memory;
}
size_t
GetCurrentThreadIDs (std::vector<lldb::tid_t> &thread_ids,
bool &sequence_mutex_unavailable);
bool
GetInterruptWasSent () const
{
return m_interrupt_sent;
}
lldb::user_id_t
OpenFile (const lldb_private::FileSpec& file_spec,
uint32_t flags,
mode_t mode,
lldb_private::Error &error);
bool
CloseFile (lldb::user_id_t fd,
lldb_private::Error &error);
lldb::user_id_t
GetFileSize (const lldb_private::FileSpec& file_spec);
lldb_private::Error
GetFilePermissions(const char *path, uint32_t &file_permissions);
lldb_private::Error
SetFilePermissions(const char *path, uint32_t file_permissions);
uint64_t
ReadFile (lldb::user_id_t fd,
uint64_t offset,
void *dst,
uint64_t dst_len,
lldb_private::Error &error);
uint64_t
WriteFile (lldb::user_id_t fd,
uint64_t offset,
const void* src,
uint64_t src_len,
lldb_private::Error &error);
lldb_private::Error
CreateSymlink (const char *src,
const char *dst);
lldb_private::Error
Unlink (const char *path);
lldb_private::Error
MakeDirectory (const char *path,
uint32_t mode);
bool
GetFileExists (const lldb_private::FileSpec& file_spec);
lldb_private::Error
RunShellCommand (const char *command, // Shouldn't be NULL
const char *working_dir, // Pass NULL to use the current working directory
int *status_ptr, // Pass NULL if you don't want the process exit status
int *signo_ptr, // Pass NULL if you don't want the signal that caused the process to exit
std::string *command_output, // Pass NULL if you don't want the command output
uint32_t timeout_sec); // Timeout in seconds to wait for shell program to finish
bool
CalculateMD5 (const lldb_private::FileSpec& file_spec,
uint64_t &high,
uint64_t &low);
std::string
HarmonizeThreadIdsForProfileData (ProcessGDBRemote *process,
StringExtractorGDBRemote &inputStringExtractor);
bool
ReadRegister(lldb::tid_t tid,
uint32_t reg_num,
StringExtractorGDBRemote &response);
bool
ReadAllRegisters (lldb::tid_t tid,
StringExtractorGDBRemote &response);
bool
SaveRegisterState (lldb::tid_t tid, uint32_t &save_id);
bool
RestoreRegisterState (lldb::tid_t tid, uint32_t save_id);
protected:
bool
GetCurrentProcessInfo ();
//------------------------------------------------------------------
// Classes that inherit from GDBRemoteCommunicationClient can see and modify these
//------------------------------------------------------------------
lldb_private::LazyBool m_supports_not_sending_acks;
lldb_private::LazyBool m_supports_thread_suffix;
lldb_private::LazyBool m_supports_threads_in_stop_reply;
lldb_private::LazyBool m_supports_vCont_all;
lldb_private::LazyBool m_supports_vCont_any;
lldb_private::LazyBool m_supports_vCont_c;
lldb_private::LazyBool m_supports_vCont_C;
lldb_private::LazyBool m_supports_vCont_s;
lldb_private::LazyBool m_supports_vCont_S;
lldb_private::LazyBool m_qHostInfo_is_valid;
lldb_private::LazyBool m_qProcessInfo_is_valid;
lldb_private::LazyBool m_supports_alloc_dealloc_memory;
lldb_private::LazyBool m_supports_memory_region_info;
lldb_private::LazyBool m_supports_watchpoint_support_info;
lldb_private::LazyBool m_supports_detach_stay_stopped;
lldb_private::LazyBool m_watchpoints_trigger_after_instruction;
lldb_private::LazyBool m_attach_or_wait_reply;
lldb_private::LazyBool m_prepare_for_reg_writing_reply;
lldb_private::LazyBool m_supports_p;
lldb_private::LazyBool m_supports_QSaveRegisterState;
bool
m_supports_qProcessInfoPID:1,
m_supports_qfProcessInfo:1,
m_supports_qUserName:1,
m_supports_qGroupName:1,
m_supports_qThreadStopInfo:1,
m_supports_z0:1,
m_supports_z1:1,
m_supports_z2:1,
m_supports_z3:1,
m_supports_z4:1,
m_supports_QEnvironment:1,
m_supports_QEnvironmentHexEncoded:1;
lldb::tid_t m_curr_tid; // Current gdb remote protocol thread index for all other operations
lldb::tid_t m_curr_tid_run; // Current gdb remote protocol thread index for continue, step, etc
uint32_t m_num_supported_hardware_watchpoints;
// If we need to send a packet while the target is running, the m_async_XXX
// member variables take care of making this happen.
lldb_private::Mutex m_async_mutex;
lldb_private::Predicate<bool> m_async_packet_predicate;
std::string m_async_packet;
StringExtractorGDBRemote m_async_response;
int m_async_signal; // We were asked to deliver a signal to the inferior process.
bool m_interrupt_sent;
std::string m_partial_profile_data;
std::map<uint64_t, uint32_t> m_thread_id_to_used_usec_map;
lldb_private::ArchSpec m_host_arch;
lldb_private::ArchSpec m_process_arch;
uint32_t m_os_version_major;
uint32_t m_os_version_minor;
uint32_t m_os_version_update;
std::string m_os_build;
std::string m_os_kernel;
std::string m_hostname;
uint32_t m_default_packet_timeout;
bool
DecodeProcessInfoResponse (StringExtractorGDBRemote &response,
lldb_private::ProcessInstanceInfo &process_info);
private:
//------------------------------------------------------------------
// For GDBRemoteCommunicationClient only
//------------------------------------------------------------------
DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationClient);
};
#endif // liblldb_GDBRemoteCommunicationClient_h_
|