इस पेज का अनुवाद Cloud Translation API से किया गया है.

कार वॉचडॉग

VHAL को डीबग करने के लिए, कार वॉचडॉग का इस्तेमाल करें. कार वॉचडॉग, कार की परफ़ॉर्मेंस पर नज़र रखता है और खराब प्रोसेस को बंद कर देता है. कार के वॉचडॉग की मदद से किसी प्रोसेस पर नज़र रखने के लिए, उस प्रोसेस को कार के वॉचडॉग के साथ रजिस्टर करना ज़रूरी है. जब कार वॉचडॉग, गड़बड़ी वाली प्रोसेस को बंद करता है, तो वह प्रोसेस की स्थिति को data/anr पर सेव करता है. यह स्थिति, ऐप्लिकेशन काम नहीं कर रहा है (ANR) के अन्य डंप की तरह ही होती है. ऐसा करने से, डीबग करने की प्रोसेस आसान हो जाती है.

इस लेख में बताया गया है कि वेंडर एचएएल और सेवाएं, कार वॉचडॉग के साथ प्रोसेस को कैसे रजिस्टर कर सकती हैं.

वेंडर एचएएल

आम तौर पर, वेंडर HAL hwbinder के लिए थ्रेड पूल का इस्तेमाल करता है. हालांकि, कार वॉचडॉग क्लाइंट, binder के ज़रिए कार वॉचडॉग डेमन से संपर्क करता है, जो hwbinder से अलग होता है. इसलिए, binder के लिए एक और थ्रेड पूल का इस्तेमाल किया जा रहा है.

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

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)
```

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

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

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

बाइंडर कम्यूनिकेशन के लिए थ्रेड पूल बनाएं. अगर वेंडर एचएएल, अपने मकसद के लिए hwbinder का इस्तेमाल करता है, तो आपको कार के वॉचडॉग बाइंडर कम्यूनिकेशन के लिए एक और थ्रेड पूल बनाना होगा).
नाम से डेमन खोजें और ICarWatchdog::registerClient को कॉल करें. कार के वॉचडॉग डेमन इंटरफ़ेस का नाम android.automotive.watchdog.ICarWatchdog/default है.

सेवा का जवाब देने में लगने वाले समय के आधार पर, कार के वॉचडॉग के साथ काम करने वाले इन तीन टाइम आउट में से कोई एक चुनें. इसके बाद, कॉल का टाइम आउट ICarWatchdog::registerClient को पास करें:

critical(3s)
moderate(5s)
सामान्य(10 सेकंड)

VehicleService.cpp और WatchogClient.cpp के लिए, यहां दिया गया कोड देखें:

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

वेंडर सेवाएं (नेटिव)

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

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 के लिए, नीचे दिया गया कोड देखें:
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 को इनहेरिट करके क्लाइंट क्लास लागू करना

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

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 है.

नाम से डेमन खोजें और 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)

CarWatchdogClientCallback को इनहेरिट करके क्लाइंट लागू करना

नई फ़ाइल में इस तरह बदलाव करें:

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 ऐप्लिकेशन (कार वॉचडॉग क्लाइंट) अटक जाता है, तो लॉग पर नीचे दी गई लाइन जैसी कोई लाइन दिखती है:

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 . इसके बाद, विश्लेषण शुरू करें.

कार वॉचडॉग

वेंडर एचएएल

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

SELinux नीति जोड़ना

system_server.te

hal_vehicle_default.te

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

WatchogClient.h

WatchogClient.cpp

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

VehicleService.cpp

WatchogClient.cpp

वेंडर सेवाएं (नेटिव)

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

SELinux नीति जोड़ना

sample_client.te

file_contexts

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

सैंपल NativeClient.h

SampleNativeClient.cpp

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

main.cpp

सैंपल NativeClient.cpp

वेंडर सेवाएं (Android)

CarWatchdogClientCallback को इनहेरिट करके क्लाइंट लागू करना

क्लाइंट को रजिस्टर करें

क्लाइंट का रजिस्ट्रेशन रद्द करें

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