หน้านี้ได้รับการแปลโดย Cloud Translation API

เฝ้าระวังรถยนต์

ใช้ Watchdog เพื่อช่วยแก้ไขข้อบกพร่องของ VHAL Watchdog ของรถยนต์จะตรวจสอบประสิทธิภาพการทำงานของกระบวนการที่มีประสิทธิภาพต่ำและเสียชีวิต หากต้องการให้ Watchdog ในรถตรวจสอบกระบวนการ กระบวนการนั้นจะต้องลงทะเบียนกับ Watchdog ในรถ เมื่อโปรแกรมตรวจสอบรถยนต์หยุดกระบวนการที่ไม่เสถียร โปรแกรมจะเขียนสถานะของกระบวนการลงใน data/anr เช่นเดียวกับการดัมพ์แอปพลิเคชันไม่ตอบสนอง (ANR) อื่นๆ การทำเช่นนี้ทำให้กระบวนการแก้ไขข้อบกพร่องเกิดขึ้น

บทความนี้อธิบายวิธีที่ HAL และบริการของผู้ให้บริการสามารถลงทะเบียนกระบวนการกับโปรแกรมตรวจสอบรถยนต์

HAL ของผู้ให้บริการ

โดยปกติแล้ว HAL ของผู้ให้บริการจะใช้พูลเธรดสำหรับ hwbinder อย่างไรก็ตาม โปรแกรมรับส่งข้อมูลสำหรับ Watchdog ของรถยนต์จะสื่อสารกับเดรัม Watchdog ของรถยนต์ผ่าน binder ซึ่งแตกต่างจาก hwbinder ดังนั้นจึงมีการใช้ Thread Pool อีกรายการสำหรับ binder

ระบุ aidl ของ Watchdog ในรถยนต์ในไฟล์ make

รวม 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 ให้สร้าง 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 ให้ทำการตรวจสอบประสิทธิภาพการทำงาน เช่น โพสต์ไปยังเครื่องจัดการลูปเทรด หากใช้งานได้ตามปกติ ให้โทรหา 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 เพื่อวัตถุประสงค์ของตนเอง คุณต้องสร้างพูลเธรดอีกชุดสำหรับการรับส่งข้อมูล Binder ของเครื่องมือตรวจสอบรถยนต์)
ค้นหาเดรัมที่มีชื่อดังกล่าวและเรียกใช้ ICarWatchdog::registerClient ชื่ออินเทอร์เฟซของ Daemon Watchdog ในรถคือ android.automotive.watchdog.ICarWatchdog/default

เลือกการหมดเวลาประเภทใดประเภทหนึ่งต่อไปนี้ตามการตอบสนองของบริการ ซึ่งเครื่องมือตรวจสอบรถยนต์รองรับ แล้วส่งการหมดเวลาในการเรียกใช้ ICarWatchdog::registerClient

critical(3s)
ปานกลาง(5 วินาที)
ปกติ(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;
}

บริการของผู้ให้บริการ (แบบเนทีฟ)

ระบุไฟล์ makefile aidl ของ 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
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);
}

เริ่มชุดข้อความ Binder และลงทะเบียนไคลเอ็นต์

ชื่ออินเทอร์เฟซของ Daemon Watchdog ในรถคือ android.automotive.watchdog.ICarWatchdog/default

ค้นหา 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();
    ...
}

ตัวอย่าง 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);
}

ตรวจจับกระบวนการที่ Watchdog ของรถยนต์สิ้นสุด

เครื่องมือตรวจสอบรถยนต์จะแสดงผล/หยุดกระบวนการ (HAL ของผู้ให้บริการ บริการของผู้ให้บริการเอง บริการ Android ของผู้ให้บริการ) ที่ลงทะเบียนกับเครื่องมือตรวจสอบรถยนต์เมื่อกระบวนการดังกล่าวค้างและไม่ตอบสนอง การตรวจหาการถ่ายโอนข้อมูลดังกล่าวทำได้โดยการตรวจสอบบันทึกการบันทึก Watchdog ของรถยนต์จะแสดงบันทึก 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 ในตัวอย่างด้านบน) แล้วเริ่มการวิเคราะห์

เฝ้าระวังรถยนต์

HAL ของผู้ให้บริการ

ระบุ aidl ของ Watchdog ในรถยนต์ในไฟล์ make

เพิ่มนโยบาย SELinux

system_server.te

hal_vehicle_default.te

ใช้คลาสไคลเอ็นต์โดยการรับช่วง BnCarWatchdogClient

WatchogClient.h

WatchogClient.cpp

เริ่มชุดข้อความ Binder และลงทะเบียนไคลเอ็นต์

VehicleService.cpp

WatchogClient.cpp

บริการของผู้ให้บริการ (แบบเนทีฟ)

ระบุไฟล์ makefile aidl ของ Watchdog ในรถ

เพิ่มนโยบาย SELinux

sample_client.te

file_contexts

ใช้คลาสไคลเอ็นต์โดยการรับช่วง BnCarWatchdogClient

ตัวอย่าง NativeClient.h

SampleNativeClient.cpp

เริ่มชุดข้อความ Binder และลงทะเบียนไคลเอ็นต์

main.cpp

ตัวอย่าง NativeClient.cpp

บริการของผู้ให้บริการ (Android)

ติดตั้งใช้งานไคลเอ็นต์โดยรับค่า CarWatchdogClientCallback

ลงทะเบียนไคลเอ็นต์

ยกเลิกการลงทะเบียนไคลเอ็นต์

ตรวจจับกระบวนการที่ Watchdog ของรถยนต์สิ้นสุด