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
|
//===-- PlatformRemoteGDBServer.h ----------------------------------------*- C++
//-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_SOURCE_PLUGINS_PLATFORM_GDB_SERVER_PLATFORMREMOTEGDBSERVER_H
#define LLDB_SOURCE_PLUGINS_PLATFORM_GDB_SERVER_PLATFORMREMOTEGDBSERVER_H
#include <string>
#include "Plugins/Process/Utility/GDBRemoteSignals.h"
#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.h"
#include "lldb/Target/Platform.h"
namespace lldb_private {
namespace platform_gdb_server {
class PlatformRemoteGDBServer : public Platform, private UserIDResolver {
public:
static void Initialize();
static void Terminate();
static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
static ConstString GetPluginNameStatic();
static const char *GetDescriptionStatic();
PlatformRemoteGDBServer();
~PlatformRemoteGDBServer() override;
// lldb_private::PluginInterface functions
ConstString GetPluginName() override { return GetPluginNameStatic(); }
uint32_t GetPluginVersion() override { return 1; }
// lldb_private::Platform functions
Status
ResolveExecutable(const ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr) override;
bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
ModuleSpec &module_spec) override;
const char *GetDescription() override;
Status GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid_ptr,
FileSpec &local_file) override;
bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info) override;
uint32_t FindProcesses(const ProcessInstanceInfoMatch &match_info,
ProcessInstanceInfoList &process_infos) override;
Status LaunchProcess(ProcessLaunchInfo &launch_info) override;
Status KillProcess(const lldb::pid_t pid) override;
lldb::ProcessSP DebugProcess(ProcessLaunchInfo &launch_info,
Debugger &debugger,
Target *target, // Can be NULL, if NULL create a
// new target, else use existing
// one
Status &error) override;
lldb::ProcessSP Attach(ProcessAttachInfo &attach_info, Debugger &debugger,
Target *target, // Can be NULL, if NULL create a new
// target, else use existing one
Status &error) override;
bool GetSupportedArchitectureAtIndex(uint32_t idx, ArchSpec &arch) override;
size_t GetSoftwareBreakpointTrapOpcode(Target &target,
BreakpointSite *bp_site) override;
bool GetRemoteOSVersion() override;
bool GetRemoteOSBuildString(std::string &s) override;
bool GetRemoteOSKernelDescription(std::string &s) override;
// Remote Platform subclasses need to override this function
ArchSpec GetRemoteSystemArchitecture() override;
FileSpec GetRemoteWorkingDirectory() override;
bool SetRemoteWorkingDirectory(const FileSpec &working_dir) override;
// Remote subclasses should override this and return a valid instance
// name if connected.
const char *GetHostname() override;
UserIDResolver &GetUserIDResolver() override { return *this; }
bool IsConnected() const override;
Status ConnectRemote(Args &args) override;
Status DisconnectRemote() override;
Status MakeDirectory(const FileSpec &file_spec,
uint32_t file_permissions) override;
Status GetFilePermissions(const FileSpec &file_spec,
uint32_t &file_permissions) override;
Status SetFilePermissions(const FileSpec &file_spec,
uint32_t file_permissions) override;
lldb::user_id_t OpenFile(const FileSpec &file_spec, File::OpenOptions flags,
uint32_t mode, Status &error) override;
bool CloseFile(lldb::user_id_t fd, Status &error) override;
uint64_t ReadFile(lldb::user_id_t fd, uint64_t offset, void *data_ptr,
uint64_t len, Status &error) override;
uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset, const void *data,
uint64_t len, Status &error) override;
lldb::user_id_t GetFileSize(const FileSpec &file_spec) override;
Status PutFile(const FileSpec &source, const FileSpec &destination,
uint32_t uid = UINT32_MAX, uint32_t gid = UINT32_MAX) override;
Status CreateSymlink(const FileSpec &src, const FileSpec &dst) override;
bool GetFileExists(const FileSpec &file_spec) override;
Status Unlink(const FileSpec &path) override;
Status RunShellCommand(
const char *command, // Shouldn't be NULL
const FileSpec &working_dir, // Pass empty FileSpec 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
const lldb_private::Timeout<std::micro> &timeout) override;
void CalculateTrapHandlerSymbolNames() override;
const lldb::UnixSignalsSP &GetRemoteUnixSignals() override;
lldb::ProcessSP ConnectProcess(llvm::StringRef connect_url,
llvm::StringRef plugin_name,
lldb_private::Debugger &debugger,
lldb_private::Target *target,
lldb_private::Status &error) override;
size_t ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
lldb_private::Status &error) override;
virtual size_t
GetPendingGdbServerList(std::vector<std::string> &connection_urls);
protected:
process_gdb_remote::GDBRemoteCommunicationClient m_gdb_client;
process_gdb_remote::GDBRemoteCommunicationReplayServer m_gdb_replay_server;
std::string m_platform_description; // After we connect we can get a more
// complete description of what we are
// connected to
std::string m_platform_scheme;
std::string m_platform_hostname;
lldb::UnixSignalsSP m_remote_signals_sp;
// Launch the debug server on the remote host - caller connects to launched
// debug server using connect_url.
// Subclasses should override this method if they want to do extra actions
// before or
// after launching the debug server.
virtual bool LaunchGDBServer(lldb::pid_t &pid, std::string &connect_url);
virtual bool KillSpawnedProcess(lldb::pid_t pid);
virtual std::string MakeUrl(const char *scheme, const char *hostname,
uint16_t port, const char *path);
private:
std::string MakeGdbServerUrl(const std::string &platform_scheme,
const std::string &platform_hostname,
uint16_t port, const char *socket_name);
llvm::Optional<std::string> DoGetUserName(UserIDResolver::id_t uid) override;
llvm::Optional<std::string> DoGetGroupName(UserIDResolver::id_t uid) override;
PlatformRemoteGDBServer(const PlatformRemoteGDBServer &) = delete;
const PlatformRemoteGDBServer &
operator=(const PlatformRemoteGDBServer &) = delete;
};
} // namespace platform_gdb_server
} // namespace lldb_private
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_GDB_SERVER_PLATFORMREMOTEGDBSERVER_H
|
