Skip to content

Android 15 emulator GNSS deadlock kills system_server during sample lifecycle tests #6

Open

Description

@biodranik

Upstream patch: Gerrit change 4445214, patch set 2. Commit 099258c2d4c8478f821f91ab4e5fbeb9585550b4, uploaded 2026-11-16 (CET).

Android 15's Ranchu GNSS HAL deadlocks with system_server during normal location callback cleanup in the sample lifecycle tests. The Android watchdog then kills system_server, interrupting instrumentation and making the offline sample's CI check fail.

This issue tracks the consumer CI impact and upstream reporting. Related PR: #5.

Evidence:

  • Run with full diagnostics, samples commit 11ffb6fca490b687379d6c09f42d4c481aaab33f.
  • sample-reports artifact: continuous logcat, raw XML/protobuf test results, per-test logs, ANR traces, and bugreport.zip. The artifact expires on 2027-01-13, so attach the diagnostic files directly to the upstream report.
  • Earlier run showed similar system-service loss while a different offline test was active, but did not retain enough diagnostics to prove its cause.

Builds, lint, and Kotlin style passed. Basic instrumentation (1 test) and routing instrumentation (4 tests) passed. The offline run was interrupted during OfflineSearchTest.stoppedSearchRejectsLateRegionAndPlaceCallbacks after 82.946 seconds; its XML failure contains no stack trace.

Environment:

Component Observed value
Host GitHub Actions, Ubuntu 26.04.1, KVM enabled
Emulator 37.2.13.0, build 16740729
Guest image system-images;android-35;default;x86_64
Guest fingerprint Android/sdk_phone64_x86_64/emu64x:15/AE3A.240806.019/12368160:userdebug/test-keys
Guest security patch 2024-09-05
AVD pixel_2, 2 CPU cores
Emulator flags -no-window -gpu swiftshader_indirect -no-snapshot -noaudio -no-boot-anim
SDK source organicmaps/organicmaps@e757eeaca3664767dceec1bf33214e04023a2342, locally published as 0.0.0-sdk-check
Java / AGP JDK 21 / AGP 9.4.1

Reproduction:

Use the pinned workflow configuration and source revisions above. With the SDK checkout at ../organicmaps, initialized submodules, JDK 21, and the matching x86_64 emulator running, run from the sample checkout:

(cd ../organicmaps/android && ./gradlew -Px86_64 -PsdkVersion=0.0.0-sdk-check publishSdkForChecks)
./gradlew --continue --info --stacktrace \
  -PsdkRepository=../organicmaps/android/build/sdk-check/repository \
  -PsdkVersion=0.0.0-sdk-check connectedSamples

The captured test repeatedly moves the activity between CREATED and RESUMED. The activity's background cleanup calls LocationHelper.stop(), which unregisters the GNSS status callback. The failure depends on concurrent satellite-status delivery. A standalone platform-only reproducer has now independently reproduced the same GNSS deadlock on ARM64 with the same Android 15 build; see the verification and complete source below. An isolated run of the SDK's individual test has not been verified.

Expected: foreground/background transitions remove and restore location subscriptions, and the test suite completes with Android system services available.

Actual: GNSS cleanup stalls, then the watchdog kills system_server. Subsequent DeadSystemException, missing package / activity services, and disconnected external storage are consequences of that system death.

Root cause:

The two ANR snapshots, taken at 11:11:03 and 11:11:54 UTC, show the same circular wait. These condensed excerpts preserve the essential evidence:

system_server PID 535, "android.fg", Java thread 13:
  GnssNative.native_stop_sv_status_collection
  GnssHal.stopSvStatusCollection
  GnssStatusProvider.unregisterWithService
  ListenerMultiplexer.updateService
  - locked <0x046ba39a>
  GnssListenerMultiplexer.onLocationPermissionsChanged

system_server, "binder:535_17":
  ListenerMultiplexer.deliverToListeners
  - waiting to lock <0x046ba39a> held by thread 13
  GnssStatusProvider.onReportSvStatus
  GnssNative.reportSvStatus

/vendor/bin/hw/android.hardware.gnss-service.ranchu, PID 931:
  thread 944:
    std::mutex::lock
    Gnss::stopSvStatus
  thread 2964:
    IPCThreadState::transact
    BpGnssCallback::gnssSvStatusCb
    Gnss::onGnssSvStatusCb

11:12:01.211 Watchdog:
  WATCHDOG KILLING SYSTEM PROCESS:
  Blocked in handler on foreground thread (android.fg) for 66s

