监控系统运行状况

监控定时器会监控供应商服务和 VHAL 服务的运行状况,并终止任何运行状况不佳的进程。运行状况不佳的进程被终止后,监控定时器会将进程状态转储至 /data/anr,如同其他应用无响应 (ANR) 转储一样。这样做有助于进行进程调试。

供应商服务运行状况监控

供应商服务在原生端和 Java 端进行监控。如需监控某个供应商服务,该服务必须通过指定预定义的超时时间,向监控定时器注册运行状况检查进程。监控定时器会按注册期间指定的超时时间的相对间隔时间,对已注册的运行状况检查进程执行 ping 操作,从而监控其运行况。如果对其执行 ping 操作的进程在超时时间内没有响应,则该进程会被视为运行状况不佳。

原生服务运行状况监控

指定监控定时器 AIDL makefile

  1. shared_libs 中添加 carwatchdog_aidl_interface-ndk_platform

    Android.bp

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

添加 SELinux 政策

  1. 如需添加 SELinux 政策,请允许供应商服务域使用 binder(binder_use 宏),并将供应商服务域添加到 carwatchdog 客户端域(carwatchdog_client_domain 宏)中。请参阅 sample_client.tefile_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
    

通过继承 BnCarWatchdogClient 实现客户端类

  1. checkIfAlive 中,执行健康检查。一种选择是发布到线程循环处理程序。如果运行状况良好,则调用 ICarWatchdog::tellClientAlive。 请参阅 SampleNativeClient.hSampleNativeClient.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);
    }
    

启动 binder 线程并注册客户端

汽车监控定时器守护程序的接口名称为 android.automotive.watchdog.ICarWatchdog/default

  1. 使用名称搜索守护程序并调用 ICarWatchdog::registerClient。 请参阅 main.cppSampleNativeClient.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);
    }
    

Java 服务运行状况监控

通过继承 CarWatchdogClientCallback 实现客户端

  1. 按下面所示修改新文件:
    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() {}
    };
    

注册客户端

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

取消注册客户端

  1. 服务完成时调用 CarWatchdogManager.unregisterClient()
    private void finishClient() {
        CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(
            Car.CAR_WATCHDOG_SERVICE);
        manager.unregisterClient(mClientCallback);
    }
    

VHAL 运行状况监控

与供应商服务运行状况监控不同,监控定时器通过订阅 VHAL_HEARTBEAT 车辆属性监控 VHAL 服务运行状况。监控定时器预期此属性的值每 N 秒更新一次。如果未在此超时时间内更新检测信号,监控定时器会终止 VHAL 服务。

注意:只有在 VHAL 服务支持 VHAL_HEARTBEAT 车辆属性时,监控定时器才会监控 VHAL 服务运行状况。

VHAL 内部实现可能因供应商而异。以下代码示例可用作参考。

  1. 注册 VHAL_HEARTBEAT 车辆属性。

    启动 VHAL 服务时,请注册 VHAL_HEARTBEAT 车辆属性。 以下示例使用将属性 ID 映射到配置的 unordered_map,以保存所有受支持的配置。系统会将 VHAL_HEARTBEAT 的配置添加到地图中,以便在查询 VHAL_HEARTBEAT 时,返回相应的配置。

    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. 更新 VHAL_HEARTBEAT 车辆属性。

    根据 VHAL 运行状况检查频率(详见定义 VHAL 运行状况检查的频率)后,每 N 秒更新一次 VHAL_HEARTBEAT 车辆属性。 为此,一种方法是使用 RecurrentTimer,以调用用于检查 VHAL 运行状况并在超时时间内更新 VHAL_HEARTBEAT 车辆属性的操作。

    下面显示了一个使用 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. (可选)定义 VHAL 运行状况检查的频率。

    监控定时器的 ro.carwatchdog.vhal_healthcheck.interval 只读产品属性用于定义 VHAL 运行状况检查频率。如未定义该属性,默认运行状况检查频率为三 (3) 秒一次。如果三 (3) 秒不足以让 VHAL 服务更新 VHAL_HEARTBEAT 车辆属性,请根据服务响应速度定义 VHAL 运行状况检查频率。

调试由监控定时器终止的运行状况不佳的进程

监控定时器会转储进程状态并终止运行状况不佳的进程。终止运行状况不佳的进程时,监控定时器会将文本 carwatchdog terminated <process name> (pid:<process id>) 记录到 logcat 中。此日志行提供有关已终止进程的信息,例如进程名称和进程 ID。

  1. 您可以通过运行以下命令,在 logcat 中搜索上述文本:
    $ adb logcat -s CarServiceHelper | fgrep "carwatchdog killed"
    

    例如,如果 KitchenSink 应用是已注册的监控定时器客户端,并且对监控定时器 ping 无响应,监控定时器会在终止已注册的 KitchenSink 进程时记录如下行。

    05-01 09:50:19.683   578  5777 W CarServiceHelper: carwatchdog killed com.google.android.car.kitchensink (pid: 5574)
    
  2. 如需确定无响应的根本原因,请使用存储在 /data/anr 中的进程转储,就像将其用于 Activity ANR 时一样。如需检索已终止进程的转储文件,请使用以下命令。
    $ adb root
    $ adb shell grep -Hn "pid process_pid" /data/anr/*
    

    以下示例输出特定于 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 -----
    

    已终止的 KitchenSink 进程的转储文件位于 /data/anr/anr_2020-05-01-09-50-18-290。请使用已终止进程的 ANR 转储文件开始进行分析。