מעקב אחר תקינות המערכת

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

מעקב אחר תקינות השירות של ספק

שירותי הספקים מפוקחים גם בצד המקורי וגם בצד Java. כדי לעקוב אחרי שירות של ספק, השירות צריך לרשום תהליך של בדיקת תקינות ב-Watchdog על ידי ציון זמן קצוב מראש. השירות Watchdog עוקב אחרי תקינות התהליך של בדיקת תקינות שנרשם, על ידי שליחת פינג במרווח זמן שנקבע במהלך הרישום, ביחס לזמן הקצוב לתפוגה. אם תהליך שמתבצעת אליו בדיקת פינג לא מגיב לפני שפג הזמן הקצוב לתפוגה, התהליך נחשב כלא תקין.

מעקב מקורי אחר תקינות השירות

ציון קובץ makefile של Watchdog AIDL

  1. הוספת 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

  1. כדי להוסיף מדיניות SELinux, מאפשרים לדומיין של שירות הספק להשתמש ב-binder (פקודת המאקרו 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, מבצעים בדיקת תקינות. אפשרות אחת היא לפרסם ב-handler של לולאת השרשור. אם הסטרימינג תקין, אפשר להתקשר אל 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.

  1. מחפשים את שירות ה-daemon עם השם ומתקשרים אל 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 על ידי הרשמה למאפיין VHAL_HEARTBEAT של הרכב. הכלי Watchdog מצפה שהערך של המאפיין הזה יתעדכן פעם אחת כל N שניות. אם הדופק לא מתעדכן במהלך הזמן הקצוב לתפוגה הזה, טיימר מפקח (watchdog) מפסיק את השירות VHAL.

הערה: Watchdog עוקב אחרי תקינות שירות VHAL רק אם שירות VHAL תומך במאפיין הרכב VHAL_HEARTBEAT.

ההטמעה הפנימית של VHAL יכולה להשתנות בהתאם לספק. אפשר להשתמש בדוגמאות הקוד הבאות כהפניות.

  1. רושמים את מאפיין הרכב VHAL_HEARTBEAT.

    כשמפעילים את שירות VHAL, צריך לרשום את מאפיין הרכב 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.

    בהתאם לתדירות של בדיקת תקינות VHAL (שמוסברת במאמר הגדרת התדירות של בדיקת תקינות VHAL), צריך לעדכן את מאפיין הרכב VHAL_HEARTBEAT פעם אחת כל N שניות. אחת הדרכים לעשות זאת היא להשתמש ב-RecurrentTimer כדי להפעיל את הפעולה שבודקת את תקינות ה-VHAL ומעדכנת את המאפיין VHAL_HEARTBEAT vehicle בתוך פסק הזמן הקצוב.

    הדוגמה הבאה היא הטמעה באמצעות 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 לקריאה בלבד של Watchdog מגדיר את התדירות של בדיקת תקינות VHAL. ברירת המחדל של התדירות של בדיקת תקינות (כשהמאפיין הזה לא מוגדר) היא שלוש שניות. אם שלוש שניות לא מספיקות לשירות VHAL לעדכן את מאפיין הרכב VHAL_HEARTBEAT, צריך להגדיר את התדירות של בדיקת התקינות של VHAL בהתאם לזמן התגובה של השירות.

ניפוי באגים בתהליכים לא תקינים שהופסקו על ידי Watchdog

הכלי Watchdog מבצע dump של מצב התהליך ומסיים תהליכים לא תקינים. כשמפסיקים תהליך לא תקין, Watchdog מתעד את הטקסט carwatchdog terminated <process name> (pid:<process id>) ב-logcat. שורת היומן הזו מספקת מידע על התהליך שהופסק, כמו שם התהליך ומזהה התהליך.

  1. כדי לחפש את הטקסט שצוין ב-logcat, מריצים את הפקודה: 
    $ 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. כדי לזהות את שורש הבעיה של חוסר התגובה, משתמשים ב-process dump שמאוחסן ב-/data/anr בדיוק כמו שמשתמשים בו במקרים של ANR של פעילות. כדי לאחזר את קובץ ה-dump של התהליך שהופסק, משתמשים בפקודות שלמטה. 
    $ 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 של תהליך KitchenSink שהופסק נמצא בנתיב /data/anr/anr_2020-05-01-09-50-18-290. מתחילים את הניתוח באמצעות קובץ ה-ANR dump של התהליך שהופסק.