Monitorowanie stanu systemu

Watchdog monitoruje stan usług dostawcy i usługi VHAL oraz przerywa wszystkie nieprawidłowe procesy. Gdy nieprawidłowy proces zostanie zakończony, Watchdog zapisze stan procesu w pliku /data/anr, tak jak w przypadku innych plików z informacjami o błędach typu Aplikacja nie odpowiada (ANR). Ułatwi to debugowanie.

Monitorowanie stanu usług dostawcy

Usługi dostawców są monitorowane zarówno po stronie natywnej, jak i po stronie Java. Aby usługa dostawcy była monitorowana, musi zarejestrować proces sprawdzania stanu w Watchdogu, podając zdefiniowany wstępnie limit czasu. Watchdog monitoruje stan zarejestrowanego procesu kontroli stanu, pingując go w odstępach czasowych zależnych od czasu oczekiwania określonego podczas rejestracji. Jeśli proces ping nie odpowie w wyznaczonym czasie, jest uznawany za nieprawidłowy.

Monitorowanie stanu usługi natywnej

Określ plik tworzenia pliku watchdog AIDL

1. Uwzględnij carwatchdog_aidl_interface-ndk_platform w shared_libs.

   Android.bp

   cc_binary {
       name: "sample_native_client",
       srcs: [
           "src/*.cpp"
       ],
       shared_libs: [
           "carwatchdog_aidl_interface-ndk_platform",
           "libbinder_ndk",
       ],
       vendor: true,
   }
   

Dodawanie zasady SELinux

1. Aby dodać zasadę SELinux, zezwól domenie usługi dostawcy na używanie sposobu (makro binder_use) i dodaj domenę usługi dostawcy do domeny klienta carwatchdog (makro carwatchdog_client_domain). Zobacz ten kod dla sample_client.te i 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)
   

   file_contexts

   /vendor/bin/sample_native_client  u:object_r:sample_client_exec:s0
   

Zaimplementuj klasę klienta, dziedzicząc ją z klasy BnCarWatchdogClient.

1. W checkIfAlive przeprowadź kontrolę stanu. Jedną z opcji jest opublikowanie w module obsługi pętli wątku. Jeśli nie masz objawów, zadzwoń pod numer ICarWatchdog::tellClientAlive. Poniżej znajdziesz kod dotyczący elementów SampleNativeClient.h i 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);
   }
   

Rozpoczynanie wątku powiązania i rejestrowanie klienta

Nazwa interfejsu demona watchdoga w samochodzie to android.automotive.watchdog.ICarWatchdog/default.

1. Wyszukaj demona o takiej nazwie i wywołaj ICarWatchdog::registerClient. Poniżej znajdziesz kod dotyczący elementów main.cpp i SampleNativeClient.cpp:

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

Monitorowanie stanu usługi Java

Wdrażanie klienta przez dziedziczenie CarWatchdogClientCallback

1. Zmień nowy plik w ten sposób:

   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() {}
   };
   

Rejestracja klienta

1. Zadzwoń do firmy CarWatchdogManager.registerClient():

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

Wyrejestruj klienta

1. Po zakończeniu usługi zadzwoń pod numer CarWatchdogManager.unregisterClient():

   private void finishClient() {
       CarWatchdogManager manager =
           (CarWatchdogManager) car.getCarManager(
           Car.CAR_WATCHDOG_SERVICE);
       manager.unregisterClient(mClientCallback);
   }
   

Monitorowanie stanu VHAL

W przeciwieństwie do monitorowania stanu usługi dostawcy Watchdog monitoruje stan usługi VHAL, subskrybując usługę VHAL_HEARTBEAT pojazdu. Funkcja Watchdog oczekuje, że wartość tej właściwości będzie aktualizowana co N sekund. Jeśli pakiet podtrzymujący nie zostanie zaktualizowany w tym czasie, Watchdog zakończy usługę VHAL.

Uwaga: Watchdog monitoruje stan usługi VHAL tylko wtedy, gdy usługa VHAL obsługuje właściwość pojazdu VHAL_HEARTBEAT.

Wewnętrzna implementacja VHAL może się różnić w zależności od dostawcy. Jako odniesienia możesz użyć tych przykładowych fragmentów kodu.

1. Zarejestruj właściwość pojazdu VHAL_HEARTBEAT.

   Podczas uruchamiania usługi VHAL zarejestruj właściwość VHAL_HEARTBEAT pojazdu. W przykładzie poniżej element unordered_map, który mapuje identyfikator usługi na konfigurację, jest używany do przechowywania wszystkich obsługiwanych konfiguracji. Konfiguracja VHAL_HEARTBEAT jest dodawana do mapy, aby po przesłaniu zapytania o VHAL_HEARTBEAT zwracać odpowiednią konfigurację.

   void registerVhalHeartbeatProperty() {
           const VehiclePropConfig config = {
                   .prop = toInt(VehicleProperty::VHAL_HEARTBEAT),
                   .access = VehiclePropertyAccess::READ,
                   .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
           };
          // mConfigsById is declared as std::unordered_map<int32_t, VehiclePropConfig>.
          mConfigsById[config.prop] = config;
   }
   

