Giám sát tình trạng hệ thống

Watchdog theo dõi tình trạng của các dịch vụ của nhà cung cấp và dịch vụ VHAL, đồng thời chấm dứt mọi quy trình không ổn định. Khi một quy trình không ổn định bị chấm dứt, Watchdog sẽ kết xuất trạng thái quy trình vào /data/anr như với các tệp kết xuất Ứng dụng không phản hồi (ANR) khác. Việc này sẽ tạo điều kiện cho quá trình gỡ lỗi.

Theo dõi tình trạng dịch vụ của nhà cung cấp

Các dịch vụ của nhà cung cấp được giám sát ở cả phía gốc và phía Java. Để được theo dõi, dịch vụ của Nhà cung cấp phải đăng ký quy trình kiểm tra tình trạng với Watchdog bằng cách chỉ định thời gian chờ được xác định trước. Watchdog theo dõi tình trạng của một quy trình kiểm tra tình trạng đã đăng ký bằng cách ping quy trình đó theo một khoảng thời gian tương ứng với thời gian chờ được chỉ định trong quá trình đăng ký. Khi một quy trình được ping không phản hồi trong khoảng thời gian chờ, quy trình đó được coi là không ổn định.

Giám sát tình trạng của dịch vụ gốc

Chỉ định tệp makefile AIDL của Bộ theo dõi

1. Thêm carwatchdog_aidl_interface-ndk_platform vào shared_libs.

   Android.bp

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

Thêm chính sách SELinux

1. Để thêm chính sách SELinux, hãy cho phép miền dịch vụ của nhà cung cấp sử dụng trình liên kết (macro binder_use) và thêm miền dịch vụ của nhà cung cấp vào miền ứng dụng carwatchdog (macro carwatchdog_client_domain). Xem mã bên dưới cho sample_client.te và 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
   

Triển khai một lớp ứng dụng bằng cách kế thừa BnCarWatchdogClient

1. Trong checkIfAlive, hãy kiểm tra tình trạng. Một cách là đăng lên trình xử lý vòng lặp luồng. Nếu khỏe mạnh, hãy gọi ICarWatchdog::tellClientAlive. Xem mã bên dưới cho SampleNativeClient.h và 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);
   }
   

Bắt đầu luồng liên kết và đăng ký ứng dụng

Tên giao diện trình nền theo dõi tình trạng xe là android.automotive.watchdog.ICarWatchdog/default.

1. Tìm trình nền theo tên và gọi ICarWatchdog::registerClient. Xem mã bên dưới cho main.cpp và 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);
   }
   

Giám sát tình trạng dịch vụ Java

Triển khai ứng dụng bằng cách kế thừa CarWatchdogClientCallback

1. Chỉnh sửa tệp mới như sau:

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

Đăng ký ứng dụng

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

Huỷ đăng ký ứng dụng

1. Gọi CarWatchdogManager.unregisterClient() khi dịch vụ hoàn tất:

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

Giám sát tình trạng VHAL

Không giống như tính năng theo dõi tình trạng dịch vụ của nhà cung cấp, Watchdog theo dõi tình trạng dịch vụ VHAL bằng cách đăng ký thuộc tính xe VHAL_HEARTBEAT. Watchdog dự kiến giá trị của thuộc tính này sẽ được cập nhật một lần sau mỗi N giây. Khi nhịp tim không được cập nhật trong khoảng thời gian chờ này, Watchdog sẽ chấm dứt dịch vụ VHAL.

Lưu ý: Watchdog chỉ theo dõi tình trạng của dịch vụ VHAL khi dịch vụ VHAL hỗ trợ thuộc tính xe VHAL_HEARTBEAT.

Cách triển khai VHAL nội bộ có thể khác nhau tuỳ theo nhà cung cấp. Hãy sử dụng các mã mẫu sau đây làm tài liệu tham khảo.

1. Đăng ký thuộc tính xe VHAL_HEARTBEAT.

   Khi bắt đầu dịch vụ VHAL, hãy đăng ký thuộc tính xe VHAL_HEARTBEAT. Trong ví dụ bên dưới, unordered_map liên kết mã thuộc tính với cấu hình được dùng để lưu giữ tất cả cấu hình được hỗ trợ. Cấu hình cho VHAL_HEARTBEAT được thêm vào bản đồ để khi truy vấn VHAL_HEARTBEAT, cấu hình tương ứng sẽ được trả về.

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

2. Cập nhật thuộc tính xe VHAL_HEARTBEAT.

   Dựa trên tần suất kiểm tra tình trạng VHAL (được giải thích trong phần Xác định tần suất kiểm tra tình trạng VHAL"), hãy cập nhật thuộc tính xe VHAL_HEARTBEAT mỗi N giây một lần. Có một cách để thực hiện việc này là sử dụng RecurrentTimer để gọi thao tác kiểm tra tình trạng VHAL và cập nhật thuộc tính xe VHAL_HEARTBEAT trong thời gian chờ.

   Dưới đây là ví dụ về cách triển khai mẫu bằng 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));
          }
   }
   

3. (Không bắt buộc) Xác định tần suất kiểm tra tình trạng của VHAL.

   Thuộc tính sản phẩm chỉ có thể đọc ro.carwatchdog.vhal_healthcheck.interval của Watchdog xác định tần suất kiểm tra tình trạng VHAL. Tần suất kiểm tra tình trạng mặc định (khi thuộc tính này không được xác định) là 3 giây. Nếu 3 giây là không đủ để dịch vụ VHAL cập nhật thuộc tính xe VHAL_HEARTBEAT, hãy xác định tần suất kiểm tra tình trạng của VHAL tuỳ thuộc vào khả năng phản hồi của dịch vụ.

Gỡ lỗi các quy trình không ổn định do Watchdog chấm dứt

Watchdog sẽ kết xuất trạng thái của quy trình và chấm dứt các quy trình không ổn định. Khi chấm dứt một quy trình không ổn định, Watchdog sẽ ghi nhật ký văn bản carwatchdog terminated <process name> (pid:<process id>) vào logcat. Dòng nhật ký này cung cấp thông tin về quy trình kết thúc, chẳng hạn như tên quy trình và mã nhận dạng quy trình.

1. Bạn có thể tìm kiếm văn bản nêu trên trong logcat bằng cách chạy:

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

   Ví dụ: khi ứng dụng KitchenSink là ứng dụng Watchdog đã đăng ký và không phản hồi ping Watchdog, Watchdog sẽ ghi lại một dòng như dòng bên dưới khi chấm dứt quy trình KitchenSink đã đăng ký.

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

2. Để xác định nguyên nhân gốc rễ của tình trạng không phản hồi, hãy sử dụng tệp báo lỗi quy trình được lưu trữ tại /data/anr giống như bạn sẽ sử dụng cho các trường hợp ANR của hoạt động. Để truy xuất tệp kết xuất cho quy trình đã kết thúc, hãy sử dụng các lệnh dưới đây.

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

   Kết quả mẫu sau đây dành riêng cho ứng dụng 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 -----
   

   Tệp báo lỗi cho quá trình KitchenSink đã chấm dứt nằm tại /data/anr/anr_2020-05-01-09-50-18-290. Bắt đầu phân tích bằng cách sử dụng tệp báo lỗi ANR của quy trình đã chấm dứt.