Use o Watchdog do carro para ajudar a depurar a VHAL. Monitores de vigilância para carros
a integridade e a eliminação de processos não saudáveis. Para que um processo seja monitorado
pelo watchdog do carro, esse processo precisa ser registrado nele. Quando
o watchdog do carro elimina processos não íntegros, o watchdog do carro grava o status
os processos para data/anr
, assim como acontece com outros aplicativos que não estão respondendo.
(ANR). Isso facilita o processo de depuração.
Este artigo descreve como as HALs e os serviços do fornecedor podem registrar um processo com o watchdog do carro.
HAL do fornecedor
Normalmente, a HAL do fornecedor usa um pool de linhas de execução para hwbinder
. No entanto,
o cliente do watchdog do carro se comunica com o daemon do watchdog do carro por meio
binder
, que é diferente de hwbinder
. Portanto,
outro pool de linhas de execução para binder
está em uso.
Especificar o auxiliar do watchdog do carro no makefile
- Inclua
carwatchdog_aidl_interface-ndk_platform
emshared_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", ], }
Adicionar uma política SELinux
-
Permitir que
system_server
elimine a HAL. Se você não tiversystem_server.te
, crie uma. É altamente recomendamos adicionar uma política de SELinux a cada dispositivo. -
Permitir que a HAL do fornecedor use o binder (macro
binder_use
) e adicionar a HAL do fornecedor ao domínio do clientecarwatchdog
(macrocarwatchdog_client_domain
). Confira o código abaixo parasystemserver.te
evehicle_default.te
: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)
Implementar uma classe de cliente herdando BnCarWatchdogClient
-
Em
checkIfAlive
, execute a verificação de integridade. Por exemplo, postar no gerenciador de loop de linha de execução. Se estiver, chameICarWatchdog::tellClientAlive
. Confira o código abaixo paraWatchogClient.h
eWatchogClient.cpp
: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; };Assistir ao cliente.cpp
ndk::ScopedAStatus WatchdogClient::checkIfAlive(int32_t sessionId, TimeoutLength /*timeout*/) { // Implement or call your health check logic here return ndk::ScopedAStatus::ok(); }
Iniciar a linha de execução de vinculação e registrar o cliente
- Criar um pool de linhas de execução para comunicação do binder. Se a HAL do fornecedor usar o hwbinder para o para fins próprios, é necessário criar outro pool de linhas de execução para comunicação do binder do watchdog do carro).
-
Procure o daemon com o nome e chame
ICarWatchdog::registerClient
. O nome da interface do daemon watchdog do carro éandroid.automotive.watchdog.ICarWatchdog/default
: -
Com base na capacidade de resposta do serviço, selecione um dos três tipos de tempo limite a seguir
suportado pelo watchdog do carro e, em seguida, passa o tempo limite na chamada do
ICarWatchdog::registerClient
:- crítico(3s)
- moderado(5 s)
- normal(10s)
VehicleService.cpp
eWatchogClient.cpp
:Veículos.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; }
Assistir ao cliente.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; }
Serviços de fornecedores (nativos)
Especificar o makefile de auxílio do watchdog do carro
- Inclua
carwatchdog_aidl_interface-ndk_platform
emshared_libs
.Android.bp
cc_binary { name: "sample_native_client", srcs: [ "src/*.cpp" ], shared_libs: [ "carwatchdog_aidl_interface-ndk_platform", "libbinder_ndk", ], vendor: true, }
Adicionar uma política SELinux
- Para adicionar uma política do SELinux, permitir que o domínio de serviço do fornecedor use um binder
(macro
binder_use
) e adicione o domínio de serviço do fornecedor aocarwatchdog
domínio de cliente (carwatchdog_client_domain
macro). Confira o código abaixo parasample_client.te
efile_contexts
:cliente_de_amostra.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)
contextos_do_arquivo
/vendor/bin/sample_native_client u:object_r:sample_client_exec:s0
Implementar uma classe de cliente herdando BnCarWatchdogClient
- Em
checkIfAlive
, execute uma verificação de integridade. Uma opção é postar o gerenciador de loop da linha de execução. Se estiver, chameICarWatchdog::tellClientAlive
. Confira o código abaixo paraSampleNativeClient.h
eSampleNativeClient.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); }
Iniciar uma linha de execução de vinculação e registrar o cliente
O nome da interface do daemon watchdog do carro é
android.automotive.watchdog.ICarWatchdog/default
:
- Procure o daemon com o nome e chame
ICarWatchdog::registerClient
. Confira o código abaixo paramain.cpp
eSampleNativeClient.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); }
Serviços do fornecedor (Android)
Implementar um cliente herdando CarWatchdogClientCallback
- Edite o novo arquivo da seguinte forma:
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() {} };
Registrar o cliente
- Ligue para
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); }
Cancelar o registro do cliente
- Chame
CarWatchdogManager.unregisterClient()
quando o serviço for concluído:private void finishClient() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager( Car.CAR_WATCHDOG_SERVICE); manager.unregisterClient(mClientCallback); }
Detectar processos encerrados pelo watchdog do carro
Processos de despejo/eliminações de vigilantes de automóveis (HAL de fornecedor, serviços nativos do fornecedor,
serviços Android do fornecedor) que são registrados no watchdog do carro quando são
parado e não responde. Esse despejo é detectado pela verificação dos logcats. O carro
o watchdog gera um registro carwatchdog killed process_name (pid:process_id)
quando um processo problemático é despejado ou encerrado. Portanto:
$ adb logcat -s CarServiceHelper | fgrep "carwatchdog killed"
Os registros relevantes são capturados. Por exemplo, se o app KitchenSink (um cão de vigilância do carro) cliente) fica preso, uma linha como esta é gravada no registro:
05-01 09:50:19.683 578 5777 W CarServiceHelper: carwatchdog killed com.google.android.car.kitchensink (pid: 5574)
Para determinar por que ou onde o app KitchenSink ficou travado, use o despejo do processo
armazenados em /data/anr
, assim como você usaria casos de ANR de atividade.
$ adb root $ adb shell grep -Hn "pid process_pid" /data/anr/*
O exemplo de saída a seguir é específico para o app 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 -----
Encontre o arquivo dump (por exemplo, /data/anr/anr_2020-05-01-09-50-18-290
).
no exemplo acima) e inicie sua análise.