Watchdog do carro

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

1. Inclua carwatchdog_aidl_interface-ndk_platform em 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",
       ],
   }
   

Adicionar uma política SELinux

1. Permitir que system_server elimine a HAL. Se você não tiver system_server.te, crie uma. É altamente recomendamos adicionar uma política de SELinux a cada dispositivo.
2. Permitir que a HAL do fornecedor use o binder (macro binder_use) e adicionar a HAL do fornecedor ao domínio do cliente carwatchdog (macro carwatchdog_client_domain). Confira o código abaixo para systemserver.te e vehicle_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

1. Em checkIfAlive, execute a verificação de integridade. Por exemplo, postar no gerenciador de loop de linha de execução. Se estiver, chame ICarWatchdog::tellClientAlive. Confira o código abaixo para WatchogClient.h e WatchogClient.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

1. 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).
2. Procure o daemon com o nome e chame ICarWatchdog::registerClient. O nome da interface do daemon watchdog do carro é android.automotive.watchdog.ICarWatchdog/default:
3. 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)
   . Confira o código abaixo para VehicleService.cpp e WatchogClient.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

1. Inclua carwatchdog_aidl_interface-ndk_platform em shared_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

1. 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 ao carwatchdog domínio de cliente (carwatchdog_client_domain macro). Confira o código abaixo para sample_client.te e file_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

1. Em checkIfAlive, execute uma verificação de integridade. Uma opção é postar o gerenciador de loop da linha de execução. Se estiver, chame ICarWatchdog::tellClientAlive. Confira o código abaixo para SampleNativeClient.h e SampleNativeClient.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:

1. Procure o daemon com o nome e chame ICarWatchdog::registerClient. Confira o código abaixo para main.cpp e SampleNativeClient.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

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

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

1. 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 travada 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.