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 <jni.h>
21  #include <stdint.h>
22  #include <sys/socket.h>
23  #include <sys/un.h>
24  
25  #include <limits>
26  #include <memory>
27  #include <string>
28  #include <vector>
29  
30  #include "adbconnection/client.h"
31  #include "base/array_ref.h"
32  #include "base/mutex.h"
33  #include "runtime_callbacks.h"
34  
35  namespace adbconnection {
36  
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  struct AdbConnectionAppInfoCallback : public art::AppInfoCallback {
AdbConnectionAppInfoCallbackAdbConnectionAppInfoCallback74    explicit AdbConnectionAppInfoCallback(AdbConnectionState* connection) : connection_(connection) {}
75  
76    void AddApplication(const std::string& package_name) REQUIRES_SHARED(art::Locks::mutator_lock_);
77    void RemoveApplication(const std::string& package_name)
78        REQUIRES_SHARED(art::Locks::mutator_lock_);
79    void SetCurrentProcessName(const std::string& process_name)
80        REQUIRES_SHARED(art::Locks::mutator_lock_);
81    void SetWaitingForDebugger(bool waiting) REQUIRES_SHARED(art::Locks::mutator_lock_);
82    void SetUserId(int uid) REQUIRES_SHARED(art::Locks::mutator_lock_);
83  
84   private:
85    AdbConnectionState* connection_;
86  };
87  
88  class AdbConnectionState {
89   public:
90    explicit AdbConnectionState(const std::string& name);
91    ~AdbConnectionState();
92  
93    // Called on the listening thread to start dealing with new input. thr is used to attach the new
94    // thread to the runtime.
95    void RunPollLoop(art::Thread* self);
96  
97    // Sends ddms data over the socket, if there is one. This data is sent even if we haven't finished
98    // hand-shaking yet.
99    void PublishDdmData(uint32_t type, const art::ArrayRef<const uint8_t>& data);
100  
101    // Wake up the poll. Call this if the set of interesting event has changed. They will be
102    // recalculated and poll will be called again via fdevent write. This wakeup  relies on fdevent
103    // and should be ACKed via AcknowledgeWakeup.
104    void WakeupPollLoop();
105  
106    // After a call to WakeupPollLoop, the fdevent internal counter should be decreased via
107    // this method. This should be called after WakeupPollLoop was called and poll triggered.
108    void AcknowledgeWakeup();
109  
110    // Stops debugger threads during shutdown.
111    void StopDebuggerThreads();
112  
113    // If StartDebuggerThreads was called successfully.
DebuggerThreadsStarted()114    bool DebuggerThreadsStarted() {
115      return started_debugger_threads_;
116    }
117  
118    // Should be called by Framework when it changes its process name.
119    void SetCurrentProcessName(const std::string& process_name);
120  
121    // Should be called by Framework when it adds an app to a process.
122    // This can be called several times (see android:process)
123    void AddApplication(const std::string& package_name);
124  
125    // Should be called by Framework when it removes an app from a process.
126    void RemoveApplication(const std::string& package_name);
127  
128    // Should be called by Framework when its debugging state changes.
129    void SetWaitingForDebugger(bool waiting);
130  
131    // Should be called by Framework when the UserID is known.
132    void SetUserId(int uid);
133  
134   private:
135    uint32_t NextDdmId();
136  
137    void StartDebuggerThreads();
138  
139    // Tell adbd about the new runtime.
140    bool SetupAdbConnection();
141  
142    std::string MakeAgentArg();
143  
144    void SendAgentFds(bool require_handshake);
145  
146    void CloseFds();
147  
148    void HandleDataWithoutAgent(art::Thread* self);
149  
150    void PerformHandshake();
151  
152    void AttachJdwpAgent(art::Thread* self);
153  
154    void NotifyDdms(bool active);
155  
156    void SendDdmPacket(uint32_t id,
157                       DdmPacketType type,
158                       uint32_t ddm_type,
159                       art::ArrayRef<const uint8_t> data);
160  
161    std::string agent_name_;
162  
163    AdbConnectionDebuggerController controller_;
164    AdbConnectionDdmCallback ddm_callback_;
165    AdbConnectionAppInfoCallback appinfo_callback_;
166  
167    // Eventfd used to allow the StopDebuggerThreads function to wake up sleeping threads
168    android::base::unique_fd sleep_event_fd_;
169  
170    // Context which wraps the socket which we use to talk to adbd.
171    std::unique_ptr<AdbConnectionClientContext, void(*)(AdbConnectionClientContext*)> control_ctx_;
172  
173    // Socket that we use to talk to the agent (if it's loaded).
174    android::base::unique_fd local_agent_control_sock_;
175  
176    // The fd of the socket the agent uses to talk to us. We need to keep it around in order to clean
177    // it up when the runtime goes away.
178    android::base::unique_fd remote_agent_control_sock_;
179  
180    // The fd that is forwarded through adb to the client. This is guarded by the
181    // adb_write_event_fd_.
182    android::base::unique_fd adb_connection_socket_;
183  
184    // The fd we send to the agent to let us synchronize access to the shared adb_connection_socket_.
185    // This is also used as a general lock for the adb_connection_socket_ on any threads other than
186    // the poll thread.
187    android::base::unique_fd adb_write_event_fd_;
188  
189    std::atomic<bool> shutting_down_;
190  
191    // True if we have loaded the agent library.
192    std::atomic<bool> agent_loaded_;
193  
194    // True if the dt_fd_forward transport is listening for a new communication channel.
195    std::atomic<bool> agent_listening_;
196  
197    // True if the dt_fd_forward transport has the socket. If so we don't do anything to the agent or
198    // the adb connection socket until connection goes away.
199    std::atomic<bool> agent_has_socket_;
200  
201    std::atomic<bool> sent_agent_fds_;
202  
203    std::atomic<bool> performed_handshake_;
204  
205    bool notified_ddm_active_;
206  
207    std::atomic<uint32_t> next_ddm_id_;
208  
209    bool started_debugger_threads_;
210  
211    friend struct AdbConnectionDebuggerController;
212  };
213  
214  }  // namespace adbconnection
215  
216  #endif  // ART_ADBCONNECTION_ADBCONNECTION_H_
217