Watchdog im Auto

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Verwenden Sie den Auto-Watchdog, um den VHAL-Fehler zu beheben. Watchdog-Monitore für Autos und tötet ungesunde Prozesse. Damit ein Prozess vom Watchdog im Auto überwacht werden kann, muss er beim Watchdog registriert sein. 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 beim Watchdog des Autos registrieren können.

Anbieter HAL

Normalerweise verwendet die HAL des Anbieters einen Thread-Pool für hwbinder. Der Watchdog-Client für das Auto kommuniziert jedoch über binder mit dem Watchdog-Daemon für das Auto, was sich von hwbinder unterscheidet. Dementsprechend wird ein anderer Threadpool für binder wird verwendet.

Watchdog-Hilfe im Auto in Makefile angeben

1. carwatchdog_aidl_interface-ndk_platform in shared_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

1. Erlauben Sie system_server, Ihre HAL zu beenden. Wenn Sie noch keine system_server.te haben, erstellen Sie eine. Es ist stark empfehlen, jedem Gerät eine SELinux-Richtlinie hinzuzufügen.
2. Anbieter-HAL erlauben, Binder zu verwenden (Makro binder_use) und fügen Sie den Anbieter-HAL der carwatchdog-Clientdomain hinzu (carwatchdog_client_domain Makro). Unten findest du den Code für systemserver.te und vehicle_default.te:

   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

1. Führen Sie in checkIfAlive eine Systemdiagnose durch. Posten Sie beispielsweise im Handler für die Thread-Schleife. Ist die Funktion fehlerfrei, rufen Sie ICarWatchdog::tellClientAlive auf. Unten findest du den Code für WatchogClient.h und WatchogClient.cpp:

   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

1. Erstellen Sie einen Threadpool für die Binder-Kommunikation. Wenn die HAL des Anbieters hwbinder für eigene Zwecke verwendet, müssen Sie einen weiteren Thread-Pool für die Kommunikation des Car Watchdog-Binders erstellen.
2. Suchen Sie nach dem Daemon mit dem Namen und rufen Sie ICarWatchdog::registerClient auf. Der Schnittstellenname des Watchdog-Daemon im Auto lautet android.automotive.watchdog.ICarWatchdog/default
3. 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>
   • critical(3s)
   • mittel (5 s)
   • Normal(10s)
   Unten finden Sie den Code für VehicleService.cpp und WatchogClient.cpp:

   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

1. carwatchdog_aidl_interface-ndk_platform in shared_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

1. Wenn Sie eine SELinux-Richtlinie hinzufügen möchten, erlauben Sie der Domain des Anbieterdiensts, Binder zu verwenden (binder_use-Makro), und fügen Sie die Domain des Anbieterdiensts der carwatchdog-Clientdomain (carwatchdog_client_domain-Makro) hinzu. Unten findest du den Code für sample_client.te und file_contexts:

   sample_client.te

   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

1. Führen Sie in checkIfAlive eine Systemdiagnose durch. Eine Möglichkeit besteht darin, den Thread-Loop-Handler. Ist die Funktion fehlerfrei, rufen Sie ICarWatchdog::tellClientAlive auf. Unten findest du den Code für SampleNativeClient.h und SampleNativeClient.cpp:

   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 Name der Watchdog-Daemon-Schnittstelle für das Auto lautet android.automotive.watchdog.ICarWatchdog/default.

1. Suchen Sie nach dem Daemon mit dem Namen und rufen Sie ICarWatchdog::registerClient auf. Im folgenden Code sind die Werte für main.cpp und SampleNativeClient.cpp zu sehen:

   main.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

1. Bearbeiten Sie die neue Datei so:

   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

1. CarWatchdogManager.registerClient() anrufen:

   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

1. 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);
   }

Prozesse erkennen, die vom Watchdog im Auto beendet wurden

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 Protokolle 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)

Um herauszufinden, warum oder wo die KitchenSink-App hängengeblieben ist, verwenden Sie den Prozess-Dump, der unter /data/anr gespeichert ist, genau wie Sie ANR-Fehlerfälle für Aktivitäten verwenden 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 der Analyse.