Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a8fad9bd authored by Peng Xu's avatar Peng Xu
Browse files

Checks hidl service and remove hidl call at dump

Two things:
  * check for hidl service availability before calling any hidl
    functions.
  * remove hidl dependency on dump to ensure dump will not cause
    crash due to hidl failure.

Bug: 36073404
Test: check sensor running after reboot
Test: check dumpsys sensorservice works normally.
Change-Id: I8626635a143a9f07f263f85d95ab16749ea1e452
parent b178d3d2
Loading
Loading
Loading
Loading
+129 −141
Original line number Original line Diff line number Diff line
@@ -52,6 +52,31 @@ static status_t StatusFromResult(Result result) {
}
}


SensorDevice::SensorDevice() : mHidlTransportErrors(20) {
SensorDevice::SensorDevice() : mHidlTransportErrors(20) {
    if (!connectHidlService()) {
        return;
    }
    checkReturn(mSensors->getSensorsList(
            [&](const auto &list) {
                const size_t count = list.size();

                mActivationCount.setCapacity(count);
                Info model;
                for (size_t i=0 ; i < count; i++) {
                    sensor_t sensor;
                    convertToSensor(list[i], &sensor);
                    mSensorList.push_back(sensor);

                    mActivationCount.add(list[i].sensorHandle, model);

                    checkReturn(mSensors->activate(list[i].sensorHandle, 0 /* enabled */));
                }
            }));

    mIsDirectReportSupported =
           (checkReturn(mSensors->unregisterDirectChannel(-1)) != Result::INVALID_OPERATION);
}

bool SensorDevice::connectHidlService() {
    // SensorDevice may wait upto 100ms * 10 = 1s for hidl service.
    // SensorDevice may wait upto 100ms * 10 = 1s for hidl service.
    constexpr auto RETRY_DELAY = std::chrono::milliseconds(100);
    constexpr auto RETRY_DELAY = std::chrono::milliseconds(100);
    size_t retry = 10;
    size_t retry = 10;
@@ -74,7 +99,7 @@ SensorDevice::SensorDevice() : mHidlTransportErrors(20) {


        if (--retry <= 0) {
        if (--retry <= 0) {
            ALOGE("Cannot connect to ISensors hidl service!");
            ALOGE("Cannot connect to ISensors hidl service!");
            return;
            break;
        }
        }
        // Delay 100ms before retry, hidl service is expected to come up in short time after
        // Delay 100ms before retry, hidl service is expected to come up in short time after
        // crash.
        // crash.
@@ -82,29 +107,11 @@ SensorDevice::SensorDevice() : mHidlTransportErrors(20) {
                (initStep == 0) ? "getService()" : "poll() check", retry);
                (initStep == 0) ? "getService()" : "poll() check", retry);
        std::this_thread::sleep_for(RETRY_DELAY);
        std::this_thread::sleep_for(RETRY_DELAY);
    }
    }

    return (mSensors != nullptr);
    checkReturn(mSensors->getSensorsList(
            [&](const auto &list) {
                const size_t count = list.size();

                mActivationCount.setCapacity(count);
                Info model;
                for (size_t i=0 ; i < count; i++) {
                    sensor_t sensor;
                    convertToSensor(list[i], &sensor);
                    mSensorList.push_back(sensor);

                    mActivationCount.add(list[i].sensorHandle, model);

                    checkReturn(mSensors->activate(list[i].sensorHandle, 0 /* enabled */));
                }
            }));

    mIsDirectReportSupported =
           (checkReturn(mSensors->unregisterDirectChannel(-1)) != Result::INVALID_OPERATION);
}
}


