O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Esta página foi traduzida pela API Cloud Translation.

Monitorar a integridade do sistema

O Watchdog monitora a integridade dos serviços do fornecedor e do serviço VHAL e encerra qualquer processo não saudável. Quando um processo com problemas é encerrado, o Watchdog salva o status do processo em /data/anr, como em outros despejos de O app não está respondendo (ANR). Isso facilita o processo de depuração.

Monitoramento da integridade do serviço do fornecedor

Os serviços do fornecedor são monitorados no nível nativo e em Java. Para que um serviço do fornecedor seja monitorado, ele precisa registrar um processo de verificação de integridade com o Watchdog especificando um tempo limite predefinido. O Watchdog monitora a integridade de um processo de verificação de integridade registrado fazendo um ping nele em um intervalo relativo ao tempo limite especificado durante o registro. Quando um processo com ping não responde dentro do tempo limite, ele é considerado não íntegro.

Monitoramento de integridade de serviços nativos

Especificar o makefile AIDL do Watchdog

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 do SELinux

Para adicionar uma política do SELinux, permita que o domínio de serviço do fornecedor use o binder (macro binder_use) e adicione o domínio de serviço do fornecedor ao domínio de cliente carwatchdog (macro carwatchdog_client_domain). Confira o código abaixo para sample_client.te e file_contexts:
sample_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)
```
file_contexts
```
/vendor/bin/sample_native_client  u:object_r:sample_client_exec:s0
```

Implementar uma classe de cliente herdando o BnCarWatchdogClient

Em checkIfAlive, faça uma verificação de integridade. Uma opção é postar no gerenciador de loops de linha de execução. Se estiver tudo certo, 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 do watchdog do carro é android.automotive.watchdog.ICarWatchdog/default.

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

Monitoramento da integridade do serviço Java

Implementar um cliente herdando o 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);
}

Monitoramento da integridade do VHAL

Ao contrário do monitoramento de integridade do serviço do fornecedor, o Watchdog monitora a integridade do serviço VHAL se inscrevendo na propriedade do veículo VHAL_HEARTBEAT. O Watchdog espera que o valor dessa propriedade seja atualizado uma vez a cada N segundos. Quando o heartbeat não é atualizado dentro desse tempo limite, o Watchdog encerra o serviço VHAL.

Observação:o Watchdog monitora a integridade do serviço VHAL somente quando a propriedade do veículo VHAL_HEARTBEAT é compatível com o serviço VHAL.

A implementação interna do VHAL pode variar de acordo com o fornecedor. Use os exemplos de código abaixo como referência.

Registre a propriedade do veículo do VHAL_HEARTBEAT.
Ao iniciar o serviço VHAL, registre a propriedade do veículo VHAL_HEARTBEAT. No exemplo abaixo, um unordered_map, que mapeia o ID da propriedade para a configuração, é usado para armazenar todas as configurações compatíveis. A configuração de VHAL_HEARTBEAT é adicionada ao mapa. Assim, quando VHAL_HEARTBEAT é consultado, a configuração correspondente é retornada.
```
void registerVhalHeartbeatProperty() {
        const VehiclePropConfig config = {
                .prop = toInt(VehicleProperty::VHAL_HEARTBEAT),
                .access = VehiclePropertyAccess::READ,
                .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
        };
       // mConfigsById is declared as std::unordered_map<int32_t, VehiclePropConfig>.
       mConfigsById[config.prop] = config;
}
```

Atualize a propriedade do veículo do VHAL_HEARTBEAT.

Com base na frequência de verificação de integridade do VHAL (explicada em Definir a frequência da verificação de integridade do VHAL), atualize a propriedade do veículo VHAL_HEARTBEAT uma vez a cada N segundos. Uma maneira de fazer isso é usar o RecurrentTimer para chamar a ação que verifica a integridade do VHAL e atualiza a propriedade do veículo VHAL_HEARTBEAT dentro do tempo limite.

Confira abaixo um exemplo de implementação usando RecurrentTimer:

int main(int argc, char** argv) {
        RecurrentTimer recurrentTimer(updateVhalHeartbeat);
        recurrentTimer.registerRecurrentEvent(kHeartBeatIntervalNs,
                                           static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT));
        … Run service …
        recurrentTimer.unregisterRecurrentEvent(
                static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT));
}

void updateVhalHeartbeat(const std::vector<int32_t>& cookies) {
       for (int32_t property : cookies) {
              if (property != static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT)) {
                     continue;
              }

              // Perform internal health checking such as retrieving a vehicle property to ensure
              // the service is responsive.
              doHealthCheck();

              // Construct the VHAL_HEARTBEAT property with system uptime.
              VehiclePropValuePool valuePool;
              VehicleHal::VehiclePropValuePtr propValuePtr = valuePool.obtainInt64(uptimeMillis());
              propValuePtr->prop = static_cast<int32_t>(VehicleProperty::VHAL_HEARTBEAT);
              propValuePtr->areaId = 0;
              propValuePtr->status = VehiclePropertyStatus::AVAILABLE;
              propValuePtr->timestamp = elapsedRealtimeNano();

              // Propagate the HAL event.
              onHalEvent(std::move(propValuePtr));
       }
}

(Opcional) Defina a frequência da verificação de integridade do VHAL.
A propriedade de produto ro.carwatchdog.vhal_healthcheck.interval somente leitura do Watchdog define a frequência da verificação de integridade do VHAL. A frequência padrão de verificação de integridade (quando esta propriedade não está definida) é de três segundos. Se três segundos não forem suficientes para que o serviço VHAL atualize a propriedade do veículo VHAL_HEARTBEAT, defina a frequência de verificação de integridade do VHAL dependendo da capacidade de resposta do serviço.

Depurar processos não íntegros encerrados pelo watchdog

O Watchdog descarta o estado do processo e encerra processos não íntegros. Ao encerrar um processo não saudável, o Watchdog registra o texto carwatchdog terminated <process name> (pid:<process id>) no Logcat. Essa linha de registro fornece informações sobre o processo encerrado, como o nome e o ID do processo.

O logcat pode ser pesquisado para encontrar o texto mencionado acima executando:
```
$ adb logcat -s CarServiceHelper | fgrep "carwatchdog killed"
```
Por exemplo, quando o app KitchenSink é um cliente Watchdog registrado e não responde aos pings do Watchdog, o Watchdog registra uma linha como a linha abaixo ao encerrar o processo registrado do KitchenSink.
```
05-01 09:50:19.683   578  5777 W CarServiceHelper: carwatchdog killed com.google.android.car.kitchensink (pid: 5574)
```
Para identificar a causa raiz da falta de resposta, use o despejo de processo armazenado em /data/anr da mesma forma que você usaria para casos de ANR de atividade. Para recuperar o arquivo de despejo do processo encerrado, use os comandos abaixo.
```
$ 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 -----
```
O arquivo dump do processo do KitchenSink encerrado está localizado em /data/anr/anr_2020-05-01-09-50-18-290. Inicie a análise usando o arquivo de despejo ANR do processo encerrado.