Verwenden Sie den Auto-Watchdog, um den VHAL-Fehler zu beheben. Watchdog-Monitore für Autos
und tötet ungesunde Prozesse. Damit ein Prozess überwacht werden kann
wurde der Vorgang beim Auto-Watchdog registriert. Wann?
Der Watchdog im Auto tötet ungesunde Prozesse,
die Prozesse an data/anr
wie bei anderen Anwendungen, die nicht reagieren
(ANR-)Dumps. Dies erleichtert den Debugging-Prozess.
In diesem Artikel wird beschrieben, wie Anbieter-HALs und -Dienste einen Prozess mit den Auto-Watchdog.
Anbieter HAL
In der Regel verwendet der Anbieter-HAL einen Threadpool für hwbinder
. Sie können jedoch
kommuniziert der Watchdog-Client im
Auto mit dem Watchdog-Daemon des Autos
binder
, die sich von hwbinder
unterscheiden. Dementsprechend wird
ein anderer Threadpool für binder
wird verwendet.
Watchdog-Hilfe im Auto in Makefile angeben
carwatchdog_aidl_interface-ndk_platform
inshared_libs
einschließen:Android.bp
:cc_defaults { name: "vhal_v2_0_defaults", shared_libs: [ "libbinder_ndk", "libhidlbase", "liblog", "libutils", "android.hardware.automotive.vehicle@2.0", "carwatchdog_aidl_interface-ndk_platform", ], cflags: [ "-Wall", "-Wextra", "-Werror", ], }
SELinux-Richtlinie hinzufügen
-
Erlaube
system_server
, deinen HAL zu beenden. Wenn Siesystem_server.te
noch nicht haben, erstellen Sie eines. Es ist stark empfehlen, jedem Gerät eine SELinux-Richtlinie hinzuzufügen. -
Anbieter-HAL erlauben, Binder zu verwenden (Makro
binder_use
) und fügen Sie den Anbieter-HAL dercarwatchdog
-Clientdomain hinzu (carwatchdog_client_domain
Makro). Unten findest du den Code fürsystemserver.te
undvehicle_default.te
: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder"> </ph> system_server.te
# Allow system_server to kill vehicle HAL allow system_server hal_vehicle_server:process sigkill;
hal_vehicle_default.te
# Configuration for register VHAL to car watchdog carwatchdog_client_domain(hal_vehicle_default) binder_use(hal_vehicle_default)
Clientklasse durch Übernahme von BnCarWatchdogClient implementieren
-
Führen Sie in
checkIfAlive
eine Systemdiagnose durch. Posten Sie beispielsweise im Handler für die Thread-Schleife. Ist die Funktion fehlerfrei, rufen SieICarWatchdog::tellClientAlive
auf. Unten findest du den Code fürWatchogClient.h
undWatchogClient.cpp
: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder"> </ph> WatchogClient.h
class WatchdogClient : public aidl::android::automotive::watchdog::BnCarWatchdogClient { public: explicit WatchdogClient(const ::android::sp<::android::Looper>& handlerLooper, VehicleHalManager* vhalManager);
ndk::ScopedAStatus checkIfAlive(int32_t sessionId, aidl::android::automotive::watchdog::TimeoutLength timeout) override; ndk::ScopedAStatus prepareProcessTermination() override; };WatchogClient.cpp
ndk::ScopedAStatus WatchdogClient::checkIfAlive(int32_t sessionId, TimeoutLength /*timeout*/) { // Implement or call your health check logic here return ndk::ScopedAStatus::ok(); }
Binder-Thread starten und Client registrieren
- Erstellen Sie einen Threadpool für die Binder-Kommunikation. Wenn der Anbieter HAL für seine müssen Sie einen weiteren Threadpool für die Kommunikation mit Watchdog-Bindern im Auto erstellen.
-
Suchen Sie nach dem Daemon mit dem Namen und rufen Sie
ICarWatchdog::registerClient
auf. Der Schnittstellenname des Watchdog-Daemon im Auto lautetandroid.automotive.watchdog.ICarWatchdog/default
-
Wählen Sie je nach Reaktionsfähigkeit des Dienstes eine der drei folgenden Arten von Zeitüberschreitungen aus.
unterstützt wird, und übergeben dann das Zeitlimit im Aufruf an
ICarWatchdog::registerClient
: <ph type="x-smartling-placeholder">- </ph>
- kritisch(3 s)
- moderat(5 s)
- Normal(10s)
VehicleService.cpp
undWatchogClient.cpp
: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder"> </ph> VehicleService.cpp
int main(int /* argc */, char* /* argv */ []) { // Set up thread pool for hwbinder configureRpcThreadpool(4, false /* callerWillJoin */); ALOGI("Registering as service..."); status_t status = service->registerAsService(); if (status != OK) { ALOGE("Unable to register vehicle service (%d)", status); return 1; } // Setup a binder thread pool to be a car watchdog client. ABinderProcess_setThreadPoolMaxThreadCount(1); ABinderProcess_startThreadPool(); sp<Looper> looper(Looper::prepare(0 /* opts */)); std::shared_ptr<WatchdogClient> watchdogClient = ndk::SharedRefBase::make<WatchdogClient>(looper, service.get()); // The current health check is done in the main thread, so it falls short of capturing the real // situation. Checking through HAL binder thread should be considered. if (!watchdogClient->initialize()) { ALOGE("Failed to initialize car watchdog client"); return 1; } ALOGI("Ready"); while (true) { looper->pollAll(-1 /* timeoutMillis */); } return 1; }
WatchogClient.cpp
bool WatchdogClient::initialize() { ndk::SpAIBinder binder(AServiceManager_getService("android.automotive.watchdog.ICarWatchdog/default")); if (binder.get() == nullptr) { ALOGE("Failed to get carwatchdog daemon"); return false; } std::shared_ptr<ICarWatchdog> server = ICarWatchdog::fromBinder(binder); if (server == nullptr) { ALOGE("Failed to connect to carwatchdog daemon"); return false; } mWatchdogServer = server; binder = this->asBinder(); if (binder.get() == nullptr) { ALOGE("Failed to get car watchdog client binder object"); return false; } std::shared_ptr<ICarWatchdogClient> client = ICarWatchdogClient::fromBinder(binder); if (client == nullptr) { ALOGE("Failed to get ICarWatchdogClient from binder"); return false; } mTestClient = client; mWatchdogServer->registerClient(client, TimeoutLength::TIMEOUT_NORMAL); ALOGI("Successfully registered the client to car watchdog server"); return true; }
Anbieterdienste (nativ)
Makefile für Watchdog-Hilfe im Auto angeben
carwatchdog_aidl_interface-ndk_platform
inshared_libs
einschließen.Android.bp
cc_binary { name: "sample_native_client", srcs: [ "src/*.cpp" ], shared_libs: [ "carwatchdog_aidl_interface-ndk_platform", "libbinder_ndk", ], vendor: true, }
SELinux-Richtlinie hinzufügen
- Um eine SELinux-Richtlinie hinzuzufügen, muss die Domain des Anbieterdienstes binder verwenden
(
binder_use
-Makro) und fügen Sie die Anbieterdienst-Domain zumcarwatchdog
-Clientdomain (carwatchdog_client_domain
-Makro) Unten findest du den Code fürsample_client.te
undfile_contexts
: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder"> </ph> beispielkunde.de
type sample_client, domain; type sample_client_exec, exec_type, file_type, vendor_file_type; carwatchdog_client_domain(sample_client) init_daemon_domain(sample_client) binder_use(sample_client)
Dateikontexte
/vendor/bin/sample_native_client u:object_r:sample_client_exec:s0
Clientklasse durch Übernahme von BnCarWatchdogClient implementieren
- Führen Sie in
checkIfAlive
eine Systemdiagnose durch. Eine Möglichkeit besteht darin, den Thread-Loop-Handler. Ist die Funktion fehlerfrei, rufen SieICarWatchdog::tellClientAlive
auf. Unten findest du den Code fürSampleNativeClient.h
undSampleNativeClient.cpp
: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder"> </ph> SampleNativeClient.h
class SampleNativeClient : public BnCarWatchdogClient { public: ndk::ScopedAStatus checkIfAlive(int32_t sessionId, TimeoutLength timeout) override; ndk::ScopedAStatus prepareProcessTermination() override; void initialize(); private: void respondToDaemon(); private: ::android::sp<::android::Looper> mHandlerLooper; std::shared_ptr<ICarWatchdog> mWatchdogServer; std::shared_ptr<ICarWatchdogClient> mClient; int32_t mSessionId; };
SampleNativeClient.cpp
ndk::ScopedAStatus WatchdogClient::checkIfAlive(int32_t sessionId, TimeoutLength timeout) { mHandlerLooper->removeMessages(mMessageHandler, WHAT_CHECK_ALIVE); mSessionId = sessionId; mHandlerLooper->sendMessage(mMessageHandler, Message(WHAT_CHECK_ALIVE)); return ndk::ScopedAStatus::ok(); } // WHAT_CHECK_ALIVE triggers respondToDaemon from thread handler void WatchdogClient::respondToDaemon() { // your health checking method here ndk::ScopedAStatus status = mWatchdogServer->tellClientAlive(mClient, mSessionId); }
Binder-Thread starten und Client registrieren
Der Schnittstellenname des Watchdog-Daemon im Auto lautet
android.automotive.watchdog.ICarWatchdog/default
- Suchen Sie nach dem Daemon mit dem Namen und rufen Sie
ICarWatchdog::registerClient
auf. Unten findest du den Code fürmain.cpp
undSampleNativeClient.cpp
: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder"> </ph> haupt.cpp
int main(int argc, char** argv) { sp<Looper> looper(Looper::prepare(/*opts=*/0)); ABinderProcess_setThreadPoolMaxThreadCount(1); ABinderProcess_startThreadPool(); std::shared_ptr<SampleNativeClient> client = ndk::SharedRefBase::make<SampleNatvieClient>(looper); // The client is registered in initialize() client->initialize(); ... }
SampleNativeClient.cpp
void SampleNativeClient::initialize() { ndk::SpAIBinder binder(AServiceManager_getService( "android.automotive.watchdog.ICarWatchdog/default")); std::shared_ptr<ICarWatchdog> server = ICarWatchdog::fromBinder(binder); mWatchdogServer = server; ndk::SpAIBinder binder = this->asBinder(); std::shared_ptr<ICarWatchdogClient> client = ICarWatchdogClient::fromBinder(binder) mClient = client; server->registerClient(client, TimeoutLength::TIMEOUT_NORMAL); }
Anbieterdienste (Android)
Client durch Übernahme von CarWatchdogClientCallback implementieren
- Bearbeiten Sie die neue Datei wie folgt:
private final CarWatchdogClientCallback mClientCallback = new CarWatchdogClientCallback() { @Override public boolean onCheckHealthStatus(int sessionId, int timeout) { // Your health check logic here // Returning true implies the client is healthy // If false is returned, the client should call // CarWatchdogManager.tellClientAlive after health check is // completed } @Override public void onPrepareProcessTermination() {} };
Client registrieren
- Rufen Sie
CarWatchdogManager.registerClient()
an:private void startClient() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager( Car.CAR_WATCHDOG_SERVICE); // Choose a proper executor according to your health check method ExecutorService executor = Executors.newFixedThreadPool(1); manager.registerClient(executor, mClientCallback, CarWatchdogManager.TIMEOUT_NORMAL); }
Client abmelden
- Rufen Sie
CarWatchdogManager.unregisterClient()
auf, wenn der Dienst beendet ist:private void finishClient() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager( Car.CAR_WATCHDOG_SERVICE); manager.unregisterClient(mClientCallback); }
Vom Auto-Watchdog beendete Prozesse erkennen
Prozesse zur Entsorgung/Tötung von Fahrzeugen (Anbieter HAL, anbieternative Dienstleistungen,
Android-Diensten des Anbieters), die beim Auto-Watchdog registriert sind,
bleibt hängen und reagiert nicht. Ein solches Dumping wird durch die Prüfung von Logcats erkannt. Das Auto
Watchdog gibt ein Log aus carwatchdog killed process_name (pid:process_id)
Ein problematischer Prozess wird gelöscht oder beendet. Daher gilt:
$ adb logcat -s CarServiceHelper | fgrep "carwatchdog killed"
Die relevanten Logs werden erfasst. Wenn z. B. die KitchenSink-App (ein Watchdog im Auto) Client) hängen bleibt, wird eine Zeile wie die folgende in das Protokoll geschrieben:
05-01 09:50:19.683 578 5777 W CarServiceHelper: carwatchdog killed com.google.android.car.kitchensink (pid: 5574)
Verwenden Sie den Prozess-Dump, um herauszufinden, warum oder wo die KitchenSink-App hängen geblieben ist
unter /data/anr
gespeichert sind, so wie Sie es bei ANR-Fällen für Aktivitäten tun würden.
$ adb root $ adb shell grep -Hn "pid process_pid" /data/anr/*
Die folgende Beispielausgabe ist spezifisch für die KitchenSink-Anwendung:
$ adb shell su root grep -Hn "pid 5574" /data/anr/*. /data/anr/anr_2020-05-01-09-50-18-290:3:----- pid 5574 at 2020-05-01 09:50:18 ----- /data/anr/anr_2020-05-01-09-50-18-290:285:----- Waiting Channels: pid 5574 at 2020-05-01 09:50:18 -----
Suchen Sie die Dumpdatei, z. B. /data/anr/anr_2020-05-01-09-50-18-290
.
im obigen Beispiel) und beginnen Sie mit Ihrer Analyse.