The Android 15 Ranchu implementation takes mMtx in stopSvStatus() and holds that same mutex while onGnssSvStatusCb() makes synchronous Binder callbacks. Thus the framework listener lock waits for the HAL mutex, while the HAL callback waits for the framework listener lock. Inspection on 2026-11-14 found the same pattern in AOSP main.

Organic Maps reaches this through the documented callback-removal API. The observed lock cycle is in the Android framework and emulator HAL. The sample's lifecycle cleanup should be preserved.

The upstream correction is under review as AOSP Gerrit change 4445214, patch set 2. It dispatches foreground GNSS status/data callbacks through a serial worker outside the GNSS state mutex and hardware-reader thread, following AOSP's Binder deadlock guidance. Patch set 2 also bounds pending work, preserves accepted session status order, and cancels pending reports on stream stop, close, or recipient replacement. Extension measurement/batching callback locking is separate and remains unresolved, as detailed below. Patch set 2 contains all reviewed fixes and the fairness correction validated on the affected ARM64 image. No fixed published system-image revision or patched x86_64 CI image has been verified.

Upstream reporting recommendation:

  • File under Emulator or System Images using the official issue form, following the Android emulator reporting instructions.
  • Suggested title: Ranchu GNSS stopSvStatus / satellite-status callback deadlock kills system_server on Android 15.
  • Include this issue, the exact environment above, the observed/full-suite reproduction, expected/actual behavior, and the lock-cycle excerpts. Search for existing reports using ranchu GNSS stopSvStatus deadlock and native_stop_sv_status_collection watchdog.
  • Attach the full app/build/ci-diagnostics/bugreport.zip, logcat.txt, both files in anr/, the failed test's per-test logcat, and raw XML results. Preserve these attachments upstream rather than relying solely on the expiring Actions artifact.
  • For a fresh reproduction, also record emulator -version, sdkmanager --list_installed, host CPU details, and the AVD config.ini. Record any latest-image retest separately; a newer API level or host-emulator version is not yet a verified fix.
  • Use the independently verified standalone source and lifecycle loop below for the upstream reproducer. Standalone x86_64 verification remains pending; the original SDK sample failure was captured on x86_64 in CI.

Follow-up:

  • File/link the upstream emulator report and preserve its diagnostic attachments.
  • Verify a standalone GNSS start/stop reproducer on ARM64 with the same Android 15 build.
  • Verify a fixed or unaffected guest image with repeated location/lifecycle cycles and the full connectedSamples suite; record and enforce the chosen image revision/fingerprint in CI.
  • Retain the location cleanup, lifecycle coverage, and failure diagnostics while resolving the CI issue.

Standalone reproducer verified on 2026-11-14

An independent app using only public Android APIs reproduced the failure. It contains exactly three DEX classes (MainActivity and its two anonymous callbacks), with no Organic Maps, AndroidX, instrumentation framework, or native library. The signed APK is approximately 12 KB.

  • Host: macOS 27.2.1 (26B131), ARM64.
  • Emulator: 37.2.13.0, build 16740729; fresh isolated pixel_2 AVD, 2 cores, the emulator flags listed above.
  • Image: system-images;android-35;default;arm64-v8a, revision 2.
  • Fingerprint: Android/sdk_phone64_arm64/emu64a:15/AE3A.240806.019/12368160:userdebug/test-keys.
  • The app completed 80 GNSS start/stop sessions. Session 81 logged STOP_BEGIN and never logged STOP_DONE.
  • At 20:35:04, the watchdog killed system_server (PID 526), reporting Blocked in handler on foreground thread (android.fg) for 66s.
  • Two ANR snapshots, anr_2026-11-14-20-34-07-306 and anr_2026-11-14-20-34-58-532, show android.fg holding listener lock 0x096e76b6 while waiting for GnssNative.native_stop_sv_status_collection; the satellite-status delivery thread waits for that same listener lock. Ranchu's Gnss::stopSvStatus() waits for its mutex while Gnss::onGnssSvStatusCb() waits on its synchronous Binder callback.
  • This run entered the listener update through onAppForegroundChanged; CI entered through onLocationPermissionsChanged. The native calls, circular lock dependency, and watchdog outcome match.
  • The complete run, including diagnostic collection, took 164 seconds. The host driver issued 200 cycles, but application progress stopped at session 81; host-loop counts are not completed lifecycle counts.
  • Verified APK SHA-256: e9659846c1eb6acfc23a7616e52d1e0e3fa07d1ad0e23c7f3e8eb0513ca733f4.
  • Application source SHA-256: 51350c2c934f6cb175cafc6192c7014838eff06838da879c6fd0f0d6476271f4.

