Diese Seite wurde von der Cloud Translation API übersetzt.

Auto-Kontrollhund

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 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 system_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 der carwatchdog-Clientdomain hinzu (carwatchdog_client_domain Makro). Unten findest du den Code für systemserver.te und vehicle_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 Sie ICarWatchdog::tellClientAlive auf. Unten findest du den Code für WatchogClient.h und WatchogClient.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 lautet android.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">

kritisch(3 s)
moderat(5 s)
Normal(10s)

Unten findest du den Code für VehicleService.cpp und WatchogClient.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 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

Um eine SELinux-Richtlinie hinzuzufügen, muss die Domain des Anbieterdienstes binder verwenden (binder_use-Makro) und fügen Sie die Anbieterdienst-Domain zum carwatchdog-Clientdomain (carwatchdog_client_domain-Makro) Unten findest du den Code für sample_client.te und file_contexts: <ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
beispiel_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

Führen Sie in checkIfAlive eine Systemdiagnose durch. Eine Möglichkeit besteht darin, den Thread-Loop-Handler. Ist der Fehler fehlerfrei, rufen Sie ICarWatchdog::tellClientAlive auf. Unten findest du den Code für SampleNativeClient.h und SampleNativeClient.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ür main.cpp und SampleNativeClient.cpp: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder">

</ph>

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

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 der Analyse.

Auto-Kontrollhund

Anbieter HAL

Watchdog-Hilfe im Auto in 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)

Makefile für Watchdog-Hilfe im Auto angeben

SELinux-Richtlinie hinzufügen

beispiel_client.te

Dateikontexte

Clientklasse durch Übernahme von BnCarWatchdogClient implementieren

SampleNativeClient.h

SampleNativeClient.cpp

Binder-Thread starten und Client registrieren

main.cpp

SampleNativeClient.cpp

Anbieterdienste (Android)

Client durch Übernahme von CarWatchdogClientCallback implementieren

Client registrieren

Client abmelden

Vom Auto-Watchdog beendete Prozesse erkennen