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
dansshared_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 desystem_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 clientcarwatchdog
(macrocarwatchdog_client_domain
). Consultez le code ci-dessous poursystemserver.te
etvehicle_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, appelezICarWatchdog::tellClientAlive
. Consultez le code ci-dessous pourWatchogClient.h
etWatchogClient.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 estandroid.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">- </ph>
- critique(3 s)
- modérée(5 s)
- normal(10s)
VehicleService.cpp
etWatchogClient.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
dansshared_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 clientcarwatchdog
(macrocarwatchdog_client_domain
). Consultez le code ci-dessous poursample_client.te
etfile_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, appelezICarWatchdog::tellClientAlive
. Consultez le code ci-dessous pourSampleNativeClient.h
etSampleNativeClient.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 pourmain.cpp
etSampleNativeClient.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.