The source, verified APK, full logcat, both ANR snapshots, and complete Android bug report have been collected together for upstream attachment. This standalone run verifies ARM64; the original CI image was x86_64. Failure timing is race-dependent.

Complete standalone app and build script

Save these three files in an empty directory. The build uses Android SDK tools directly and downloads no dependencies. Set ANDROID_HOME to an SDK containing platform 35 and build-tools 37.0.0, and JAVA_HOME to JDK 21.

AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="org.example.gnssrepro" android:versionCode="1" android:versionName="1.0">
    <uses-sdk android:minSdkVersion="30" android:targetSdkVersion="35" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <application android:label="GNSS deadlock reproducer"
        android:theme="@android:style/Theme.Material.Light.NoActionBar">
        <activity android:name=".MainActivity" android:exported="true" android:launchMode="singleTask">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

src/org/example/gnssrepro/MainActivity.java

package org.example.gnssrepro;

import android.Manifest;
import android.app.Activity;
import android.content.pm.PackageManager;
import android.location.GnssStatus;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

/** Platform APIs only: register GNSS in the foreground, remove it on stop. */
public final class MainActivity extends Activity {
    private static final String TAG = "GnssRepro";
    private LocationManager manager;
    private boolean active;
    private int sessions;
    private int satelliteCallbacks;
    private final LocationListener locations = new LocationListener() {
        @Override public void onLocationChanged(Location location) {}
    };
    private final GnssStatus.Callback satellites = new GnssStatus.Callback() {
        @Override public void onSatelliteStatusChanged(GnssStatus status) {
            satelliteCallbacks++;
            if (satelliteCallbacks == 1 || satelliteCallbacks % 20 == 0) {
                Log.i(TAG, "SV_CALLBACK count=" + satelliteCallbacks + " satellites=" + status.getSatelliteCount());
            }
        }
    };

    @Override public void onCreate(Bundle state) {
        super.onCreate(state);
        manager = getSystemService(LocationManager.class);
        TextView text = new TextView(this);
        text.setText("GNSS lifecycle reproducer\nPlatform Android APIs only.\n"
                + "The host runner repeatedly backgrounds and resumes this activity.");
        setContentView(text);
    }

    @Override public void onResume() {
        super.onResume();
        if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            Log.e(TAG, "Fine location permission missing; install the APK with adb install -g.");
            return;
        }
        if (active) return;
        active = true;
        sessions++;
        Log.i(TAG, "START_BEGIN session=" + sessions);
        manager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0L, 0f, locations, getMainLooper());
        boolean registered = manager.registerGnssStatusCallback(getMainExecutor(), satellites);
        Log.i(TAG, "START_DONE session=" + sessions + " registered=" + registered);
    }

    @Override public void onStop() {
        super.onStop();
        if (!active) return;
        Log.i(TAG, "STOP_BEGIN session=" + sessions);
        manager.removeUpdates(locations);
        manager.unregisterGnssStatusCallback(satellites);
        active = false;
        Log.i(TAG, "STOP_DONE session=" + sessions);
    }
}

build.py

#!/usr/bin/env python3
"""Build a dependency-free APK with Android SDK build tools and a JDK."""
import os
from pathlib import Path
import subprocess
import zipfile

root = Path(__file__).resolve().parent
sdk = Path(os.environ["ANDROID_HOME"])
java = Path(os.environ["JAVA_HOME"]) / "bin"
tools = sdk / "build-tools" / os.environ.get("BUILD_TOOLS_VERSION", "37.0.0")
android = sdk / "platforms/android-35/android.jar"
build = root / "build"
(build / "classes").mkdir(parents=True, exist_ok=True)
(build / "dex").mkdir(exist_ok=True)

def run(*args):
    subprocess.run([str(arg) for arg in args], check=True, cwd=root)

run(tools / "aapt2", "link", "-o", build / "unsigned.apk", "-I", android,
    "--manifest", root / "AndroidManifest.xml")
run(java / "javac", "-source", "8", "-target", "8", "-Xlint:-options", "-bootclasspath", android,
    "-d", build / "classes", *sorted((root / "src").rglob("*.java")))
