Gitiles
Code Review Sign In
LeafOS / LeafOS-Project / android_packages_modules_adb / 5675696dd81c3d4360320e7da32c8e0b413a13e0
commit5675696dd81c3d4360320e7da32c8e0b413a13e0[log] [tgz]
authorDiwas Sharma <sdiwas@google.com>Wed May 29 18:39:13 2024 +0000
committerDiwas Sharma <sdiwas@google.com>Wed May 29 18:46:43 2024 +0000
tree1978079931d614248ac1cdba29a7287f71048a7b
parentb286b39f41b8166be0face385aec594d62a3b53c [diff]
Add a dedicated Mainline Test Mapping group for ADBD.

Test of *all* Mainline modules are currently configured in a single
`mainline-presubmit` Test Mapping group. This requires that users indicate the
module to install in every entry and is quite tedious.

The above approach also adds overhead due to installing, checking for, and
uninstalling Mainline modules between test module executions. This eats up
precious presubmit time and gets runtimes close to violating the SLO.

This change moves all ADBD Mainline module tests into a dedicated
Test Mapping group that installs the Mainline module once before executing all
test modules. This also simplifies the configuration syntax by no longer
requiring brackets that indicate the, now implicit, Mainline module.

Bug: 328102821
Test: presubmit checks
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:e15bd89957c3767128cec5b57b7301e58aab9644)
Merged-In: I3d2ba57bf769413cfcc1e9f3431247cd686c549c
Change-Id: I3d2ba57bf769413cfcc1e9f3431247cd686c549c
1 file changed
tree: 1978079931d614248ac1cdba29a7287f71048a7b
  1. apex/
  2. client/
  3. coverage/
  4. crypto/
  5. daemon/
  6. docs/
  7. fastdeploy/
  8. fdevent/
  9. libs/
  10. pairing_auth/
  11. pairing_connection/
  12. proto/
  13. sysdeps/
  14. test_utils/
  15. tls/
  16. tools/
  17. .clang-format
  18. adb.bash
  19. adb.cpp
  20. adb.h
  21. adb_auth.h
  22. adb_integration_test_adb.xml
  23. adb_integration_test_device.xml
  24. adb_io.cpp
  25. adb_io.h
  26. adb_io_test.cpp
  27. adb_listeners.cpp
  28. adb_listeners.h
  29. adb_listeners_test.cpp
  30. adb_mdns.cpp
  31. adb_mdns.h
  32. adb_trace.cpp
  33. adb_trace.h
  34. adb_unique_fd.cpp
  35. adb_unique_fd.h
  36. adb_utils.cpp
  37. adb_utils.h
  38. adb_utils_test.cpp
  39. adb_wifi.h
  40. adbd_test.map
  41. adbd_test.xml
  42. Android.bp
  43. benchmark_device.py
  44. bugreport_test.cpp
  45. compression_utils.h
  46. file_sync_protocol.h
  47. mdns_test.cpp
  48. MODULE_LICENSE_APACHE2
  49. NOTICE
  50. OVERVIEW.TXT
  51. OWNERS
  52. PREUPLOAD.cfg
  53. protocol.txt
  54. README.md
  55. run-device-tests.sh
  56. security_log_tags.h
  57. services.cpp
  58. services.h
  59. SERVICES.TXT
  60. shell_protocol.h
  61. shell_service_protocol.cpp
  62. shell_service_protocol_test.cpp
  63. SOCKET-ACTIVATION.txt
  64. socket.h
  65. socket_spec.cpp
  66. socket_spec.h
  67. socket_spec_test.cpp
  68. socket_test.cpp
  69. sockets.cpp
  70. sockets.dia
  71. SYNC.TXT
  72. sysdeps.h
  73. sysdeps_test.cpp
  74. sysdeps_unix.cpp
  75. sysdeps_win32.cpp
  76. sysdeps_win32_test.cpp
  77. test_adb.py
  78. test_device.py
  79. TEST_MAPPING
  80. trace.sh
  81. transfer_id.h
  82. transport.cpp
  83. transport.h
  84. transport_benchmark.cpp
  85. transport_fd.cpp
  86. transport_test.cpp
  87. types.cpp
  88. types.h
  89. types_test.cpp
README.md

ADB Internals

If you are new to adb source code, you should start by reading OVERVIEW.TXT which describes the three components of adb pipeline.

This document is here to boost what can be achieved within a "window of naive interest". You will not find function or class documentation here but rather the "big picture" which should allow you to build a mental map to help navigate the code.

Three components of adb pipeline

As outlined in the overview, this codebase generates three components (Client, Server (a.k.a Host), and Daemon (a.k.a adbd)). The central part is the Server which runs on the Host computer. On one side the Server exposes a "Smart Socket" to Clients such as adb or DDMLIB. On the other side, the Server continuously monitors for connecting Daemons (as USB devices or TCP emulator). Communication with a device is done with a Transport.

+----------+              +------------------------+
|   ADB    +----------+   |      ADB SERVER        |                   +----------+
|  CLIENT  |          |   |                        |              (USB)|   ADBD   |
+----------+          |   |                     Transport+-------------+ (DEVICE) |
                      |   |                        |                   +----------+
