anjing penjaga mobil

Gunakan pengawas mobil untuk membantu men-debug VHAL. Pengawas mobil memantau kesehatan — dan membunuh — proses yang tidak sehat. Agar suatu proses dapat dimonitor oleh car watchdog, proses tersebut harus didaftarkan pada car watchdog. Ketika pengawas mobil menghentikan proses yang tidak sehat, pengawas mobil menulis status proses ke data/anr seperti pada dump Application Not Responding (ANR) lainnya. Melakukannya akan memudahkan proses debugging.

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

Penjual HAL

Biasanya, vendor HAL menggunakan kumpulan utas untuk hwbinder . Namun, klien pengawas mobil berkomunikasi dengan daemon pengawas mobil melalui binder , yang berbeda dari hwbinder . Oleh karena itu, kumpulan utas lain untuk binder sedang digunakan.

Tentukan bantuan pengawas mobil di makefile

1. 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",
       ],
   }
   

Tambahkan Kebijakan SELinux

1. Izinkan system_server untuk membunuh HAL Anda. Jika Anda tidak memiliki system_server.te , buatlah. Sangat disarankan Anda menambahkan kebijakan SELinux ke setiap perangkat.
2. Izinkan vendor HAL untuk menggunakan binder ( makro binder_use ) dan tambahkan HAL vendor ke domain klien carwatchdog ( makro carwatchdog_client_domain ). Lihat kode di bawah ini 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)
   

Menerapkan kelas klien dengan mewarisi BnCarWatchdogClient

1. Di checkIfAlive , lakukan pemeriksaan kesehatan. Misalnya, posting ke penangan loop utas. Jika sehat, hubungi ICarWatchdog::tellClientAlive . Lihat kode di bawah ini 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();
   }
   

Mulai utas pengikat dan daftarkan klien

1. Buat kumpulan utas untuk komunikasi pengikat. Jika vendor HAL menggunakan hwbinder untuk tujuannya sendiri, Anda harus membuat kumpulan utas lain untuk komunikasi pengikat pengawas mobil).
2. Cari daemon dengan nama dan panggil ICarWatchdog::registerClient . Nama antarmuka daemon pengawas mobil adalah android.automotive.watchdog.ICarWatchdog/default .
3. Berdasarkan responsivitas layanan, pilih salah satu dari tiga jenis batas waktu berikut yang didukung oleh pengawas mobil dan kemudian berikan batas waktu dalam panggilan ke ICarWatchdog::registerClient :
   • kritis(3s)
   • sedang (5 detik)
   • biasa (10 detik)
   Lihat kode di bawah ini untuk VehicleService.cpp dan WatchogClient.cpp :

   Layanan Kendaraan.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 (Asli)

Tentukan car watchdog aidl makefile

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

Tambahkan kebijakan SELinux

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

Menerapkan kelas klien dengan mewarisi BnCarWatchdogClient

1. Di checkIfAlive , lakukan pemeriksaan kesehatan. Salah satu opsi adalah memposting ke penangan loop utas. Jika sehat, hubungi ICarWatchdog::tellClientAlive . Lihat kode di bawah ini 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);
   }
   

Mulai utas pengikat dan daftarkan klien

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

1. Cari daemon dengan nama dan panggil ICarWatchdog::registerClient . Lihat kode di bawah ini 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 Penjual (Android)

Terapkan klien dengan mewarisi CarWatchdogClientCallback

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

Daftarkan klien

1. 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);
   }
   

Batalkan pendaftaran klien

1. Panggil CarWatchdogManager.unregisterClient() saat layanan selesai:

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

Deteksi proses yang dihentikan oleh pengawas mobil

Car watchdog dumps/kills process (vendor HAL, vendor native services, vendor Android services) yang didaftarkan ke car watchdog saat macet dan tidak responsif. Dumping tersebut dideteksi dengan memeriksa logcats. Pengawas mobil mengeluarkan 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 ditangkap. Misalnya, jika aplikasi KitchenSink (klien pengawas mobil) macet, baris seperti di bawah ini 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 mengapa atau di mana aplikasi KitchenSink macet, gunakan dump proses yang disimpan di /data/anr seperti halnya Anda menggunakan kasus ANR Aktivitas.

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

Contoh keluaran 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.