run(tools / "d8", "--min-api", "30", "--lib", android, "--output", build / "dex",
    *sorted((build / "classes").rglob("*.class")))
with zipfile.ZipFile(build / "unsigned.apk", "a") as apk:
    apk.write(build / "dex/classes.dex", "classes.dex")
run(tools / "zipalign", "-f", "4", build / "unsigned.apk", build / "aligned.apk")
if not (build / "debug.jks").exists():
    run(java / "keytool", "-genkeypair", "-keystore", build / "debug.jks", "-storepass", "android",
        "-keypass", "android", "-alias", "repro", "-dname", "CN=GNSS Reproducer", "-keyalg", "RSA",
        "-keysize", "2048", "-validity", "3650")
run(tools / "apksigner", "sign", "--ks", build / "debug.jks", "--ks-pass", "pass:android",
    "--out", build / "gnss-repro.apk", build / "aligned.apk")
run(tools / "apksigner", "verify", build / "gnss-repro.apk")
print(build / "gnss-repro.apk")

Build and install on a dedicated emulator, replacing emulator-5580 with its serial:

python3 build.py
adb -s emulator-5580 install -r -g build/gnss-repro.apk
adb -s emulator-5580 shell cmd location set-location-enabled true
adb -s emulator-5580 shell settings put global window_animation_scale 0
adb -s emulator-5580 shell settings put global transition_animation_scale 0
adb -s emulator-5580 shell settings put global animator_duration_scale 0
adb -s emulator-5580 shell am start -W -n org.example.gnssrepro/.MainActivity
adb -s emulator-5580 emu geo fix 0.0 0.0 0 8
sleep 3

Record all logcat buffers to a host file in a separate terminal before starting the loop:

adb -s emulator-5580 logcat -b all -v threadtime > gnss-repro-logcat.txt

The verified driver used this lifecycle loop in adb shell sh:

i=0
while [ "$i" -lt 200 ]; do
  input keyevent 3
  sleep 0.3
  am start -n org.example.gnssrepro/.MainActivity >/dev/null
  sleep 0.3
  i=$((i + 1))
  echo CYCLE "$i"
done

If application progress stalls, keep recording through the watchdog event, then save adb bugreport and both files from /data/anr (adb root on this AOSP userdebug image permits pulling them). The host loop can continue issuing commands while the application's main thread is blocked.

Initial HAL prototype built and verified on 2026-11-15 (historical results)

A dedicated Ubuntu 24.04.5 amd64 OrbStack machine on the ARM64 Mac successfully built the patch over SSH. Linux x86-64 build tools ran through Rosetta. No Docker or additional filesystem compression was used. The Linux filesystem reported approximately 134 GiB used after the targeted build.

  • Build source: AOSP android-15.0.0_r1; Goldfish revision bf456f45b33733b943cbd32bc8f8967240232963. The module-relative patch also applies to main's hals/gnss layout at base 3ce87694caeb4a330280bb1284d9ad050fe28263.
  • Built android.hardware.gnss-service.ranchu, gnss_ranchu_callback_queue_test, and VtsHalGnssTargetTest for sdk_phone64_arm64-trunk_staging-userdebug.
  • Actual AOSP Soong/Clang/libc++ host regression tests: 3 tests × 100 shuffled repetitions = 300 passed executions. They cover queue progress while a callback is blocked, FIFO dispatch/draining, and pending-event cancellation without waiting for an active callback. These initial tests did not exercise actual HAL state RPCs; the prepared revision adds actual HAL lifecycle tests.
  • Installed only the ARM64 GNSS HAL in the same affected Android 15 ARM64 image using a writable vendor overlay, restored its SELinux label, and rebooted. The hash of the running process's executable, not just the installed file, matched the built HAL.
  • The same independent platform-only APK completed 1,100 GNSS stops and 1,101 starts in 719.88 seconds. Satellite callbacks continued throughout. system_server PID 533 and HAL PID 813 survived unchanged; no watchdog kill occurred. The stock control stalled at stop 81.
  • Focused native GNSS VTS: 9 passed executions (3 repetitions each of SetupTeardownCreateCleanup, GetLocations, and TestStopSvStatusAndNmea). Locations were delivered; stopped SV/NMEA streams emitted no events during the tested interval. Framework and HAL PIDs remained unchanged.
  • After another guest reboot and running-HAL verification, all 12 connectedSamples instrumentation tests passed (basic 1, offline 7, routing 4) in 40 seconds. Framework PID 526 and HAL PID 786 survived unchanged.
  • Sample SDK artifact: existing local version 0.0.0-location-resolution-check; this was not a fresh publication of the original CI source pin.
  • Patch SHA-256: ffe6771154d9938250cd8511167cce0350eac4d4a94b464b60fa7c3219e05275.
  • Patched HAL SHA-256: dd6ee9edce2c406414b9b7e8752934d19e9fc88e7e03cc97ec2c6b7e95431c84.
  • Stock ARM64 HAL SHA-256: bdfc8ca911a52dd34111dde1cc380f4d6effefb16e1f29cee54ff43680a7fd18.

