सिस्टम की परफ़ॉर्मेंस पर नज़र रखना

वॉचडॉग, वेंडर की सेवाओं और VHAL सेवा की स्थिति पर नज़र रखता है. साथ ही, किसी भी खराब प्रोसेस को बंद कर देता है. जब कोई प्रोसेस ठीक से काम नहीं करती है, तो Watchdog उस प्रोसेस की स्थिति को /data/anr में डंप कर देता है. ऐसा ही तब होता है, जब ऐप्लिकेशन काम नहीं कर रहा होता है (एएनआर). ऐसा करने से, डीबग करने की प्रोसेस आसान हो जाती है.

वेंडर की सेवा की परफ़ॉर्मेंस पर नज़र रखना

वेंडर की सेवाओं की निगरानी, नेटिव और Java, दोनों साइड पर की जाती है. किसी वेंडर सेवा की निगरानी करने के लिए, सेवा को वॉचडॉग के साथ हेल्थ चेक करने की प्रोसेस रजिस्टर करनी होगी. इसके लिए, पहले से तय किया गया टाइमआउट बताना होगा. वॉचडॉग, रजिस्टर की गई हेल्थ चेकिंग प्रोसेस की स्थिति पर नज़र रखता है. इसके लिए, वह रजिस्ट्रेशन के दौरान तय किए गए टाइम आउट के हिसाब से, तय समय पर प्रोसेस को पिंग करता है. जब पिंग की गई कोई प्रोसेस, टाइम आउट होने के बाद भी जवाब नहीं देती है, तो उसे अस्वस्थ माना जाता है.

नेटिव सेवा की परफ़ॉर्मेंस पर नज़र रखना

वॉचडॉग के AIDL मेकफ़ाइल के बारे में जानकारी देना

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_use मैक्रो) का इस्तेमाल करने की अनुमति दें. साथ ही, वेंडर सेवा के डोमेन को carwatchdog क्लाइंट डोमेन (carwatchdog_client_domain मैक्रो) में जोड़ें. sample_client.te और 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

BnCarWatchdogClient को इनहेरिट करके, क्लाइंट क्लास लागू करना

1. checkIfAlive में, हेल्थ चेक करें. इसके लिए, थ्रेड लूप हैंडलर को पोस्ट किया जा सकता है. अगर आप ठीक हैं, तो ICarWatchdog::tellClientAlive पर कॉल करें. SampleNativeClient.h और 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);
   }

बाइंडर थ्रेड शुरू करना और क्लाइंट को रजिस्टर करना

कार के वॉचडॉग डेमॉन इंटरफ़ेस का नाम android.automotive.watchdog.ICarWatchdog/default है.

1. नाम से डेमॉन खोजें और ICarWatchdog::registerClient को कॉल करें. main.cpp और 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);
   }

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 की परफ़ॉर्मेंस पर नज़र रखना

वेंडर की सेवा की सेहत की निगरानी करने के बजाय, Watchdog VHAL_HEARTBEAT वाहन की प्रॉपर्टी की सदस्यता लेकर, वीएचएएल सेवा की सेहत की निगरानी करता है. वॉचडॉग को उम्मीद है कि इस प्रॉपर्टी की वैल्यू हर N सेकंड में अपडेट की जाएगी. अगर इस टाइमआउट के दौरान हार्टबीट अपडेट नहीं होता है, तो वॉचडॉग, VHAL सेवा को बंद कर देता है.

ध्यान दें: वॉचडॉग, वीएचएएल सेवा की स्थिति की निगरानी सिर्फ़ तब करता है, जब VHAL_HEARTBEAT वाहन की प्रॉपर्टी को वीएचएएल सेवा से मदद मिलती है.

VHAL को लागू करने का तरीका, वेंडर के हिसाब से अलग-अलग हो सकता है. रेफ़रंस के तौर पर, यहां दिए गए कोड के सैंपल का इस्तेमाल करें.

1. VHAL_HEARTBEAT वाहन की प्रॉपर्टी रजिस्टर करें.

   वीएचएएल सेवा शुरू करते समय, VHAL_HEARTBEAT वाहन की प्रॉपर्टी रजिस्टर करें. नीचे दिए गए उदाहरण में, 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 वाहन की प्रॉपर्टी अपडेट करें.

   वीएचएएल की जांच कितनी बार की जाती है, इसके आधार पर (इसके बारे में वीएचएएल की जांच कितनी बार की जाती है" में बताया गया है), हर N सेकंड में एक बार VHAL_HEARTBEAT वाहन की प्रॉपर्टी अपडेट करें. इसके लिए, RecurrentTimer का इस्तेमाल करके, वीएचएएल की स्थिति की जाँच करने वाली कार्रवाई को कॉल किया जा सकता है. साथ ही, टाइम आउट होने से पहले 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. (ज़रूरी नहीं) वीएचएएल के हेल्थ चेक की फ़्रीक्वेंसी तय करें.

   Watchdog की ro.carwatchdog.vhal_healthcheck.interval read-only प्रॉडक्ट प्रॉपर्टी से, VHAL की परफ़ॉर्मेंस की जांच करने की फ़्रीक्वेंसी तय होती है. अगर इस प्रॉपर्टी को तय नहीं किया जाता है, तो डिफ़ॉल्ट रूप से हेल्थ चेक की फ़्रीक्वेंसी तीन सेकंड होती है. अगर वीएचएएल सेवा को VHAL_HEARTBEAT वाहन की प्रॉपर्टी अपडेट करने में तीन सेकंड से ज़्यादा समय लगता है, तो सेवा की प्रतिक्रिया देने की क्षमता के आधार पर, वीएचएएल की हेल्थ चेक फ़्रीक्वेंसी तय करें.

वॉचडॉग की वजह से बंद की गई खराब प्रोसेस को डीबग करना

वॉचडॉग, प्रोसेस की स्थिति को डंप करता है और खराब प्रोसेस को बंद कर देता है. जब Watchdog किसी ऐसी प्रोसेस को बंद करता है जो ठीक से काम नहीं कर रही है, तो वह logcat में carwatchdog terminated <process name> (pid:<process id>) टेक्स्ट को लॉग करता है. इस लॉग लाइन में, बंद की गई प्रोसेस के बारे में जानकारी दी गई है. जैसे, प्रोसेस का नाम और प्रोसेस आईडी.

1. ऊपर दिए गए टेक्स्ट को लॉगकैट में खोजने के लिए, यह कमांड चलाएं:

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

   उदाहरण के लिए, जब KitchenSink ऐप्लिकेशन, Watchdog क्लाइंट के तौर पर रजिस्टर होता है और Watchdog पिंग का जवाब नहीं देता है, तो Watchdog, रजिस्टर की गई KitchenSink प्रोसेस को बंद करते समय, इस तरह की लाइन लॉग करता है.

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

2. ऐप्लिकेशन के जवाब न देने की समस्या की असली वजह का पता लगाने के लिए, /data/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 पर मौजूद है. बंद की गई प्रोसेस की एएनआर डंप फ़ाइल का इस्तेमाल करके, विश्लेषण शुरू करें.