Ta strona została przetłumaczona przez Cloud Translation API.

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

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

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.

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.

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

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

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

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.

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

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

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

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)
```
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.