2. Zaktualizuj właściwość pojazdu VHAL_HEARTBEAT.

   Na podstawie częstotliwości kontroli stanu VHAL (omówionej w sekcji Definiowanie częstotliwości kontroli stanu VHAL) aktualizuj właściwość pojazdu VHAL_HEARTBEAT co N sekund. Można to zrobić na przykład za pomocą wywołania RecurrentTimer do wywołania działania, które sprawdza stan VHAL i powoduje zaktualizowanie właściwości pojazdu VHAL_HEARTBEAT po upływie limitu czasu.

   Poniżej znajduje się przykładowa implementacja korzystająca z funkcji RecurrentTimer:

   int main(int argc, char** argv) {
           RecurrentTimer recurrentTimer(updateVhalHeartbeat);
           recurrentTimer.registerRecurrentEvent(kHeartBeatIntervalNs,
                                              static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT));
           … Run service …
           recurrentTimer.unregisterRecurrentEvent(
                   static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT));
   }
   
   void updateVhalHeartbeat(const std::vector<int32_t>& cookies) {
          for (int32_t property : cookies) {
                 if (property != static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT)) {
                        continue;
                 }
   
                 // Perform internal health checking such as retrieving a vehicle property to ensure
                 // the service is responsive.
                 doHealthCheck();
   
                 // Construct the VHAL_HEARTBEAT property with system uptime.
                 VehiclePropValuePool valuePool;
                 VehicleHal::VehiclePropValuePtr propValuePtr = valuePool.obtainInt64(uptimeMillis());
                 propValuePtr->prop = static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT);
                 propValuePtr->areaId = 0;
                 propValuePtr->status = VehiclePropertyStatus::AVAILABLE;
                 propValuePtr->timestamp = elapsedRealtimeNano();
   
                 // Propagate the HAL event.
                 onHalEvent(std::move(propValuePtr));
          }
   }
   

3. (Opcjonalnie) Określ częstotliwość kontroli stanu VHAL.

   Właściwość usługi Watchdog ro.carwatchdog.vhal_healthcheck.interval tylko do odczytu określa częstotliwość kontroli stanu VHAL. Domyślna częstotliwość kontroli stanu (gdy ta właściwość nie jest zdefiniowana) wynosi 3 sekundy. Jeśli 3 sekundy to za dużo, aby usługa VHAL zaktualizowała właściwość VHAL_HEARTBEAT pojazdu, zdefiniuj częstotliwość kontroli stanu VHAL w zależności od szybkości działania usługi.

Debugowanie procesów w złym stanie zakończonych przez Watchdoga

Watchdog zrzuca stan procesu i kończy procesy nieprawidłowe. Po zakończeniu nieprawidłowego procesu Watchdog zarejestruje tekst carwatchdog terminated <process name> (pid:<process id>) w logcat. Ta linia dziennika zawiera informacje o zakończonym procesie, takie jak nazwa procesu i identyfikator procesu.

1. Aby wyszukać wspomniany tekst w pliku logcat, uruchom:

   $ adb logcat -s CarServiceHelper | fgrep "carwatchdog killed"
   

   Na przykład, gdy aplikacja KitchenSink jest zarejestrowanym klientem Watchdog i przestaje odpowiadać na pingi Watchdog, Watchdog rejestruje wiersz podobny do tego poniżej, gdy kończy zarejestrowany proces KitchenSink.

   05-01 09:50:19.683   578  5777 W CarServiceHelper: carwatchdog killed com.google.android.car.kitchensink (pid: 5574)
   

2. Aby zidentyfikować główną przyczynę braku reakcji, użyj pliku dump procesu przechowywanego w pliku /data/anr, tak jak w przypadku błędów ANR dotyczących aktywności. Aby pobrać plik zrzutu dla zakończonego procesu, użyj podanych niżej poleceń.

   $ adb root
   $ adb shell grep -Hn "pid process_pid" /data/anr/*
   

   Poniższy przykładowy wynik dotyczy aplikacji KitchenSink:

   $ 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 -----
   

   Plik z dane pochodzącymi z zakończonego procesu KitchenSink znajduje się w katalogu /data/anr/anr_2020-05-01-09-50-18-290. Rozpocznij analizę za pomocą pliku zrzutu ANR zakończonego procesu.