The patch, exact source manifest, build output, native test stdout/XML, per-test sample results, full device logcat, and process/hash checks are retained locally. This is one 1,100-cycle stress boot plus focused VTS and the complete sample instrumentation suite after a second boot. Full GNSS VTS/CTS and the original x86_64 CI guest remain untested with this patch. A full system image was not rebuilt. The initial patch was subsequently uploaded as Gerrit change 4445214; these prototype hashes and counts are historical, rather than patch set 2's validation. The issue remains open pending upstream review/distribution and CI validation.

Pre-existing issues from code reviews

All nine findings below concern code that predates this Gerrit patch. “Addressed in patch set 2” refers to the uploaded Gerrit revision, commit 099258c2d4c8478f821f91ab4e5fbeb9585550b4; it does not mean a released emulator image. The change remains open for upstream review. Rows 7–9 still require separate CLs.

# Pre-existing defect and verified evidence Status
1 Foreground callback/state-lock deadlock. Synchronous satellite/status/NMEA/location callbacks execute under the GNSS state mutex; hardware data callbacks also run on the reader. Framework listener removal can hold its multiplexer lock while calling back into the HAL. The original traces and standalone stock-image reproduction above demonstrate the cycle: stop 81 hung after 80 completed stops; watchdog killed system_server after 66 seconds. Addressed in patch set 2: serial foreground callback dispatch independent of state RPCs and hardware joins.
2 Concurrent GNSS starts can deadlock a hardware-reader join. Replacing mGnssHwConn under the state mutex joins a reader that needs that mutex. Native stacks captured the cycle. The correction completed 40 successful starts across 20 concurrent pairs. Addressed in patch set 2: serialize hardware ownership with a lifecycle mutex and release state before joins.
3 SV/NMEA subscriptions survive close/reopen. A new callback received these optional streams without requesting them. Native close/reopen probes reproduce this and verify that resetting the flags prevents delivery. Addressed in patch set 2: reset optional subscriptions on close.
4 Batch cleanup sends positions that it must discard and retains the last fix. A native cleanup probe received a callback containing four positions. This contradicts the batching cleanup contract. Addressed in patch set 2: discard the FIFO and last fix during cleanup/reinitialization. Queued-input generation checks additionally protect the new asynchronous handoff.
5 Zero batching period can prevent stop. Zero was accepted and produced a timer loop that retained the mutex; a native probe verified that stop hangs. The correction also covers submillisecond periods and unsafe deadline arithmetic, with native tests for 1 ns and the maximum positive signed 64-bit period. Addressed in patch set 2: reject nonpositive periods, round positive submillisecond intervals to 1 ms, and saturate absolute timer deadlines.
6 Incorrect GNSS service-error encoding. Positive IGnss::ERROR_* values were passed to fromExceptionCode(). An actual setCallback(nullptr) returned exception -129 / service error 0, losing the intended code. The correct factory returns EX_SERVICE_SPECIFIC (-8) / service error 1. Addressed in patch set 2 in GNSS, batching, antenna, configuration, measurement, and power guards using fromServiceSpecificError().
7 Measurement callback/close deadlock. GnssMeasurementInterface calls the synchronous measurement callback while holding its mutex; close takes that mutex and joins the callback-producing thread. Native callback re-entry into close deterministically deadlocked. The Android last-listener removal lock cycle was also traced in Java/JNI; a complete measurement-app timing reproduction has not been run. Open; separate upstream CL. Decouple dispatch from the joined producer and keep outgoing Binder calls outside extension locks.
8 Batching callback/stop deadlock. GnssBatching::flushLocked() calls the synchronous batch callback under its mutex; stop needs the mutex and may join the sampler. A native callback re-entering stop deterministically deadlocked. Open; separate upstream CL. Decouple callback dispatch from sampler joins and move outgoing Binder calls outside the extension mutex.
9 Batch-only requests have no independent hardware acquisition/feed. Batching start creates a sampler but does not start the GPS hardware; its only input is gated by ordinary GNSS navigation. A native probe produced no batch through the normal GNSS input while only batching was active, but delivered reports when input was fed directly to batching. Framework source confirms it stops normal navigation when choosing batching. Open; separate upstream CL. Give batching independent acquisition/feed lifetime while coordinating shared hardware ownership.

