1/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ART_ADBCONNECTION_ADBCONNECTION_H_
18#define ART_ADBCONNECTION_ADBCONNECTION_H_
19
20#include <stdint.h>
21#include <vector>
22#include <limits>
23
24#include "android-base/unique_fd.h"
25
26#include "base/mutex.h"
27#include "base/array_ref.h"
28#include "runtime_callbacks.h"
29
30#include <sys/socket.h>
31#include <sys/un.h>
32#include <jni.h>
33
34namespace adbconnection {
35
36static constexpr char kJdwpControlName[] = "\0jdwp-control";
37static constexpr char kAdbConnectionThreadName[] = "ADB-JDWP Connection Control Thread";
38
39// The default jdwp agent name.
40static constexpr char kDefaultJdwpAgentName[] = "libjdwp.so";
41
42class AdbConnectionState;
43
44struct AdbConnectionDebuggerController : public art::DebuggerControlCallback {
45  explicit AdbConnectionDebuggerController(AdbConnectionState* connection)
46      : connection_(connection) {}
47
48  // Begin running the debugger.
49  void StartDebugger() OVERRIDE;
50
51  // The debugger should begin shutting down since the runtime is ending.
52  void StopDebugger() OVERRIDE;
53
54  bool IsDebuggerConfigured() OVERRIDE;
55
56 private:
57  AdbConnectionState* connection_;
58};
59
60enum class DdmPacketType : uint8_t { kReply = 0x80, kCmd = 0x00, };
61
62struct AdbConnectionDdmCallback : public art::DdmCallback {
63  explicit AdbConnectionDdmCallback(AdbConnectionState* connection) : connection_(connection) {}
64
65  void DdmPublishChunk(uint32_t type,
66                       const art::ArrayRef<const uint8_t>& data)
67      REQUIRES_SHARED(art::Locks::mutator_lock_);
68
69 private:
70  AdbConnectionState* connection_;
71};
72
73class AdbConnectionState {
74 public:
75  explicit AdbConnectionState(const std::string& name);
76
77  // Called on the listening thread to start dealing with new input. thr is used to attach the new
78  // thread to the runtime.
79  void RunPollLoop(art::Thread* self);
80
81  // Sends ddms data over the socket, if there is one. This data is sent even if we haven't finished
82  // hand-shaking yet.
83  void PublishDdmData(uint32_t type, const art::ArrayRef<const uint8_t>& data);
84
85  // Stops debugger threads during shutdown.
86  void StopDebuggerThreads();
87
88  // If StartDebuggerThreads was called successfully.
89  bool DebuggerThreadsStarted() {
90    return started_debugger_threads_;
91  }
92
93 private:
94  uint32_t NextDdmId();
95
96  void StartDebuggerThreads();
97
98  // Tell adbd about the new runtime.
99  bool SetupAdbConnection();
100
101  std::string MakeAgentArg();
102
103  android::base::unique_fd ReadFdFromAdb();
104
105  void SendAgentFds(bool require_handshake);
106
107  void CloseFds();
108
109  void HandleDataWithoutAgent(art::Thread* self);
110
111  void PerformHandshake();
112
113  void AttachJdwpAgent(art::Thread* self);
114
115  void NotifyDdms(bool active);
116
117  void SendDdmPacket(uint32_t id,
118                     DdmPacketType type,
119                     uint32_t ddm_type,
120                     art::ArrayRef<const uint8_t> data);
121
122  std::string agent_name_;
123
124  AdbConnectionDebuggerController controller_;
125  AdbConnectionDdmCallback ddm_callback_;
126
127  // Eventfd used to allow the StopDebuggerThreads function to wake up sleeping threads
128  android::base::unique_fd sleep_event_fd_;
129
130  // Socket that we use to talk to adbd.
131  android::base::unique_fd control_sock_;
132
133  // Socket that we use to talk to the agent (if it's loaded).
134  android::base::unique_fd local_agent_control_sock_;
135
136  // The fd of the socket the agent uses to talk to us. We need to keep it around in order to clean
137  // it up when the runtime goes away.
138  android::base::unique_fd remote_agent_control_sock_;
139
140  // The fd that is forwarded through adb to the client. This is guarded by the
141  // adb_write_event_fd_.
142  android::base::unique_fd adb_connection_socket_;
143
144  // The fd we send to the agent to let us synchronize access to the shared adb_connection_socket_.
145  // This is also used as a general lock for the adb_connection_socket_ on any threads other than
146  // the poll thread.
147  android::base::unique_fd adb_write_event_fd_;
148
149  std::atomic<bool> shutting_down_;
150
151  // True if we have loaded the agent library.
152  std::atomic<bool> agent_loaded_;
153
154  // True if the dt_fd_forward transport is listening for a new communication channel.
155  std::atomic<bool> agent_listening_;
156
157  // True if the dt_fd_forward transport has the socket. If so we don't do anything to the agent or
158  // the adb connection socket until connection goes away.
159  std::atomic<bool> agent_has_socket_;
160
161  std::atomic<bool> sent_agent_fds_;
162
163  bool performed_handshake_;
164
165  bool notified_ddm_active_;
166
167  std::atomic<uint32_t> next_ddm_id_;
168
169  bool started_debugger_threads_;
170
171  socklen_t control_addr_len_;
172  union {
173    sockaddr_un controlAddrUn;
174    sockaddr controlAddrPlain;
175  } control_addr_;
176
177  friend struct AdbConnectionDebuggerController;
178};
179
180}  // namespace adbconnection
181
182#endif  // ART_ADBCONNECTION_ADBCONNECTION_H_
183