void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {
void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {
    // not need to check mSensors because this is is only called after successful poll()
    if (connected) {
    if (connected) {
        Info model;
        Info model;
        mActivationCount.add(handle, model);
        mActivationCount.add(handle, model);
@@ -115,63 +122,37 @@ void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {
}
}


std::string SensorDevice::dump() const {
std::string SensorDevice::dump() const {
    if (mSensors == NULL) return "HAL not initialized\n";
    if (mSensors == nullptr) return "HAL not initialized\n";


    String8 result;
    String8 result;

    result.appendFormat("Total %zu h/w sensors, %zu running:\n",
    result.appendFormat("Saw %d hidlTransport Errors\n", mTotalHidlTransportErrors);
                        mSensorList.size(), mActivationCount.size());
    for (auto it = mHidlTransportErrors.begin() ; it != mHidlTransportErrors.end(); it++ ) {
        result += "\t";
        result += it->toString();
        result += "\n";
    }

    checkReturn(mSensors->getSensorsList([&](const auto &list){
            const size_t count = list.size();

            result.appendFormat(
                "Total %zu h/w sensors, %zu running:\n",
                count,
                mActivationCount.size());


    Mutex::Autolock _l(mLock);
    Mutex::Autolock _l(mLock);
            for (size_t i = 0 ; i < count ; i++) {
    for (const auto & s : mSensorList) {
                const Info& info = mActivationCount.valueFor(
        int32_t handle = s.handle;
                    list[i].sensorHandle);
        const Info& info = mActivationCount.valueFor(handle);

        if (info.batchParams.isEmpty()) continue;
        if (info.batchParams.isEmpty()) continue;
                result.appendFormat(

                    "0x%08x) active-count = %zu; ",
        result.appendFormat("0x%08x) active-count = %zu; ", handle, info.batchParams.size());
                    list[i].sensorHandle,
                    info.batchParams.size());


        result.append("sampling_period(ms) = {");
        result.append("sampling_period(ms) = {");
        for (size_t j = 0; j < info.batchParams.size(); j++) {
        for (size_t j = 0; j < info.batchParams.size(); j++) {
            const BatchParams& params = info.batchParams.valueAt(j);
            const BatchParams& params = info.batchParams.valueAt(j);
                    result.appendFormat(
            result.appendFormat("%.1f%s", params.batchDelay / 1e6f,
                        "%.1f%s",
                        params.batchDelay / 1e6f,
                j < info.batchParams.size() - 1 ? ", " : "");
                j < info.batchParams.size() - 1 ? ", " : "");
        }
        }
                result.appendFormat(
        result.appendFormat("}, selected = %.1f ms; ", info.bestBatchParams.batchDelay / 1e6f);
                        "}, selected = %.1f ms; ",
                        info.bestBatchParams.batchDelay / 1e6f);


        result.append("batching_period(ms) = {");
        result.append("batching_period(ms) = {");
        for (size_t j = 0; j < info.batchParams.size(); j++) {
        for (size_t j = 0; j < info.batchParams.size(); j++) {
            BatchParams params = info.batchParams.valueAt(j);
            BatchParams params = info.batchParams.valueAt(j);


                    result.appendFormat(
            result.appendFormat("%.1f%s", params.batchTimeout / 1e6f,
                            "%.1f%s",
                            params.batchTimeout / 1e6f,
                    j < info.batchParams.size() - 1 ? ", " : "");
                    j < info.batchParams.size() - 1 ? ", " : "");
        }
        }

        result.appendFormat("}, selected = %.1f ms\n", info.bestBatchParams.batchTimeout / 1e6f);
                result.appendFormat(
                        "}, selected = %.1f ms\n",
                        info.bestBatchParams.batchTimeout / 1e6f);
    }
    }
        }));


    return result.string();
    return result.string();
}
}
@@ -187,7 +168,7 @@ status_t SensorDevice::initCheck() const {
}
}


ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
    if (mSensors == NULL) return NO_INIT;
    if (mSensors == nullptr) return NO_INIT;


    ssize_t err;
    ssize_t err;
    int numHidlTransportErrors = 0;
    int numHidlTransportErrors = 0;
@@ -239,7 +220,7 @@ void SensorDevice::autoDisable(void *ident, int handle) {
}
}


status_t SensorDevice::activate(void* ident, int handle, int enabled) {
status_t SensorDevice::activate(void* ident, int handle, int enabled) {
    if (mSensors == NULL) return NO_INIT;
    if (mSensors == nullptr) return NO_INIT;


    status_t err(NO_ERROR);
    status_t err(NO_ERROR);
    bool actuateHardware = false;
    bool actuateHardware = false;
@@ -328,7 +309,7 @@ status_t SensorDevice::batch(
        int flags,
        int flags,
        int64_t samplingPeriodNs,
        int64_t samplingPeriodNs,
        int64_t maxBatchReportLatencyNs) {
        int64_t maxBatchReportLatencyNs) {
    if (mSensors == NULL) return NO_INIT;
    if (mSensors == nullptr) return NO_INIT;


    if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
    if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
        samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
        samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
@@ -382,7 +363,7 @@ status_t SensorDevice::batch(
}
}


status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs) {
status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs) {
    if (mSensors == NULL) return NO_INIT;
    if (mSensors == nullptr) return NO_INIT;
    if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
    if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
        samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
        samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
    }
    }
@@ -407,11 +388,12 @@ status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodN
}
}


