דף זה תורגם על ידי Cloud Translation API.

טיימר מפקח (watchdog) של רכב

אפשר להשתמש ב-watchdog של המכונית כדי לנפות באגים ב-VHAL. מוניטורים למעקב אחרי מפקחים (watchdog) של רכב והרגשה של תהליכים לא בריאים. כדי לעקוב אחר תהליך על ידי הטיימר המפקח (watchdog) של הרכב, התהליך חייב להיות רשום אצל הטיימר המפקח (watchdog) של הרכב. מתי הטיימר המפקח (watchdog) של המכונית הורג תהליכים לא בריאים, הטיימר המפקח (watchdog) כותב את הסטטוס התהליכים אל data/anr כמו לאפליקציות אחרות שלא מגיבות (מקרי ANR). הפעולה הזו מתאפשרת את תהליך ניפוי הבאגים.

המאמר הזה מתאר איך HALs ושירותים של ספקים יכולים לרשום תהליך הטיימר המפקח (watchdog) של המכונית.

HAL של ספק

בדרך כלל, HAL של הספק משתמש במאגר שרשורים עבור hwbinder. אבל, לפעמים הלקוח המפקח (watchdog) של המכונית מתקשר עם הדימון (daemon) של הטיימר המפקח (watchdog) של המכונית binder, ששונה מ-hwbinder. לכן, מאגר שרשורים אחר של binder נמצא בשימוש.

ציון הכלי עזר המפקח (watchdog) של מכונית ב-makefile

הכללה של carwatchdog_aidl_interface-ndk_platform ב-shared_libs:

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 הרשאה לסיים את פעולת ה-HAL. אם אין לך חשבון system_server.te, עליך ליצור חשבון. חשוב מאוד מומלץ להוסיף מדיניות SELinux לכל מכשיר.
מתן הרשאה ל-HAL של הספק להשתמש ב-binder (מאקרו binder_use) ולהוסיף את ממשק הלקוח HAL של הספק לדומיין הלקוח 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 צריך לבצע בדיקת תקינות. לדוגמה, פרסם handler של לולאת שרשור. אם המכשיר תקין, צריך להתקשר למספר 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();
}

התחלת השרשור של ה-binder ורישום הלקוח

יצירת מאגר של שרשורים לתקשורת ב-Binder. אם הספק HAL משתמש ב-hwbinder למטרה האישית שלכם, עליכם ליצור מאגר שרשורים נוסף עבור תקשורת בין-המפקח (watchdog) של המכונית).
מחפשים את הדימון בעל השם ומתקשרים אל ICarWatchdog::registerClient. שם הממשק של הטיימר המפקח (watchdog) של המכונית הוא android.automotive.watchdog.ICarWatchdog/default

בהתאם למהירות התגובה של השירות, בוחרים באחד משלושת הסוגים הבאים של זמן קצוב לתפוגה שנתמכת על ידי הטיימר המפקח (watchdog) של המכונית, ואז מעביר את הזמן הקצוב לתפוגה בשיחה אל ICarWatchdog::registerClient:

קריטיות(3s)
בינוני(5s)
רגיל(10s)

הקוד בהמשך ל-VehicleService.cpp ול-WatchogClient.cpp:

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

שירותי ספק (מקורי)

יש לציין את קובץ ה-Makefile של כלי המעקב המפקח (watchdog) של המכונית

הכללה של carwatchdog_aidl_interface-ndk_platform ב-shared_libs.

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 (מאקרו binder_use) ולהוסיף את דומיין השירות של הספק דומיין לקוח carwatchdog (פקודת מאקרו carwatchdog_client_domain). הקוד בהמשך ל-sample_client.te ול-file_contexts:
example_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 צריך לבצע בדיקת תקינות. אפשרות אחת היא לפרסם ב ה-handler של לולאת ה-thread. אם המכשיר תקין, צריך להתקשר למספר 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);
}

התחלת שרשור ב-binder ורישום הלקוח

שם הממשק של הטיימר המפקח (watchdog) של המכונית הוא 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();
    ...
}

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

שירותי ספקים (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);
}

זיהוי תהליכים שהסתיים על ידי טיימר המפקח (watchdog) של הרכב

תהליכי קריסת טיימר מפקח (watchdog) של רכב (ספק HAL, שירותים מקוריים של ספק, של הספק Android) שרשומים בחשבון המפקח (watchdog) של הרכב נתקע ולא מגיב. העתקת תוכן כזה מזוהה על ידי בדיקת Logcats. המכונית פלט טיימר מפקח (watchdog) מפיק יומן carwatchdog killed process_name (pid:process_id) כאשר השליך תהליך בעייתי או הורגים אותו. לפיכך:

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

היומנים הרלוונטיים מתועדים. לדוגמה, אם אפליקציית KitchenSink (טיימר מפקח (watchdog) של רכב לקוח) נתקע, שורה כמו ההודעה הבאה נכתבת ביומן:

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

כדי לבדוק למה או איפה אפליקציית KitchenSink נתקעה, אפשר להשתמש בקובץ ה-Dump של התהליך מאוחסנים ב-/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 -----

מוצאים את קובץ ה-Dump (לדוגמה, /data/anr/anr_2020-05-01-09-50-18-290). בדוגמה שלמעלה) ולהתחיל את הניתוח.

טיימר מפקח (watchdog) של רכב

HAL של ספק

ציון הכלי עזר המפקח (watchdog) של מכונית ב-makefile

הוספת מדיניות SELinux

system_server.te

hal_vehicle_default.te

הטמעה של מחלקת לקוח על ידי קבלת בירושה את BnCarWatchdogClient

WatchogClient.h

WatchogClient.cpp

התחלת השרשור של ה-binder ורישום הלקוח

CarService.cpp

WatchogClient.cpp

שירותי ספק (מקורי)

יש לציין את קובץ ה-Makefile של כלי המעקב המפקח (watchdog) של המכונית

הוספת מדיניות SELinux

example_client.te

file_contexts

הטמעה של מחלקת לקוח על ידי קבלת בירושה את BnCarWatchdogClient

SampleNativeClient.h

SampleNativeClient.cpp

התחלת שרשור ב-binder ורישום הלקוח

main.cpp

SampleNativeClient.cpp

שירותי ספקים (Android)

הטמעה של לקוח באמצעות קבלת בירושה של CarWatchdogClientCallback

רישום הלקוח

ביטול הרישום של הלקוח

זיהוי תהליכים שהסתיים על ידי טיימר המפקח (watchdog) של הרכב