Google berkomitmen untuk mendorong terwujudnya keadilan ras bagi komunitas Kulit Hitam. Lihat caranya.

Halaman ini diterjemahkan oleh Cloud Translation API.

Pengawas Mobil

Gunakan watchdog mobil untuk membantu men-debug VHAL. Watchdog mobil memantau kondisi dan membunuh proses yang tidak sehat. Agar proses dapat dipantau oleh watchdog mobil, proses tersebut harus terdaftar di watchdog mobil. Saat car watchdog menghentikan proses yang tidak sehat, car watchdog akan menulis status proses ke data/anr seperti dump Aplikasi Tidak Merespons (ANR) lainnya. Tindakan ini akan memfasilitasi proses proses debug.

Artikel ini menjelaskan cara HAL dan layanan vendor dapat mendaftarkan proses ke watchdog mobil.

HAL Vendor

Biasanya, HAL vendor menggunakan kumpulan thread untuk hwbinder. Namun, klien car watchdog berkomunikasi dengan daemon car watchdog melalui binder, yang berbeda dengan hwbinder. Oleh karena itu, kumpulan thread lain untuk binder sedang digunakan.

Menentukan aidl watchdog mobil di makefile

Sertakan carwatchdog_aidl_interface-ndk_platform di 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",
    ],
}

Menambahkan Kebijakan SELinux

Izinkan system_server menghentikan HAL Anda. Jika Anda tidak memiliki system_server.te, buat system_server.te. Sebaiknya tambahkan kebijakan SELinux ke setiap perangkat.
Izinkan HAL vendor menggunakan binder (makro binder_use) dan tambahkan HAL vendor ke domain klien carwatchdog (makro carwatchdog_client_domain). Lihat kode di bawah untuk systemserver.te dan 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)
```

Mengimplementasikan class klien dengan mewarisi BnCarWatchdogClient

Di checkIfAlive, lakukan pemeriksaan kesehatan. Misalnya, posting ke pengendali loop thread. Jika responsif, panggil ICarWatchdog::tellClientAlive. Lihat kode di bawah untuk WatchogClient.h dan 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;
};

WatchogClient.cpp

ndk::ScopedAStatus WatchdogClient::checkIfAlive(int32_t sessionId, TimeoutLength /*timeout*/) {
    // Implement or call your health check logic here
    return ndk::ScopedAStatus::ok();
}

Memulai thread binder dan mendaftarkan klien

Membuat kumpulan thread untuk komunikasi binder. Jika HAL vendor menggunakan hwbinder untuk tujuannya sendiri, Anda harus membuat kumpulan thread lain untuk komunikasi binder car watchdog).
Telusuri daemon dengan nama dan panggil ICarWatchdog::registerClient. Nama antarmuka daemon watchdog mobil adalah android.automotive.watchdog.ICarWatchdog/default.

Berdasarkan responsivitas layanan, pilih salah satu dari tiga jenis waktu tunggu berikut yang didukung oleh car watchdog, lalu teruskan waktu tunggu dalam panggilan ke ICarWatchdog::registerClient:

kritis(3 dtk)
sedang(5 detik)
normal(10 dtk)

Lihat kode di bawah untuk VehicleService.cpp dan WatchogClient.cpp:

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

Layanan Vendor (Native)

Menentukan makefile aidl watchdog mobil

Sertakan carwatchdog_aidl_interface-ndk_platform di shared_libs.

Android.bp

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

Menambahkan kebijakan SELinux

Untuk menambahkan kebijakan SELinux, izinkan domain layanan vendor menggunakan binder (makro binder_use) dan tambahkan domain layanan vendor ke domain klien carwatchdog (makro carwatchdog_client_domain). Lihat kode di bawah untuk sample_client.te dan 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
```

Mengimplementasikan class klien dengan mewarisi BnCarWatchdogClient

Di checkIfAlive, lakukan health check. Salah satu opsi adalah memposting ke pengendali loop thread. Jika sehat, panggil ICarWatchdog::tellClientAlive. Lihat kode di bawah untuk SampleNativeClient.h dan 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);
}

Memulai thread binder dan mendaftarkan klien

Nama antarmuka daemon watchdog mobil adalah android.automotive.watchdog.ICarWatchdog/default.

Telusuri daemon dengan nama dan panggil ICarWatchdog::registerClient. Lihat kode di bawah untuk main.cpp dan 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);
}

Layanan Vendor (Android)

Mengimplementasikan klien dengan mewarisi CarWatchdogClientCallback

Edit file baru sebagai berikut:

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

Mendaftarkan klien

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

Membatalkan pendaftaran klien

Panggil CarWatchdogManager.unregisterClient() saat layanan selesai:

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

Mendeteksi proses yang dihentikan oleh car watchdog

Proses dump/kills watchdog mobil (vendor HAL, layanan native vendor, layanan Android vendor) yang didaftarkan ke watchdog mobil saat mengalami masalah dan tidak responsif. Dumping tersebut terdeteksi dengan memeriksa logcat. Watchdog mobil menghasilkan log carwatchdog killed process_name (pid:process_id) saat proses yang bermasalah di-dump atau dihentikan. Oleh karena itu:

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

Log yang relevan akan direkam. Misalnya, jika aplikasi KitchenSink (klien car watchdog) berhenti berfungsi, baris seperti di bawah akan ditulis ke log:

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

Untuk menentukan alasan atau tempat aplikasi KitchenSink macet, gunakan dump proses yang disimpan di /data/anr seperti yang Anda gunakan untuk kasus ANR Aktivitas.

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

Contoh output berikut khusus untuk aplikasi 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 -----

Temukan file dump (misalnya, /data/anr/anr_2020-05-01-09-50-18-290 dalam contoh di atas) dan mulai analisis Anda.

Pengawas Mobil

HAL Vendor

Menentukan aidl watchdog mobil di makefile

Menambahkan Kebijakan SELinux

system_server.te

hal_vehicle_default.te

Mengimplementasikan class klien dengan mewarisi BnCarWatchdogClient

WatchogClient.h

WatchogClient.cpp

Memulai thread binder dan mendaftarkan klien

VehicleService.cpp

WatchogClient.cpp

Layanan Vendor (Native)

Menentukan makefile aidl watchdog mobil

Menambahkan kebijakan SELinux

sample_client.te

file_contexts

Mengimplementasikan class klien dengan mewarisi BnCarWatchdogClient

SampleNativeClient.h

SampleNativeClient.cpp

Memulai thread binder dan mendaftarkan klien

main.cpp

SampleNativeClient.cpp

Layanan Vendor (Android)

Mengimplementasikan klien dengan mewarisi CarWatchdogClientCallback

Mendaftarkan klien

Membatalkan pendaftaran klien

Mendeteksi proses yang dihentikan oleh car watchdog