+-----------          |   |                        |
|   ADB    |          v   +                        |                   +----------+
|  CLIENT  +--------->SmartSocket                  |              (USB)|   ADBD   |
+----------+          ^   | (TCP/IP)            Transport+-------------+ (DEVICE) |
                      |   |                        |                   +----------+
+----------+          |   |                        |
|  DDMLIB  |          |   |                     Transport+--+          +----------+
|  CLIENT  +----------+   |                        |        |  (TCP/IP)|   ADBD   |
+----------+              +------------------------+        +----------|(EMULATOR)|
                                                                       +----------+

The Client and the Server are contained in the same executable and both run on the Host machine. Code sections specific to the Host is enclosed within ADB_HOST guard. adbd runs on the Android Device. Daemon specific code is enclosed in !ADB_HOST but also sometimes with-in __ANDROID__ guard.

"SMART SOCKET" and TRANSPORT

A smart socket is a simple TCP socket with a smart protocol built on top of it. This is what Clients connect onto from the Host side. The Client must always initiate communication via a human readable request but the response format varies. The smart protocol is documented in SERVICES.TXT.

On the other side, the Server communicates with a device via a Transport. adb initially targeted devices connecting over USB, which is restricted to a fixed number of data streams. Therefore, adb multiplexes multiple byte streams over a single pipe via Transport. When devices connecting over other mechanisms (e.g. emulators over TCP) were introduced, the existing transport protocol was maintained.

THREADING MODEL and FDEVENT system

At the heart of both the Server and Daemon is a main thread running an fdevent loop, which is a platform-independent abstraction over poll/epoll/WSAPoll monitoring file descriptors events. Requests and services are usually served from the main thread but some service requests result in new threads being spawned.

To allow for operations to run on the Main thread, fdevent features a RunQueue combined with an interrupt fd to force polling to return.

+------------+    +-------------------------^
|  RUNQUEUE  |    |                         |
+------------+    |  POLLING (Main thread)  |
| Function<> |    |                         |
+------------+    |                         |
| Function<> |    ^-^-------^-------^------^^
+------------+      |       |       |       |
|    ...     |      |       |       |       |
+------------+      |       |       |       |
|            |      |       |       |       |
|============|      |       |       |       |
|Interrupt fd+------+  +----+  +----+  +----+
+------------+         fd      Socket  Pipe

ASOCKET, APACKET, and AMESSAGE

The asocket, apacket, and amessage constructs exist only to wrap data while it transits on a Transport. An asocket handles a stream of apackets. An apacket consists in a amessage header featuring a command (A_SYNC, A_OPEN, A_CLSE, A_WRTE, A_OKAY, ...) followed by a payload (find more documentation in protocol.txt. There is no A_READ command because an asocket is unidirectional. To model a bi-directional stream, asocket have a peer which go in the opposite direction.

An asocket features a buffer where the elemental unit is an apacket. If traffic is inbound, the buffer stores the apacket until it is consumed. If the traffic is oubound, the buffer stores apackets until they are sent down the wire (with A_WRTE commands).

+---------------------ASocket------------------------+
 |                                                   |
 | +----------------APacket Queue------------------+ |
 | |                                               | |
 | |            APacket     APacket     APacket    | |
 | |          +--------+  +--------+  +--------+   | |
 | |          |AMessage|  |AMessage|  |AMessage|   | |
 | |          +--------+  +--------+  +--------+   | |
 | |          |        |  |        |  |        |   | |
 | |  .....   |        |  |        |  |        |   | |
 | |          |  Data  |  |  Data  |  |  Data  |   | |
 | |          |        |  |        |  |        |   | |
 | |          |        |  |        |  |        |   | |
 | |          +--------+  +--------+  +--------+   | |
 | |                                               | |
 | +-----------------------------------------------+ |
 +---------------------------------------------------+

This system allows to multiplex data streams on an unique byte stream. Without entering too much into details, the amessage fields arg1 and arg2 are used alike in the TCP protocol where local and remote ports identify an unique stream. Note that unlike TCP which feature an "unacknowledged-send window", an apacket is sent only after the previous one has been confirmed to be received.

The two types of asocket (Remote and Local) differentiate between outbound and inbound traffic.

adbd <-> APPPLICATION communication

This pipeline is detailed in daemon/jdwp_service.cpp with ASCII drawings! The JDWP extension implemented by Dalvik/ART are documented in:

  • platform/dalvik/+/main/docs/debugmon.html
  • platform/dalvik/+/main/docs/debugger.html

Sync protocol

To transfer files and directories, ADB places a smart-socket in SYNC mode and then issues SYNC commands. The SYNC protocol is documented in SYNC.TXT.

Benchmark sample run for Pixel 8,USB

$ ./benchmark_device.py
sink 100MiB: 10 runs: median 27.00 MiB/s, mean 26.39 MiB/s, stddev: 1.11 MiB/s
source 100MiB: 10 runs: median 36.97 MiB/s, mean 37.05 MiB/s, stddev: 0.46 MiB/s
push 100MiB: 10 runs: median 331.96 MiB/s, mean 329.81 MiB/s, stddev: 14.67 MiB/s
pull 100MiB: 10 runs: median 34.55 MiB/s, mean 33.57 MiB/s, stddev: 2.54 MiB/s