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 
34 namespace adbconnection {
35 
36 static constexpr char kJdwpControlName[] = "\0jdwp-control";
37 static constexpr char kAdbConnectionThreadName[] = "ADB-JDWP Connection Control Thread";
38 
39 // The default jdwp agent name.
40 static constexpr char kDefaultJdwpAgentName[] = "libjdwp.so";
41 
42 class AdbConnectionState;
43 
44 struct AdbConnectionDebuggerController : public art::DebuggerControlCallback {
AdbConnectionDebuggerControllerAdbConnectionDebuggerController45   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 
60 enum class DdmPacketType : uint8_t { kReply = 0x80, kCmd = 0x00, };
61 
62 struct AdbConnectionDdmCallback : public art::DdmCallback {
AdbConnectionDdmCallbackAdbConnectionDdmCallback63   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 
73 class 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.
DebuggerThreadsStarted()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