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