The baseline implementations can be inspected at GNSS, batching, and measurement. The small related fixes in rows 2–6 accompany the original deadlock correction in patch set 2; rows 7–9 are intentionally deferred.

Reproduction and scope of the three remaining issues:

  • Measurement (#7): register a sole active GnssMeasurementsEvent.Callback, then race its removal with measurement delivery. Last-listener removal holds the framework multiplexer lock while closing the HAL; measurement report delivery needs that same lock. For a deterministic HAL test, use a native measurement callback that re-enters the extension's close(). That native deadlock is verified; the complete public-API race is source-traced and still needs an end-to-end reproducer.
  • Batching callback (#8): initialize the batching extension with a native callback that calls stop(), then call flush(); flushLocked() holds the mutex needed by stop(). This deterministic native deadlock is verified. Releasing the mutex alone is insufficient for the sampler path if stop still joins a producer blocked on the synchronous callback.
  • Batch-only acquisition (#9): on a fresh Ranchu image, enable GPS and ensure no other GPS requests are active. Request GPS_PROVIDER updates with new LocationRequest.Builder(1000).setMaxUpdateDelayMillis(60000).build(), inject changing positions at 1 Hz, and wait 20 seconds. With advertised batch size 4, the framework chooses batching and stops ordinary navigation, leaving the sampler without fresh hardware fixes. This public-API reproduction follows the inspected framework/HAL paths; the direct native input-gating probe is verified, but this complete app scenario has not yet been run.

Review corrections to the proposed patch—stopped-stream backlog cancellation, bounded queues, actual HAL test coverage, and coalescing fairness—are tracked separately from the pre-existing defects above. The latest fairness fix replaces a pending latest-value payload in place, preserving its queue position so continuing NMEA/location input cannot postpone it indefinitely. It adds no worker or priority scheduler. Four deterministic regression cases fail with the previous queue implementation and pass with this correction; the coalescing test now checks latest values and NMEA FIFO order without requiring unrelated streams to follow a global order.

Patch set 2 validation (performed before upload)

Builds use current release GNSS C++ sources with the Android 15 AOSP toolchain and AIDL V2, targeting ARM64. Runtime verification uses the isolated Android 15/API 35 ARM64 userdebug emulator described above. A full Android 17 image, full GNSS VTS/CTS, and the original x86_64 CI guest remain untested.

  • Targeted ARM64 HAL and both actual test modules built successfully with AOSP Soong/Clang/libc++.
  • All 13 changed files match the build tree byte for byte. Queue tests: 13 × 100 shuffled repetitions = 1,300 passed executions. Independent Mac ARM64 validation also passed all 13; replacing only the header with the previous committed version failed exactly the four new continuous-input progress cases.
  • Actual native HAL lifecycle tests: 11 × 3 shuffled runs = 33 passes, none skipped.
  • The same platform-only lifecycle reproducer completed 300 GNSS stops and 301 starts in 199.43 seconds, with continuing satellite callbacks and unchanged system_server PID 534. No watchdog, failed registrations, full status backlog, or unreserved-status diagnostic occurred.
  • Focused GNSS VTS: 9 passes (the same three cases listed above, each repeated three times). Framework and HAL PIDs remained unchanged during VTS.
  • After another reboot and running-binary verification, all 12 debug connectedSamples tests passed (basic 1, offline 7, routing 4); framework and HAL PIDs remained unchanged. The sample SDK was the existing local 0.0.0-location-resolution-check publication, not a fresh build of the original CI pin.
  • Current tested HAL SHA-256: a997572283dac5cba35752e0aded4fcbea52f12b0cfb3a667853f0dd674b36ff, checked against both the installed file and running process executable.

All reviewed fixes, including the fairness correction and regression tests, were committed and uploaded as patch set 2 on 2026-11-16 (CET), with the existing Change-Id and me@alex.bio author/committer/signoff. The committed sources match the validation snapshot, and the local working tree is clean. This issue remains open until upstream distribution and the original x86_64 CI-image validation are resolved.

Activity

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions