Diese Seite wurde von der Cloud Translation API übersetzt.

Auto-Kontrollhund

Verwenden Sie den Watchdog im Auto, um die VHAL zu debuggen. Der Auto-Watchdog überwacht den Zustand ungesunder Prozesse – und tötet sie. Damit ein Prozess vom Watchdog im Auto überwacht werden kann, muss er beim Watchdog registriert sein. Wenn der Car Watchdog fehlerhafte Prozesse beendet, schreibt er den Status der Prozesse wie bei anderen ANR-Dumps (Application Not Responding) in data/anr. Dies erleichtert die Fehlerbehebung.

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. Daher wird ein anderer Thread-Pool für binder verwendet.

Watchdog im Auto als aidl im Makefile angeben

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

Erlaube system_server, deinen HAL zu beenden. Wenn Sie noch kein system_server.te haben, erstellen Sie eines. Wir empfehlen dringend, jedem Gerät eine SELinux-Richtlinie hinzuzufügen.
Erlauben Sie der HAL des Anbieters, den Binder zu verwenden (binder_use-Makro) und fügen Sie die HAL des Anbieters der carwatchdog-Clientdomain hinzu (carwatchdog_client_domain-Makro). Im folgenden Code sind die Werte für systemserver.te und vehicle_default.te zu sehen:
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. Beispiel: Posten an den Thread-Loop-Handler. Wenn alles in Ordnung ist, rufen Sie ICarWatchdog::tellClientAlive an. Im folgenden Code sind die Werte für WatchogClient.h und WatchogClient.cpp zu sehen:

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 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.
Suchen Sie nach dem Daemon mit dem Namen und rufen Sie ICarWatchdog::registerClient auf. Der Name der Watchdog-Daemon-Schnittstelle für das Auto lautet android.automotive.watchdog.ICarWatchdog/default.

Wählen Sie je nach Dienstreaktionszeit einen der drei vom Dienst-Watchdog unterstützten Zeitüberschreitungstypen aus und übergeben Sie die Zeitüberschreitung dann im Aufruf an ICarWatchdog::registerClient:

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)

Aidl-Makefile für den Watchdog im Auto angeben

Fügen Sie carwatchdog_aidl_interface-ndk_platform in shared_libs ein.

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

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)
```
file_contexts
```
/vendor/bin/sample_native_client  u:object_r:sample_client_exec:s0
```

Implementieren Sie eine Clientklasse, indem Sie BnCarWatchdogClient erben.

Führen Sie in checkIfAlive eine Systemdiagnose durch. Eine Möglichkeit besteht darin, eine Nachricht an den Thread-Loop-Handler zu senden. Ist die Funktion fehlerfrei, rufen Sie ICarWatchdog::tellClientAlive auf. Im folgenden Code sind die Werte für SampleNativeClient.h und SampleNativeClient.cpp zu sehen:

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.

Suchen Sie nach dem Daemon mit dem Namen und rufen Sie ICarWatchdog::registerClient auf. Unten findest du den Code für main.cpp und SampleNativeClient.cpp:

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

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

Rufe CarWatchdogManager.unregisterClient() auf, wenn der Dienst abgeschlossen ist:

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

Vom Auto-Watchdog beendete Prozesse erkennen

Prozesse zum Abladen/Töten von Fahrzeugen (Anbieter-HAL, native Dienste des Anbieters, Android-Dienste des Anbieters), die beim Watchdog im Auto registriert werden, wenn sie nicht weiterkommen und nicht reagieren. Solche Dumps werden durch Prüfen von Logcats erkannt. Der Watchdog des Autos gibt ein Log-carwatchdog killed process_name (pid:process_id) aus, wenn ein problematischer Prozess abgelegt oder gelöscht wird. Daher gilt:

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

Die relevanten Protokolle werden erfasst. Wenn beispielsweise die KitchenSink-App (ein Car Watchdog-Client) hängen bleibt, wird in das Protokoll eine Zeile wie die folgende 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 bezieht sich auf die KitchenSink-App:

$ 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 Beispiel oben) und starten Sie die Analyse.

Auto-Kontrollhund

Anbieter-HAL

Watchdog im Auto als aidl im Makefile angeben

SELinux-Richtlinie hinzufügen

system_server.te

hal_vehicle_default.te

Clientklasse durch Übernahme von BnCarWatchdogClient implementieren

WatchogClient.h

WatchogClient.cpp

Binder-Thread starten und Client registrieren

VehicleService.cpp

WatchogClient.cpp

Anbieterdienste (nativ)

Aidl-Makefile für den Watchdog im Auto angeben

SELinux-Richtlinie hinzufügen

sample_client.te

file_contexts

Implementieren Sie eine Clientklasse, indem Sie BnCarWatchdogClient erben.

SampleNativeClient.h

SampleNativeClient.cpp

Binder-Thread starten und Client registrieren

haupt.cpp

SampleNativeClient.cpp

Anbieterdienste (Android)

Client durch Übernahme von CarWatchdogClientCallback implementieren

Client registrieren

Client abmelden

Vom Auto-Watchdog beendete Prozesse erkennen