Merge sp/adbd-tcp-off into sprint [skip ci]

Brings in luckfox board patch 0015, which removes the adbd TCP listeners
on port 5555 and on 127.0.0.1:5037, plus the fail-closed adbd build rule
and the regression tests for both. Sprint had no commits past the branch
base, so the merge tree equals the branch tip.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPu4qHGnopkHjchmwz
This commit is contained in:
BFE Engineering
2026-11-09 14:44:51 -06:00
co-authored by Claude Haiku 5.5
4 changed files with 573 additions and 2 deletions
+43 -2
View File
@@ -60,6 +60,7 @@ luckfox-sdk-patches/wifi/patches/ diffs against sysdrv/drv_ko/wifi/ (out-of-
luckfox-sdk-patches/board/patches/ diffs against project/ and sysdrv/ build files (board .mk,
build drivers, Makefiles, init overlays); may delete files
luckfox-sdk-patches/buildroot/ our delta on the Buildroot tree (see "Buildroot" below)
luckfox-sdk-patches/tests/ regression tests for the series (see "Regression tests")
```
Paths inside each patch are relative to the vendor SDK root, so apply with
@@ -102,6 +103,24 @@ tree alone. flare-edge's `tools/build-firmware.sh` runs it right after
applying the patches, then stages `buildroot/files/` and applies
`buildroot/patches/` onto the tree (issue #4).
## Regression tests
`tests/test-adbd-no-tcp.sh BASE_DIR PATCH_FILE|none` applies the board patch to
a copy of the base tree and runs the android-tools rule of the Makefile under
make. It checks the adbd TCP listener removal (flare-edge#3129), the rule's
fail-closed behaviour (bfe-core1106-sdk#45) and the adbd rebuild gate as the
Makefile evaluates it (bfe-core1106-sdk#44, #46). `BASE_DIR` is the luckfox base
commit 824b817f8, `sysdrv/tools/board/android-tools` only:
git -C <luckfox-sdk> archive 824b817f8 sysdrv/tools/board/android-tools | tar -C BASE_DIR -xf -
sh tests/test-adbd-no-tcp.sh BASE_DIR board/patches/0015-adbd-no-tcp-listener.patch
sh tests/adbd-no-tcp-cases.sh BASE_DIR board/patches/0015-adbd-no-tcp-listener.patch
The toolchain is a stub: the compiler stub only creates its output file, so
nothing is compiled. Run the test with `none` as the patch file to see the base
fail. `adbd-no-tcp-cases.sh` runs the real patch (must pass), the unpatched base
and three mutants of the patch (each must fail for the reason it names).
## Completeness check
flare-edge's `tools/verify-sdk-patches.sh` replays this series onto the vendor
@@ -123,7 +142,7 @@ had to be fixed before it did. Each was measured on hardware, not inferred.
|---|---|
| `rockchip_display.c` | `malloc` -> `calloc`. `enabled_at_spl` is only ever assigned under `#ifdef CONFIG_SPL_BUILD`, so in U-Boot proper it read uninitialised heap. Garbage read as truthy meant `display_enable()` skipped the connector pre-enable/enable path -- the only path that reaches `backlight_enable()`. |
| `pwm_backlight.c` | `args.args[2] & 1`. The DT has `pwms = <&pwm1 0 100000 50000>`; assigning `50000` to a `bool` polarity field inverted the PWM. Measured `DUTY=0x26e8` (99.6%) with `CTRL=0x13`; after the fix `CTRL=0x0b`. The backlight was running at 0.4%. |
| `clk_rv1106.c` | Two bugs. `rv1106_clk_set_rate()` returned a stale `ret` instead of the computed `rate`, so it always reported 0 Hz. And `DCLK_VOP_DIV_MASK` is 5 bits (max ÷32) while `DIV_ROUND_UP(1188 MHz, 30 MHz) = 40` wrote 39, truncated to 7 -- **the VOP was running at 125 MHz, not 30**. Now clamps to 32, picks the closest parent, and retunes CPLL 1000 -> 960 MHz when neither divides evenly, giving exactly 30.000 MHz. |
| `clk_rv1106.c` | Two bugs. `rv1106_clk_set_rate()` returned a stale `ret` instead of the computed `rate`, so it always reported 0 Hz. And `DCLK_VOP_DIV_MASK` is 5 bits (max /32) while `DIV_ROUND_UP(1188 MHz, 30 MHz) = 40` wrote 39, truncated to 7 -- **the VOP was running at 125 MHz, not 30**. Now clamps to 32, picks the closest parent, and retunes CPLL 1000 -> 960 MHz when neither divides evenly, giving exactly 30.000 MHz. |
| `rockchip_panel.c` | `FLARE_PANEL_SETTLE_MS`: wait after scanout starts before switching the backlight on. See the comment in the file -- it distinguishes two artefacts that look similar and have different causes. |
| `board.c` | Release `RGB_RES` (GPIO0_A1) at the top of `board_init()` instead of `board_late_init()`, and `FLARE_TRACE` instrumentation. `setup_download_mode()` is deliberately kept **first** in `board_late_init()`: moving the logo ahead of it pushed BOOT-key sampling from 1.18 s to ~4-5 s and the key had to be held for eight seconds. |
| `rv1106-u-boot.dtsi` | `u-boot,spl-boot-order = <&emmc>`. It was `<&sdmmc, &spi_nor, &spi_nand, &emmc>` -- the only fitted medium was last. Walking the dead entries cost **267 ms** every boot: ~212 ms failing to identify a non-existent SPI-NAND (`unknown raw ID 0 0 0`) and ~57 ms probing an SD slot this board does not have (`sdmmc` is wired to the AIC8800 WiFi as SDIO). **This file is shared by every rv1106 U-Boot build in the tree**; an SD- or SPI-NAND-booting variant would no longer boot. |
@@ -294,6 +313,28 @@ had masked it (the reproducibility gap `tools/build-firmware.sh` exists to close
`sysdrv/source/uboot/u-boot/configs/` (it is a whole new file, not a diff);
the board `.mk` patch is what references it by name.
### `board/patches/0015-adbd-no-tcp-listener.patch` (flare-edge#3129)
Rockchip's android-tools patch `0015-make-adb-tcp-function-default-enbale.patch`
made `adb_main()` open TCP 5555 whenever USB is up, and the non-secure branch
opened `tcp:5037` on 127.0.0.1. S50usbdevice starts adbd with no arguments, so
every panel ran both (`0.0.0.0:5555` was reachable from the LAN). The patch
adds `android-tools-patches/0017-no-adb-tcp-listener.patch`, which removes both
calls from the device half of `adb_main()` and runs last in
`android-tools.patch.sh`. USB stays the only transport.
It also changes the Makefile gate. adbd was rebuilt only when `out/usr/bin/adbd`
was missing, so a patch-set change never reached an SDK tree that already held
the binary (bfe-core1106-sdk#44). `adbd-current.sh` now compares a stamp in
`out/.adbd-inputs` with a hash of the Makefile, the gate script and the patch
set, and the build writes that stamp.
The rule now stops at the first failed step (a debian series entry, an
`android-tools.patch.sh` step run with `-e`, the build, or the copy into
`out/usr/bin`), and the stamp is written last. A failed step therefore never
leaves a stamp for an adbd that was not built from the patch set
(bfe-core1106-sdk#45).
### `board/patches/0009` to `0013` (issue #4)
Deltas that lived only in the workstation SDK until issue #4. Each patch
@@ -322,7 +363,7 @@ already carries 0004 and 0008.
| fragment | why |
|---|---|
| `uboot/flare-display.config` | the DRM/panel/PWM symbols the logo path needs |
| `uboot/flare-verbose.config` | `CONFIG_BOOTSTAGE_PRINTF_TIMESTAMP=y` -- µs timestamps on every line. ~15 chars/line ~ 1.3 ms/line at 115200, so read instrumented timings as an upper bound |
| `uboot/flare-verbose.config` | `CONFIG_BOOTSTAGE_PRINTF_TIMESTAMP=y` -- us timestamps on every line. ~15 chars/line ~ 1.3 ms/line at 115200, so read instrumented timings as an upper bound |
| `uboot/flare-bootcount.config` | boot-failure fallback to `altbootcmd=download` -> MaskRom |
| `uboot/flare-spl-brom.config` | builds `spl_bootrom.o`; does *not* set `SPL_ROCKCHIP_BACK_TO_BROM`, which would flip `SPL_MMC_SUPPORT` off |
| `kernel/flare-backlight.config` | `CONFIG_BACKLIGHT_PWM=y`. As `=m` the backlight class device does not exist until userspace `insmod`s it at ~3.3-3.7 s, which is when the logo is being replaced anyway |
@@ -0,0 +1,158 @@
Drop adbd TCP listeners and rebuild on patch change
Rockchip's 0015 android-tools patch made adbd open TCP 5555 whenever USB is
up, and the non-secure branch also opened tcp:5037 on 127.0.0.1. S50usbdevice
starts adbd with no arguments, so every panel ran both listeners: 0.0.0.0:5555
(reachable from the LAN) and 127.0.0.1:5037. Found on bench panel 10.255.1.55
(flare-edge#3129).
This patch adds android-tools-patches/0017-no-adb-tcp-listener.patch, which
removes both calls from the device half of adb_main(), and applies it last in
android-tools.patch.sh. USB stays the only transport, so the USB adbd path is
unchanged.
It also closes a build gap (bfe-core1106-sdk#44). The Makefile rebuilt adbd
only when out/usr/bin/adbd was missing, so a patch-set change never reached an
image built on an SDK tree that already held the binary. The Makefile now
gates adbd on adbd-current.sh: the build writes a stamp holding a hash of the
Makefile, the gate script and the patch set, and a missing or stale stamp
rebuilds adbd.
The rule stops at the first failed step: a debian series entry, an
android-tools.patch.sh step (run with -e), the build, or the copy into
out/usr/bin. The stamp is written last, so no binary that was not built from
the patch set gets one (bfe-core1106-sdk#45).
Regression tests: luckfox-sdk-patches/tests/test-adbd-no-tcp.sh runs the rule
under make with stub toolchains. It checks the listeners, the fail-closed
cases, the stamp and the gate that the Makefile evaluates (bfe-core1106-sdk#46).
tests/adbd-no-tcp-cases.sh runs the real patch, the unpatched base and mutants
that must fail.
diff --git a/sysdrv/tools/board/android-tools/Makefile b/sysdrv/tools/board/android-tools/Makefile
index bb72255..889e983 100644
--- a/sysdrv/tools/board/android-tools/Makefile
+++ b/sysdrv/tools/board/android-tools/Makefile
@@ -23,6 +23,15 @@ PKG_TARBALL_DEBIAN := android-tools_4.2.2+git20130218-3ubuntu41.debian.tar.gz
PKG_BIN := out
PKG_INSTALL_BIN_DIR := $(CURRENT_DIR)/$(PKG_BIN)/usr/bin
+# flare-edge#3129: adbd is rebuilt whenever its inputs change. The stamp holds
+# the hash of this Makefile, adbd-current.sh and the android-tools patch set.
+# An adbd without a matching stamp (left in out/ by a build from other patches)
+# is built again from the regenerated source. Every step below stops the rule
+# when it fails, and the stamp is written last, so no binary that was not built
+# from the patch set gets one (bfe-core1106-sdk#45).
+ADBD_STAMP := $(CURRENT_DIR)/$(PKG_BIN)/.adbd-inputs
+ADBD_INPUTS := $(shell cat $(CURRENT_DIR)/Makefile $(CURRENT_DIR)/adbd-current.sh $(CURRENT_DIR)/$(PKG_PATCHES_ANDROID_TOOLS)/* | sha256sum | cut -d' ' -f1)
+
PKG_DEP_OPENSSL := $(CURRENT_DIR)/../toolkits/openssl
PKG_DEP_ZLIB := $(CURRENT_DIR)/../toolkits/zlib
@@ -36,7 +45,7 @@ PKG_CONF_OPTS += -mthumb -Wa,-mimplicit-it=thumb -mthumb-interwork
endif
all: dep-openssl
- @test -f $(PKG_INSTALL_BIN_DIR)/adbd || (\
+ @sh $(CURRENT_DIR)/adbd-current.sh $(PKG_INSTALL_BIN_DIR)/adbd $(ADBD_STAMP) $(ADBD_INPUTS) || (\
rm -rf $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS); \
tar -xf $(PKG_TARBALL_ANDROID_TOOLS); \
tar -xf $(PKG_TARBALL_DEBIAN) -C $(PKG_NAME_ANDROID_TOOLS); \
@@ -45,16 +54,17 @@ all: dep-openssl
pushd $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/; \
cp -af $(CURRENT_DIR)/$(PKG_PATCHES_ANDROID_TOOLS)/* ./; \
for item in `cat ./debian/patches/series`; do \
- patch -p1 < ./debian/patches/$$item; \
+ patch -p1 < ./debian/patches/$$item || exit 1; \
done; \
- $(SHELL) ./android-tools.patch.sh; \
+ $(SHELL) -e ./android-tools.patch.sh || exit 1; \
CC="$(SYSDRV_CROSS)-gcc" GCC="$(SYSDRV_CROSS)-gcc" CXX="$(SYSDRV_CROSS)-g++" CPP="$(SYSDRV_CROSS)-cpp" \
CFLAGS="$(PKG_CONF_OPTS)" CPPFLAGS="$(PKG_CONF_OPTS)" \
CXXFLAGS="$(PKG_CONF_OPTS)" LDFLAGS="$(PKG_CONF_OPTS) $(PKG_ADBD_BUILD_STATIC)" \
make -j$(SYSDRV_JOBS) -C $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/$(PKG_BIN) \
SRCDIR=$(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS) \
-f $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/debian/makefiles/adbd.mk 1>/dev/null || exit -1; \
- cp -f $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/$(PKG_BIN)/adbd $(PKG_INSTALL_BIN_DIR)/ ; \
+ cp -f $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/$(PKG_BIN)/adbd $(PKG_INSTALL_BIN_DIR)/ || exit 1; \
+ echo $(ADBD_INPUTS) > $(ADBD_STAMP) || exit 1; \
popd; )
$(SYSDRV_CROSS)-strip -s $(PKG_INSTALL_BIN_DIR)/adbd ;
@mkdir -p $(PKG_BIN)/etc/init.d;
diff --git a/sysdrv/tools/board/android-tools/adbd-current.sh b/sysdrv/tools/board/android-tools/adbd-current.sh
new file mode 100644
index 0000000..df4bd81
--- /dev/null
+++ b/sysdrv/tools/board/android-tools/adbd-current.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+# adbd-current.sh ADBD STAMP INPUTS
+# Exit 0 when the built adbd is current: it exists and its stamp holds the hash
+# of the inputs it was built from (see the stamp logic in the Makefile). Any
+# other state, including an adbd left by an older patch set, exits 1 so that
+# the Makefile regenerates the android-tools source and builds again.
+# flare-edge#3129, luckfox-sdk-patches/tests/test-adbd-no-tcp.sh.
+adbd=$1
+stamp=$2
+inputs=$3
+[ -f "$adbd" ] || exit 1
+[ -f "$stamp" ] || exit 1
+[ "$(cat "$stamp")" = "$inputs" ] || exit 1
+exit 0
diff --git a/sysdrv/tools/board/android-tools/android-tools-patches/0017-no-adb-tcp-listener.patch b/sysdrv/tools/board/android-tools/android-tools-patches/0017-no-adb-tcp-listener.patch
new file mode 100644
index 0000000..c487482
--- /dev/null
+++ b/sysdrv/tools/board/android-tools/android-tools-patches/0017-no-adb-tcp-listener.patch
@@ -0,0 +1,42 @@
+flare-edge#3129: no adbd TCP listener in the image
+
+Rockchip's 0015 patch made adb_main() open a TCP listener on 5555 whenever
+USB is up (local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT)). The non-secure
+branch also installs the tcp:5037 smartsocket listener, bound to 127.0.0.1.
+S50usbdevice starts adbd with no arguments, so both listeners were live on
+every panel: 0.0.0.0:5555 and 127.0.0.1:5037.
+
+This patch removes both calls. USB stays the only transport, so the USB adbd
+path (the shell over the gadget) is unchanged. The regression test is
+luckfox-sdk-patches/tests/test-adbd-no-tcp.sh.
+
+--- a/core/adbd/adb.c
++++ b/core/adbd/adb.c
+@@ -1298,13 +1298,9 @@
+ capset(&header, cap);
+
+ D("Local port disabled\n");
+- } else {
+- char local_name[30];
+- build_local_name(local_name, sizeof(local_name), server_port);
+- if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
+- exit(1);
+- }
+- }
++ }
++ /* flare-edge#3129: the non-secure branch installs no smartsocket listener
++ either (it was tcp:5037, bound to 127.0.0.1). adbd opens no TCP port. */
+
+ int usb = 0;
+ if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {
+@@ -1327,8 +1323,8 @@
+ //} else if (!usb)
+ if (usb) {
+ printf("Using USB\n");
+- // listen on default port
+- local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
++ // flare-edge#3129: the image opens no TCP listener. USB is the only
++ // transport; local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT) is not called.
+ }
+
+ D("adb_main(): pre init_jdwp()\n");
diff --git a/sysdrv/tools/board/android-tools/android-tools-patches/android-tools.patch.sh b/sysdrv/tools/board/android-tools/android-tools-patches/android-tools.patch.sh
index 2cb01e6..1a0470a 100755
--- a/sysdrv/tools/board/android-tools/android-tools-patches/android-tools.patch.sh
+++ b/sysdrv/tools/board/android-tools/android-tools-patches/android-tools.patch.sh
@@ -17,3 +17,4 @@ patch -p1 < 0014-Specify-login-shell-in-standard-way.patch
patch -p1 < 0015-make-adb-tcp-function-default-enbale.patch
patch -p1 < 0015-support-rsa-key-authentication.patch
patch -p1 < 0016-fix-static-link-dl-lll_unlock_wait_private.patch
+patch -p1 < 0017-no-adb-tcp-listener.patch
+100
View File
@@ -0,0 +1,100 @@
#!/bin/sh
# adbd-no-tcp-cases.sh BASE_DIR PATCH_FILE
#
# Runs test-adbd-no-tcp.sh on the real patch (must PASS), on the unpatched base
# (must FAIL), and on three mutants of the patch. Each mutant must FAIL, and its
# FAIL line must name the reason given here:
# gate-makefile-only ADBD_INPUTS hashes only the Makefile; the patch set and
# the gate script are dropped (bfe-core1106-sdk#46)
# no-fail-fast the rule ignores failed series, patch and copy steps,
# so a failed 0017 hunk still stamps adbd (bfe-core1106-sdk#45)
# copy-unchecked only the copy into out/usr/bin is unchecked, so a failed
# copy still writes the stamp (bfe-core1106-sdk#45)
# Usage and layout: see test-adbd-no-tcp.sh.
# Exit 0 when every case behaves as expected, 1 otherwise, 2 on usage.
set -u
LC_ALL=C
export LC_ALL
if [ $# -ne 2 ]; then
echo "usage: $0 BASE_DIR PATCH_FILE" >&2
exit 2
fi
HERE=$(cd "$(dirname "$0")" && pwd) || exit 2
TEST=$HERE/test-adbd-no-tcp.sh
BASE=$(cd "$1" && pwd) || exit 2
PATCH=$(cd "$(dirname "$2")" && pwd)/$(basename "$2") || exit 2
WORK=$(mktemp -d "${TMPDIR:-/tmp}/adbd-no-tcp-cases.XXXXXX") || exit 2
trap 'rm -rf "$WORK"' EXIT
fail=0
pass() { echo "PASS $1"; }
bad() { echo "FAIL $1"; fail=1; }
# mutant NAME: writes $WORK/NAME.patch from PATCH with the sed script
# $WORK/NAME.sed. Fails when the script changes nothing.
mutant() {
sed -f "$WORK/$1.sed" "$PATCH" > "$WORK/$1.patch" || return 1
if cmp -s "$PATCH" "$WORK/$1.patch"; then return 1; fi
return 0
}
# expect WANT LABEL PATCH [REASON]: runs the test on PATCH. The exit status must
# be WANT. For a FAIL case, REASON must appear in one of the FAIL lines.
expect() {
log=$WORK/run-$(echo "$2" | tr -c 'a-zA-Z0-9' '_').log
sh "$TEST" "$BASE" "$3" > "$log" 2>&1
rc=$?
if [ "$rc" != "$1" ]; then
bad "$2 (exit $rc, want $1)"
return
fi
if [ -n "${4:-}" ] && ! grep -q "^FAIL.*$4" "$log"; then
bad "$2 (exit $rc, no FAIL line names: $4)"
return
fi
pass "$2 (exit $rc)"
}
# The mutant scripts. Each edits only the Makefile hunk of the patch, or the
# gate line that carries ADBD_INPUTS.
cat > "$WORK/gate-makefile-only.sed" <<'SEDEOF'
s#^+ADBD_INPUTS := .*$#+ADBD_INPUTS := $(shell sha256sum $(CURRENT_DIR)/Makefile | cut -c1-64)#
SEDEOF
cat > "$WORK/no-fail-fast.sed" <<'SEDEOF'
/^diff --git a\/sysdrv\/tools\/board\/android-tools\/Makefile /,/^diff --git a\/sysdrv\/tools\/board\/android-tools\/adbd-current.sh /{
/^+/{
s/ || exit 1//
s/\$(SHELL) -e /$(SHELL) /
}
}
SEDEOF
cat > "$WORK/copy-unchecked.sed" <<'SEDEOF'
/^diff --git a\/sysdrv\/tools\/board\/android-tools\/Makefile /,/^diff --git a\/sysdrv\/tools\/board\/android-tools\/adbd-current.sh /{
/^+.*cp -f /s/ || exit 1//
}
SEDEOF
expect 0 "real patch" "$PATCH"
expect 1 "unpatched base" none
if mutant gate-makefile-only; then
expect 1 "mutant gate-makefile-only" "$WORK/gate-makefile-only.patch" "ADBD_INPUTS is"
else
bad "mutant gate-makefile-only does not change the patch"
fi
if mutant no-fail-fast; then
expect 1 "mutant no-fail-fast" "$WORK/no-fail-fast.patch" "stops before compile"
else
bad "mutant no-fail-fast does not change the patch"
fi
if mutant copy-unchecked; then
expect 1 "mutant copy-unchecked" "$WORK/copy-unchecked.patch" "copy into out/usr/bin"
else
bad "mutant copy-unchecked does not change the patch"
fi
if [ "$fail" = 0 ]; then
echo "RESULT PASS"
exit 0
fi
echo "RESULT FAIL"
exit 1
+272
View File
@@ -0,0 +1,272 @@
#!/bin/sh
# test-adbd-no-tcp.sh BASE_DIR PATCH_FILE|none
#
# Regression test for flare-edge#3129 (adbd listened on TCP 5555 and on
# 127.0.0.1:5037), bfe-core1106-sdk#44 (a change to the adbd patch set never
# reached the image), bfe-core1106-sdk#45 (a failed patch or copy step still
# stamped adbd current) and bfe-core1106-sdk#46 (the gate was tested by a copy
# of its formula instead of by the Makefile).
#
# BASE_DIR holds sysdrv/tools/board/android-tools at the luckfox base commit
# 824b817f8, as in the vendor checkout:
# git -C <luckfox-sdk> archive 824b817f8 sysdrv/tools/board/android-tools | tar -C BASE_DIR -xf -
# PATCH_FILE is luckfox-sdk-patches/board/patches/0015-adbd-no-tcp-listener.patch,
# or "none" to check the unpatched base, which must FAIL.
#
# The android-tools rule of the Makefile runs for real under make, with stub
# toolchains, so nothing is compiled: the compiler stub only creates its -o
# file. The fail-closed cases each break one step and check that the rule stops
# before the stamp is written. tests/adbd-no-tcp-cases.sh runs this test on the
# real patch, on the base and on mutants of the patch.
# Exit 0 PASS, 1 FAIL, 2 usage or missing input.
set -u
LC_ALL=C
export LC_ALL
fail=0
pass() { echo "PASS $1"; }
bad() { echo "FAIL $1"; fail=1; }
if [ $# -ne 2 ]; then
echo "usage: $0 BASE_DIR PATCH_FILE|none" >&2
exit 2
fi
BASE=$1
PATCH=$2
if [ ! -d "$BASE/sysdrv/tools/board/android-tools" ]; then
echo "no sysdrv/tools/board/android-tools under $BASE" >&2
exit 2
fi
BASE=$(cd "$BASE" && pwd) || exit 2
if [ "$PATCH" != none ]; then
[ -f "$PATCH" ] || { echo "no patch file $PATCH" >&2; exit 2; }
PATCH=$(cd "$(dirname "$PATCH")" && pwd)/$(basename "$PATCH")
fi
WORK=$(mktemp -d "${TMPDIR:-/tmp}/adbd-no-tcp.XXXXXX") || exit 2
trap 'rm -rf "$WORK"' EXIT
TREE=$WORK/tree
mkdir -p "$TREE/sysdrv/tools/board" || exit 2
cp -a "$BASE/sysdrv/tools/board/android-tools" "$TREE/sysdrv/tools/board/" || exit 2
AT=$TREE/sysdrv/tools/board/android-tools
# 1. The board patch applies to the base tree.
if [ "$PATCH" != none ]; then
if (cd "$TREE" && git apply --check "$PATCH" && git apply "$PATCH") 2>"$WORK/apply.err"; then
pass "board patch applies to the base tree"
else
bad "board patch does not apply to the base tree: $(head -3 "$WORK/apply.err")"
echo "RESULT FAIL"; exit 1
fi
fi
# Stub toolchain for the rule: the compiler (also CXX and CPP), strip, and the
# openssl and zlib sub-makes. The compiler stub logs each run to $STUB_LOG,
# creates its -o output, and fails when STUB_CC_FAIL is set.
STUB=$WORK/stub
mkdir -p "$STUB/dep" || exit 2
cat > "$STUB/cross-gcc" <<'STUBEOF'
#!/bin/sh
[ -n "${STUB_LOG:-}" ] && echo "cc $*" >> "$STUB_LOG"
[ -n "${STUB_CC_FAIL:-}" ] && { echo "stub compiler: forced failure" >&2; exit 1; }
out=
while [ $# -gt 0 ]; do
if [ "$1" = -o ]; then out=$2; shift; fi
shift
done
[ -n "$out" ] && : > "$out"
exit 0
STUBEOF
cp "$STUB/cross-gcc" "$STUB/cross-g++" || exit 2
cp "$STUB/cross-gcc" "$STUB/cross-cpp" || exit 2
printf '#!/bin/sh\nexit 0\n' > "$STUB/cross-strip" || exit 2
printf 'all:\n\t@true\n' > "$STUB/dep/Makefile" || exit 2
chmod 755 "$STUB/cross-gcc" "$STUB/cross-g++" "$STUB/cross-cpp" "$STUB/cross-strip" || exit 2
# run_make AT_DIR LOG: runs the rule of the Makefile in AT_DIR under make, with
# the stubs. Sets RC (make's exit status) and CC_RUNS (compiler runs).
run_make() {
rm -f "$2.cc"
(cd "$1" && STUB_LOG="$2.cc" make -f Makefile SYSDRV_PARAM=/dev/null \
SYSDRV_CROSS="$STUB/cross" SYSDRV_JOBS=1 \
PKG_DEP_OPENSSL="$STUB/dep" PKG_DEP_ZLIB="$STUB/dep" all) > "$2" 2>&1
RC=$?
CC_RUNS=0
if [ -s "$2.cc" ]; then CC_RUNS=$(wc -l < "$2.cc" | tr -d ' '); fi
}
# case_at NAME: a fresh copy of the patched android-tools tree; prints its path.
case_at() {
rm -rf "$WORK/case-$1"
mkdir -p "$WORK/case-$1/sysdrv/tools/board" || return 1
cp -a "$AT" "$WORK/case-$1/sysdrv/tools/board/" || return 1
echo "$WORK/case-$1/sysdrv/tools/board/android-tools"
}
# 2. The rule applies every debian series entry and every android-tools.patch.sh
# step, builds adbd, and writes the stamp.
GOOD=$(case_at good) || exit 2
run_make "$GOOD" "$WORK/good.log"
if [ "$RC" = 0 ] && [ "$CC_RUNS" -gt 0 ]; then
pass "rule applies the debian series and android-tools.patch.sh, then builds adbd"
else
bad "rule does not build adbd from the patch set (rc $RC, compiler runs $CC_RUNS): $(grep -m1 -E 'FAILED|No such|Error' "$WORK/good.log")"
fi
# 3. The device half of adb_main(), in the source the rule generated: the TCP
# listeners must be gone, and the USB transport must stay.
# Comments are stripped first: the source keeps commented-out calls, and a
# comment that names a call is not a call.
ADB=$GOOD/android-tools/core/adbd/adb.c
awk '
/^int adb_main\(/ { inmain = 1 }
inmain && /^}/ { exit }
inmain {
if (incom) { if (index($0, "*/")) incom = 0; next }
if (index($0, "/*")) { if (!index($0, "*/")) incom = 1; next }
line = $0
sub(/\/\/.*/, "", line)
if (line ~ /^#if ADB_HOST/) { host = 1; next }
if (host && line ~ /^#else/) { host = 0; dev = 1; next }
if (dev && line ~ /^#endif/) { dev = 0; next }
if (dev) print line
}' "$ADB" > "$WORK/device-main.txt" 2>/dev/null
if [ ! -s "$WORK/device-main.txt" ]; then
bad "could not extract the device half of adb_main()"
else
if grep -q 'local_init' "$WORK/device-main.txt"; then
bad "adb_main() device half still calls local_init (TCP 5555 listener)"
else
pass "adb_main() device half opens no TCP 5555 listener"
fi
if grep -q 'install_listener' "$WORK/device-main.txt"; then
bad "adb_main() device half still installs a smartsocket listener (tcp:5037)"
else
pass "adb_main() device half installs no smartsocket listener"
fi
for need in 'usb_init()' 'Using USB' 'init_jdwp()'; do
if grep -q "$need" "$WORK/device-main.txt"; then
pass "adb_main() device half keeps: $need"
else
bad "adb_main() device half lost the USB path: $need"
fi
done
fi
# 4. The gate, as the Makefile evaluates it: ADBD_INPUTS must be the sha256 of
# the Makefile, adbd-current.sh and the patch set, the three inputs that the
# stamp must match.
# shellcheck disable=SC2016 # the make text must reach make unexpanded
printf '%s\n' '$(info ADBD_INPUTS=$(ADBD_INPUTS))' > "$WORK/probe.mk" || exit 2
probe=$(cd "$GOOD" && make -s -f Makefile -f "$WORK/probe.mk" SYSDRV_PARAM=/dev/null no-such-target 2>/dev/null | sed -n 's/^ADBD_INPUTS=//p')
want=$(cd "$AT" && cat Makefile adbd-current.sh android-tools-patches/* 2>/dev/null | sha256sum | cut -d' ' -f1)
if [ -n "$probe" ] && [ "$probe" = "$want" ]; then
pass "ADBD_INPUTS is the sha256 of Makefile, adbd-current.sh and the patch set"
else
bad "ADBD_INPUTS is '$probe', want '$want' (sha256 of Makefile, adbd-current.sh and the patch set)"
fi
# 5. The rule itself: a matching stamp with adbd present skips the build, and a
# stale or missing stamp rebuilds it. The stamp must hold ADBD_INPUTS.
if [ -n "$probe" ] && [ "$(cat "$GOOD/out/.adbd-inputs" 2>/dev/null)" = "$probe" ]; then
pass "rule writes the stamp of its inputs after the build"
else
bad "rule did not write the stamp of its inputs after the build"
fi
run_make "$GOOD" "$WORK/skip.log"
if [ "$RC" = 0 ] && [ "$CC_RUNS" = 0 ] && [ -n "$probe" ] && [ "$(cat "$GOOD/out/.adbd-inputs" 2>/dev/null)" = "$probe" ]; then
pass "rule skips adbd when the stamp matches"
else
bad "rule did not skip adbd with a matching stamp (rc $RC, compiler runs $CC_RUNS)"
fi
echo "0000000000000000000000000000000000000000000000000000000000000000" > "$GOOD/out/.adbd-inputs" || exit 2
run_make "$GOOD" "$WORK/stale.log"
if [ "$RC" = 0 ] && [ "$CC_RUNS" -gt 0 ]; then
pass "rule rebuilds adbd when the stamp is stale"
else
bad "rule did not rebuild adbd with a stale stamp (rc $RC, compiler runs $CC_RUNS)"
fi
rm -f "$GOOD/out/.adbd-inputs"
run_make "$GOOD" "$WORK/nostamp.log"
if [ "$RC" = 0 ] && [ "$CC_RUNS" -gt 0 ]; then
pass "rule rebuilds adbd when there is no stamp"
else
bad "rule did not rebuild adbd without a stamp (rc $RC, compiler runs $CC_RUNS)"
fi
# 6. Fail closed. An injected failure must stop the rule with a non-zero status
# and leave no stamp. The failures before the compile step must also stop the
# rule before the compiler runs.
check_closed() { # AT_DIR LOG PRE LABEL
run_make "$1" "$2"
stamp=absent
[ -e "$1/out/.adbd-inputs" ] && stamp=written
if [ "$RC" != 0 ] && [ "$stamp" = absent ] && { [ "$3" != pre ] || [ "$CC_RUNS" = 0 ]; }; then
pass "$4"
else
bad "$4 (rc $RC, stamp $stamp, compiler runs $CC_RUNS): $(grep -m1 -E 'FAILED|No such|Error|forced|cannot|Is a directory' "$2")"
fi
}
inject_drift() { # AT_DIR: one removed line of the 0017 hunk stops matching
f=$1/android-tools-patches/0017-no-adb-tcp-listener.patch
[ -f "$f" ] || return 1
awk '{ if ($0 == "- build_local_name(local_name, sizeof(local_name), server_port);") $0 = $0 " /* drift */"; print }' "$f" > "$f.new" || return 1
grep -q 'drift' "$f.new" || return 1
mv "$f.new" "$f"
}
inject_middle() { # AT_DIR: a failing patch step ahead of the last step
f=$1/android-tools-patches/android-tools.patch.sh
[ -f "$f" ] || return 1
awk 'NR == 4 { print "patch -p1 < 0000-no-such-patch.patch" } { print }' "$f" > "$f.new" || return 1
mv "$f.new" "$f"
}
inject_series() { # AT_DIR: a debian series entry with no patch file behind it
t=$1/android-tools_4.2.2+git20130218-3ubuntu41.debian.tar.gz
d=$WORK/deb-series
rm -rf "$d" && mkdir -p "$d" || return 1
tar -xzf "$t" -C "$d" || return 1
printf '\nno-such-debian-patch.patch\n' >> "$d/debian/patches/series" || return 1
tar -czf "$t.new" -C "$d" debian || return 1
mv "$t.new" "$t"
}
D=$(case_at drift) || exit 2
if inject_drift "$D"; then
check_closed "$D" "$WORK/drift.log" pre "rule stops before compile when a 0017 hunk does not apply"
else
bad "could not inject a 0017 failure (no 0017 patch in the tree)"
fi
D=$(case_at middle) || exit 2
if inject_middle "$D"; then
check_closed "$D" "$WORK/middle.log" pre "rule stops before compile when a middle android-tools.patch.sh step fails"
else
bad "could not inject a failing android-tools.patch.sh step"
fi
D=$(case_at series) || exit 2
if inject_series "$D"; then
check_closed "$D" "$WORK/series.log" pre "rule stops before compile when a debian series entry does not apply"
else
bad "could not inject a failing debian series entry"
fi
D=$(case_at compile) || exit 2
export STUB_CC_FAIL=1
check_closed "$D" "$WORK/compile.log" any "rule stops and writes no stamp when the compiler fails"
unset STUB_CC_FAIL
D=$(case_at copy) || exit 2
mkdir -p "$D/out/usr/bin/adbd" || exit 2
check_closed "$D" "$WORK/copy.log" any "rule stops and writes no stamp when the copy into out/usr/bin fails"
# 7. The Makefile still parses (a parse error prints something other than
# "No rule to make target").
if (cd "$AT" && make -f Makefile SYSDRV_PARAM=/dev/null -n no-such-target 2>&1 | grep -q 'No rule to make target'); then
pass "Makefile parses"
else
bad "Makefile does not parse"
fi
if [ "$fail" = 0 ]; then
echo "RESULT PASS"
exit 0
fi
echo "RESULT FAIL"
exit 1