VHAL को डीबग करने के लिए, कार वॉचडॉग का इस्तेमाल करें. कार के वॉचडॉग मॉनिटर
नुकसान पहुंचाने वाली प्रक्रियाओं का स्वास्थ्य और उन्हें मार देता है. मॉनिटर की जाने वाली प्रोसेस के लिए
अगर कार वॉचडॉग के पास है, तो प्रोसेस को कार के वॉचडॉग के साथ रजिस्टर किया जाना ज़रूरी है. टास्क कब शुरू होगा
कार का वॉचडॉग नुकसान पहुंचाने वाली प्रोसेस को खत्म कर देता है, कार का वॉचडॉग
अन्य 'ऐप्लिकेशन नहीं चल रहा है' के साथ data/anr
की प्रोसेस
(ANR) डंप. ऐसा करने से डीबग करने की प्रोसेस आसान हो जाती है.
इस लेख में बताया गया है कि वेंडर एचएएल और सेवाएं, कार का वॉचडॉग.
वेंडर एचएएल
आम तौर पर, वेंडर HAL hwbinder
के लिए थ्रेड पूल का इस्तेमाल करता है. हालांकि,
कार का वॉचडॉग क्लाइंट, कार के वॉचडॉग डीमन से बातचीत करता है
binder
, जो hwbinder
से अलग है. इसलिए,
binder
के लिए किसी अन्य थ्रेड पूल का इस्तेमाल किया जा रहा है.
मेकफ़ाइल में कार के वॉचडॉग आईडी की जानकारी दें
shared_libs
मेंcarwatchdog_aidl_interface-ndk_platform
को शामिल करें: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", ], }
SELinux नीति जोड़ें
-
system_server
को अपना एचएएल खत्म करने की अनुमति दें. अगर आपके पासsystem_server.te
नहीं है, तो नया खाता बनाएं. यह बहुत दिलचस्प है हर डिवाइस के लिए SELinux नीति जोड़ें -
वेंडर एचएएल को बाइंडर (
binder_use
मैक्रो) इस्तेमाल करने की अनुमति दें और वेंडर एचएएल कोcarwatchdog
क्लाइंट डोमेन में जोड़ें (carwatchdog_client_domain
मैक्रो).systemserver.te
और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)
BnCarWatchdogfoodClient को इनहेरिट करके, क्लाइंट क्लास को लागू करें
-
checkIfAlive
में, सेहत की जांच करें. उदाहरण के लिए, थ्रेड लूप हैंडलर. अगर ठीक है, तोICarWatchdog::tellClientAlive
पर कॉल करें.WatchogClient.h
और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(); }
बाइंडर थ्रेड शुरू करें और क्लाइंट को रजिस्टर करें
- बाइंडर कम्यूनिकेशन के लिए थ्रेड पूल बनाएं. अगर वेंडर HAL, अपने का इस्तेमाल करने के लिए, आपको कार वॉचडॉग बाइंडर कम्यूनिकेशन के लिए एक और थ्रेड पूल बनाना होगा).
-
डीमन को नाम से खोजें और
ICarWatchdog::registerClient
को कॉल करें. कार वॉचडॉग डीमन इंटरफ़ेस का नाम हैandroid.automotive.watchdog.ICarWatchdog/default
. -
सेवा का जवाब देने के तरीके के आधार पर, टाइम आउट के इन तीन टाइप में से किसी एक को चुनें
जो कार के वॉचडॉग की मदद से काम करता है और फिर कॉल के दौरान टाइम आउट पास करता है
ICarWatchdog::registerClient
:- अहम(3 सेकंड)
- सामान्य(5 सेकंड)
- सामान्य(10 सेकंड)
VehicleService.cpp
औरWatchogClient.cpp
के लिए नीचे दिया गया कोड देखें:वाहनसेवा.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; }
वेंडर सेवाएं (नेटिव)
कार के वॉचडॉग आईडी के बारे में बताएं
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 नीति जोड़ें
- SELinux नीति जोड़ने के लिए, वेंडर सेवा डोमेन को बाइंडर का इस्तेमाल करने की अनुमति दें
(
binder_use
मैक्रो) और वेंडर सेवा डोमेन कोcarwatchdog
क्लाइंट डोमेन (carwatchdog_client_domain
मैक्रो).sample_client.te
औरfile_contexts
के लिए नीचे दिया गया कोड देखें:नमूना_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)
फ़ाइल_कॉन्टेक्स्ट
/vendor/bin/sample_native_client u:object_r:sample_client_exec:s0
BnCarWatchdogfoodClient को इनहेरिट करके, क्लाइंट क्लास को लागू करें
checkIfAlive
में, सेहत की जांच करें. एक विकल्प यह है कि थ्रेड लूप हैंडलर. अगर ठीक है, तोICarWatchdog::tellClientAlive
पर कॉल करें.SampleNativeClient.h
औरSampleNativeClient.cpp
के लिए नीचे दिया गया कोड देखें:सैंपल NativeClient.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; };
सैंपल NativeClient.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
.
- डीमन को नाम से खोजें और
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(); ... }
सैंपल NativeClient.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); }
वेंडर सेवाएं (Android)
CarWatch DogClientCallback इनहेरिट करके, क्लाइंट को लागू करें
- नई फ़ाइल में इस तरह से बदलाव करें:
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() {} };
क्लाइंट को रजिस्टर करें
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); }
क्लाइंट का रजिस्ट्रेशन रद्द करें
- सेवा खत्म होने पर
CarWatchdogManager.unregisterClient()
पर कॉल करें:private void finishClient() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager( Car.CAR_WATCHDOG_SERVICE); manager.unregisterClient(mClientCallback); }
कार के वॉचडॉग ने जिन प्रोसेस को बंद किया है उनका पता लगाएं
कार वॉचडॉग डंप/किल करने की प्रोसेस (वेंडर एचएएल, वेंडर नेटिव सेवाएं,
विक्रेता Android सेवाएँ) जो कार वॉचडॉग में पंजीकृत हों, जब वे
अटक गया है और प्रतिक्रिया नहीं दे रहा है. लॉगकैट की जांच करके, इस तरह के डंपिंग का पता लगाया जाता है. कार
वॉचडॉग से लॉग carwatchdog killed process_name (pid:process_id)
मिलता है
जब नुकसान पहुंचाने वाली प्रोसेस को छोड़ दिया जाता है या मार दिया जाता है. इसलिए:
$ adb logcat -s CarServiceHelper | fgrep "carwatchdog killed"
काम के लॉग कैप्चर कर लिए जाते हैं. उदाहरण के लिए, अगर KitchenSink ऐप्लिकेशन (कार वॉचडॉग) Client) अटक जाता है, तो लॉग में एक लाइन नीचे दी गई है, जो इस तरह की होती है:
05-01 09:50:19.683 578 5777 W CarServiceHelper: carwatchdog killed com.google.android.car.kitchensink (pid: 5574)
KitchenSink ऐप्लिकेशन क्यों और कहां अटका, इसका पता लगाने के लिए प्रोसेस डंप का इस्तेमाल करें
डेटा को /data/anr
पर ठीक उसी तरह सेव किया जाता है जिस तरह 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 -----
डंप फ़ाइल ढूंढें (उदाहरण के लिए, /data/anr/anr_2020-05-01-09-50-18-290
ऊपर दिए गए उदाहरण में) और अपना विश्लेषण शुरू करें.