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

Halaman ini diterjemahkan oleh Cloud Translation API.

Pengawas Mobil

Gunakan car watchdog untuk membantu men-debug VHAL. Monitor watchdog mobil kesehatan — dan membunuh — proses yang tidak sehat. Agar proses dipantau oleh watchdog mobil, proses harus didaftarkan di watchdog mobil. Kapan {i>watchdog<i} mobil membunuh proses yang tidak sehat, {i>watchdog<i} mobil menulis status proses ke data/anr seperti halnya Aplikasi Tidak Merespons lainnya dump (ANR). Tindakan ini akan memudahkan proses debug.

Artikel ini menjelaskan bagaimana HAL vendor dan layanan dapat mendaftarkan proses dengan watchdog mobil.

HAL Vendor

Biasanya, HAL vendor menggunakan kumpulan thread untuk hwbinder. Namun, klien watchdog mobil berkomunikasi dengan {i>daemon watchdog<i} mobil 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 untuk mematikan HAL Anda. Jika Anda tidak memiliki system_server.te, buat akun. Sangat kuat menyarankan Anda untuk menambahkan 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 health check. Misalnya, posting ke sebagai 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 vendor HAL menggunakan hwbinder untuk tujuan Anda sendiri, Anda harus membuat kumpulan thread lain untuk komunikasi binder watchdog mobil).
Telusuri daemon dengan nama dan panggil ICarWatchdog::registerClient. Nama antarmuka {i>daemon<i} watchdog mobil adalah android.automotive.watchdog.ICarWatchdog/default.

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

kritis(3d)
sedang(5 dtk)
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 bantuan 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 carwatchdog domain klien (makro carwatchdog_client_domain). Lihat kode di bawah untuk sample_client.te dan file_contexts:
klien_contoh.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)
```
konteks_file
```
/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 pilihan adalah untuk memposting ke pengendali loop thread. Jika responsif, 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 {i>daemon<i} 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

Hubungi 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 watchdog mobil

Proses pembuangan/pemusnahan dari watchdog (vendor HAL, layanan asli vendor, layanan Android vendor) yang terdaftar di watchdog mobil saat mereka macet dan tidak responsif. Dumping tersebut terdeteksi dengan memeriksa logcat. Mobil watchdog menghasilkan log carwatchdog killed process_name (pid:process_id) ketika proses yang bermasalah dibuang atau dimatikan. Oleh karena itu:

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

Log yang relevan akan direkam. Misalnya, jika aplikasi KitchenSink (pengawas mobil klien) menjadi macet, baris seperti di bawah ini ditulis ke log:

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

Untuk mengetahui alasan atau di mana aplikasi KitchenSink macet, gunakan pembuangan proses disimpan di /data/anr seperti Anda menggunakan 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 -----

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

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 bantuan watchdog mobil

Menambahkan kebijakan SELinux

klien_contoh.te

konteks_file

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 watchdog mobil