int SensorDevice::getHalDeviceVersion() const {
int SensorDevice::getHalDeviceVersion() const {
    if (mSensors == NULL) return -1;
    if (mSensors == nullptr) return -1;
    return SENSORS_DEVICE_API_VERSION_1_4;
    return SENSORS_DEVICE_API_VERSION_1_4;
}
}


status_t SensorDevice::flush(void* ident, int handle) {
status_t SensorDevice::flush(void* ident, int handle) {
    if (mSensors == nullptr) return NO_INIT;
    if (isClientDisabled(ident)) return INVALID_OPERATION;
    if (isClientDisabled(ident)) return INVALID_OPERATION;
    ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
    ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
    return StatusFromResult(checkReturn(mSensors->flush(handle)));
    return StatusFromResult(checkReturn(mSensors->flush(handle)));
@@ -427,6 +409,7 @@ bool SensorDevice::isClientDisabledLocked(void* ident) {
}
}


void SensorDevice::enableAllSensors() {
void SensorDevice::enableAllSensors() {
    if (mSensors == nullptr) return;
    Mutex::Autolock _l(mLock);
    Mutex::Autolock _l(mLock);
    mDisabledClients.clear();
    mDisabledClients.clear();
    ALOGI("cleared mDisabledClients");
    ALOGI("cleared mDisabledClients");
@@ -453,6 +436,7 @@ void SensorDevice::enableAllSensors() {
}
}


void SensorDevice::disableAllSensors() {
void SensorDevice::disableAllSensors() {
    if (mSensors == nullptr) return;
    Mutex::Autolock _l(mLock);
    Mutex::Autolock _l(mLock);
    for (size_t i = 0; i< mActivationCount.size(); ++i) {
    for (size_t i = 0; i< mActivationCount.size(); ++i) {
        const Info& info = mActivationCount.valueAt(i);
        const Info& info = mActivationCount.valueAt(i);
@@ -475,6 +459,7 @@ void SensorDevice::disableAllSensors() {


status_t SensorDevice::injectSensorData(
status_t SensorDevice::injectSensorData(
        const sensors_event_t *injected_sensor_event) {
        const sensors_event_t *injected_sensor_event) {
    if (mSensors == nullptr) return NO_INIT;
    ALOGD_IF(DEBUG_CONNECTIONS,
    ALOGD_IF(DEBUG_CONNECTIONS,
            "sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
            "sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
            injected_sensor_event->sensor,
            injected_sensor_event->sensor,
@@ -490,72 +475,14 @@ status_t SensorDevice::injectSensorData(
}
}


status_t SensorDevice::setMode(uint32_t mode) {
status_t SensorDevice::setMode(uint32_t mode) {

    if (mSensors == nullptr) return NO_INIT;
    return StatusFromResult(
    return StatusFromResult(
            checkReturn(mSensors->setOperationMode(
            checkReturn(mSensors->setOperationMode(
                    static_cast<hardware::sensors::V1_0::OperationMode>(mode))));
                    static_cast<hardware::sensors::V1_0::OperationMode>(mode))));
}
}


// ---------------------------------------------------------------------------

int SensorDevice::Info::numActiveClients() {
    SensorDevice& device(SensorDevice::getInstance());
    int num = 0;
    for (size_t i = 0; i < batchParams.size(); ++i) {
        if (!device.isClientDisabledLocked(batchParams.keyAt(i))) {
            ++num;
        }
    }
    return num;
}

status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,
                                                    int64_t samplingPeriodNs,
                                                    int64_t maxBatchReportLatencyNs) {
    ssize_t index = batchParams.indexOfKey(ident);
    if (index < 0) {
        ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%" PRId64 " timeout=%" PRId64 ") failed (%s)",
              ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
        return BAD_INDEX;
    }
    BatchParams& params = batchParams.editValueAt(index);
    params.flags = flags;
    params.batchDelay = samplingPeriodNs;
    params.batchTimeout = maxBatchReportLatencyNs;
    return NO_ERROR;
}

void SensorDevice::Info::selectBatchParams() {
    BatchParams bestParams(0, -1, -1);
    SensorDevice& device(SensorDevice::getInstance());

    for (size_t i = 0; i < batchParams.size(); ++i) {
        if (device.isClientDisabledLocked(batchParams.keyAt(i))) continue;
        BatchParams params = batchParams.valueAt(i);
        if (bestParams.batchDelay == -1 || params.batchDelay < bestParams.batchDelay) {
            bestParams.batchDelay = params.batchDelay;
        }
        if (bestParams.batchTimeout == -1 || params.batchTimeout < bestParams.batchTimeout) {
            bestParams.batchTimeout = params.batchTimeout;
        }
    }
    bestBatchParams = bestParams;
}

ssize_t SensorDevice::Info::removeBatchParamsForIdent(void* ident) {
    ssize_t idx = batchParams.removeItem(ident);
    if (idx >= 0) {
        selectBatchParams();
    }
    return idx;
}

void SensorDevice::notifyConnectionDestroyed(void* ident) {
    Mutex::Autolock _l(mLock);
    mDisabledClients.remove(ident);
}

int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {
int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {
    if (mSensors == nullptr) return NO_INIT;
    Mutex::Autolock _l(mLock);
    Mutex::Autolock _l(mLock);


    SharedMemType type;
    SharedMemType type;
@@ -596,12 +523,14 @@ int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory)
}
}


void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {
void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {
    if (mSensors == nullptr) return;
    Mutex::Autolock _l(mLock);
    Mutex::Autolock _l(mLock);
    checkReturn(mSensors->unregisterDirectChannel(channelHandle));
    checkReturn(mSensors->unregisterDirectChannel(channelHandle));
}
}


int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle,
int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle,
        int32_t channelHandle, const struct sensors_direct_cfg_t *config) {
        int32_t channelHandle, const struct sensors_direct_cfg_t *config) {
    if (mSensors == nullptr) return NO_INIT;
    Mutex::Autolock _l(mLock);
    Mutex::Autolock _l(mLock);


    RateLevel rate;
    RateLevel rate;
@@ -639,6 +568,65 @@ int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle,
    return ret;
    return ret;
}
}


// ---------------------------------------------------------------------------

int SensorDevice::Info::numActiveClients() {
    SensorDevice& device(SensorDevice::getInstance());
    int num = 0;
    for (size_t i = 0; i < batchParams.size(); ++i) {
        if (!device.isClientDisabledLocked(batchParams.keyAt(i))) {
            ++num;
        }
    }
    return num;
}

status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,
                                                    int64_t samplingPeriodNs,
                                                    int64_t maxBatchReportLatencyNs) {
    ssize_t index = batchParams.indexOfKey(ident);
    if (index < 0) {
        ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%" PRId64 " timeout=%" PRId64 ") failed (%s)",
              ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
        return BAD_INDEX;
    }
    BatchParams& params = batchParams.editValueAt(index);
    params.flags = flags;
    params.batchDelay = samplingPeriodNs;
    params.batchTimeout = maxBatchReportLatencyNs;
    return NO_ERROR;
}

void SensorDevice::Info::selectBatchParams() {
    BatchParams bestParams(0, -1, -1);
    SensorDevice& device(SensorDevice::getInstance());

    for (size_t i = 0; i < batchParams.size(); ++i) {
        if (device.isClientDisabledLocked(batchParams.keyAt(i))) continue;
        BatchParams params = batchParams.valueAt(i);
        if (bestParams.batchDelay == -1 || params.batchDelay < bestParams.batchDelay) {
            bestParams.batchDelay = params.batchDelay;
        }
        if (bestParams.batchTimeout == -1 || params.batchTimeout < bestParams.batchTimeout) {
            bestParams.batchTimeout = params.batchTimeout;
        }
    }
    bestBatchParams = bestParams;
}

ssize_t SensorDevice::Info::removeBatchParamsForIdent(void* ident) {
    ssize_t idx = batchParams.removeItem(ident);
    if (idx >= 0) {
        selectBatchParams();
    }
    return idx;
}

void SensorDevice::notifyConnectionDestroyed(void* ident) {
    Mutex::Autolock _l(mLock);
    mDisabledClients.remove(ident);
}

bool SensorDevice::isDirectReportSupported() const {
bool SensorDevice::isDirectReportSupported() const {
    return mIsDirectReportSupported;
    return mIsDirectReportSupported;
}
}
+1 −0
Original line number Original line Diff line number Diff line
@@ -161,6 +161,7 @@ private:
    // Use this vector to determine which client is activated or deactivated.
    // Use this vector to determine which client is activated or deactivated.
    SortedVector<void *> mDisabledClients;
    SortedVector<void *> mDisabledClients;
    SensorDevice();
    SensorDevice();
    bool connectHidlService();


    static void handleHidlDeath(const std::string &detail);
    static void handleHidlDeath(const std::string &detail);
    template<typename T>
    template<typename T>