Cette page a été traduite par l'API Cloud Translation.

Chien de garde de la voiture

Utilisez le watchdog de la voiture pour déboguer le VHAL. Surveillance des véhicules l'état des processus défaillants et les tue. Pour qu'un processus soit surveillé par le watchdog de la voiture, le processus doit être enregistré auprès du watchdog de la voiture. Quand ? le watchdog de la voiture tue les processus non opérationnels, le watchdog de la voiture écrit l'état les processus à data/anr, comme lorsque l'application ne répond pas (ANR). Cela facilite le processus de débogage.

Cet article explique comment les HAL et les services des fournisseurs peuvent enregistrer un processus avec le chien de garde de la voiture.

HAL du fournisseur

En règle générale, le fournisseur HAL utilise un pool de threads pour hwbinder. Toutefois, le client watchdog de la voiture communique avec le démon watchdog de la voiture via binder, qui diffère de hwbinder. Par conséquent, un autre pool de threads pour binder est en cours d'utilisation.

Spécifier l'idl du watchdog de la voiture dans le fichier makefile

Inclure carwatchdog_aidl_interface-ndk_platform dans shared_libs:

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",
    ],
}

Ajouter une règle SELinux

Autoriser system_server à fermer votre HAL. Si vous ne disposez pas de system_server.te, créez-en un. Il est fortement vous a recommandé d'ajouter une règle SELinux à chaque appareil.
Autoriser le HAL du fournisseur à utiliser la liaison (macro binder_use) et ajoutez le fournisseur HAL au domaine du client carwatchdog (macro carwatchdog_client_domain). Consultez le code ci-dessous pour systemserver.te et 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)
```

Implémenter une classe client en héritant de BnCarWatchdogClient

Dans checkIfAlive, vérifiez l'état. Par exemple, publiez sur le gestionnaire de boucle de threads. Si l'état est opérationnel, appelez ICarWatchdog::tellClientAlive. Consultez le code ci-dessous pour WatchogClient.h et 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();
}

Démarrer le thread de liaison et enregistrer le client

Créez un pool de threads pour la communication de liaison. Si le fournisseur HAL utilise hwbinder pour ses votre propre objectif, vous devez créer un autre pool de threads pour la communication des liaisons de surveillance des voitures).
Recherchez le daemon portant le nom et appelez ICarWatchdog::registerClient. Le nom de l'interface du daemon de watchdog de la voiture est android.automotive.watchdog.ICarWatchdog/default

En fonction de la réactivité du service, sélectionnez l'un des trois types de délai avant expiration suivants pris en charge par le watchdog de la voiture, puis transmettre le délai d'inactivité dans l'appel à ICarWatchdog::registerClient: <ph type="x-smartling-placeholder">

critique(3 s)
modérée(5 s)
normal(10s)

Consultez le code ci-dessous pour VehicleService.cpp et WatchogClient.cpp: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder">

</ph>

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

Services pour les fournisseurs (natifs)

Spécifier le fichier makefile de l'idl du watchdog de la voiture

Inclure carwatchdog_aidl_interface-ndk_platform dans shared_libs.

Android.bp

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

Ajouter une règle SELinux

Pour ajouter une règle SELinux, autorisez le domaine du service du fournisseur à utiliser la liaison (macro binder_use), puis ajoutez le domaine du service fournisseur au Domaine du client carwatchdog (macro carwatchdog_client_domain). Consultez le code ci-dessous pour sample_client.te et file_contexts: <ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
exemple_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)
```
contextes_fichiers
```
/vendor/bin/sample_native_client  u:object_r:sample_client_exec:s0
```

Implémenter une classe client en héritant de BnCarWatchdogClient

Dans checkIfAlive, effectuez une vérification de l'état. Une option consiste à publier sur le gestionnaire de boucle de thread. Si l'état est opérationnel, appelez ICarWatchdog::tellClientAlive. Consultez le code ci-dessous pour SampleNativeClient.h et SampleNativeClient.cpp: <ph type="x-smartling-placeholder"></ph> <ph type="x-smartling-placeholder">

</ph>

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

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

Démarrer un thread de liaison et enregistrer le client

Le nom de l'interface du daemon de watchdog de la voiture est android.automotive.watchdog.ICarWatchdog/default

Recherchez le daemon portant le nom et appelez ICarWatchdog::registerClient. Consultez le code ci-dessous pour main.cpp et 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();
    ...
}

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

Services pour les fournisseurs (Android)

Implémenter un client en héritant de CarWatchdogClientCallback

Modifiez le nouveau fichier comme suit:

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

Enregistrer le client

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

Annuler l'enregistrement du client

Appelez CarWatchdogManager.unregisterClient() lorsque le service est terminé:

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

Détecter les processus arrêtés par le watchdog de la voiture

Processus de dumps/suppressions de watchdog de la voiture (HAL du fournisseur, services natifs du fournisseur, des services Android du fournisseur) enregistrés dans le watchdog de la voiture lorsqu'ils bloqué et ne répond pas. Ce vidage est détecté en vérifiant les fichiers logcat. La voiture watchdog génère un journal carwatchdog killed process_name (pid:process_id) lorsqu'un processus problématique est vidé ou arrêté. Par conséquent :

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

Les journaux pertinents sont capturés. Par exemple, si l'application KitchenSink (un watchdog de la voiture client) reste bloqué, une ligne comme celle ci-dessous est écrite dans le journal:

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

Pour déterminer l'origine ou la cause du blocage de l'application KitchenSink, utilisez le vidage de processus stocké à /data/anr, tout comme vous utiliseriez les cas d'erreurs ANR d'activité.

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

L'exemple de résultat suivant est spécifique à l'application 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 -----

Recherchez le fichier de vidage (par exemple, /data/anr/anr_2020-05-01-09-50-18-290). dans l'exemple ci-dessus) et commencez votre analyse.

Chien de garde de la voiture

HAL du fournisseur

Spécifier l'idl du watchdog de la voiture dans le fichier makefile

Ajouter une règle SELinux

system_server.te

hal_vehicle_default.te

Implémenter une classe client en héritant de BnCarWatchdogClient

WatchogClient.h

WatchogClient.cpp

Démarrer le thread de liaison et enregistrer le client

ServiceService.cpp

WatchogClient.cpp

Services pour les fournisseurs (natifs)

Spécifier le fichier makefile de l'idl du watchdog de la voiture

Ajouter une règle SELinux

exemple_client.te

contextes_fichiers

Implémenter une classe client en héritant de BnCarWatchdogClient

ExempleNatifClient.h

ExempleNatifClient.cpp

Démarrer un thread de liaison et enregistrer le client

main.cpp

ExempleNatifClient.cpp

Services pour les fournisseurs (Android)

Implémenter un client en héritant de CarWatchdogClientCallback

Enregistrer le client

Annuler l'enregistrement du client

Détecter les processus arrêtés par le watchdog de la voiture