hdi_service/src/power_interface_impl.cpp

/*
 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "power_interface_impl.h"

#include "errors.h"
#include "hdf_device_desc.h"
#include "hdf_remote_service.h"
#include "hdf_sbuf.h"
#include "pubdef.h"
#include "running_lock_impl.h"
#include "securec.h"
#include "unique_fd.h"
#include "power_hdf_log.h"
#include "v1_2/power_types.h"
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstdlib>
#include <file_ex.h>
#include <hdf_base.h>
#include <iproxy_broker.h>
#include <iremote_object.h>
#include <mutex>
#include <sys/eventfd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <thread>
#include <unistd.h>

#ifdef DRIVER_PERIPHERAL_POWER_WAKEUP_CAUSE_PATH
#include "power_config.h"
#endif

namespace OHOS {
namespace HDI {
namespace Power {
namespace V1_2 {
static constexpr const int32_t MAX_FILE_LENGTH = 32 * 1024 * 1024;
static constexpr const int32_t FORCE_SLEEP_MAX_COUNT = 100;

static constexpr const char * const SUSPEND_STATE = "mem";
static constexpr const char * const SUSPEND_STATE_PATH = "/sys/power/state";
static constexpr const char * const LOCK_PATH = "/sys/power/wake_lock";
static constexpr const char * const UNLOCK_PATH = "/sys/power/wake_unlock";
static constexpr const char * const WAKEUP_COUNT_PATH = "/sys/power/wakeup_count";
#ifdef FASTER_RETRY_OF_SLEEP
static constexpr std::chrono::milliseconds DEFAULT_WAIT_TIME(100); // 100ms for phone and tablet
#else
static constexpr std::chrono::milliseconds DEFAULT_WAIT_TIME(1000); // 1000ms
#endif
static constexpr std::chrono::milliseconds MAX_WAIT_TIME(1000 * 60); // 1min
static constexpr int32_t WAIT_TIME_FACTOR = 2;
static std::chrono::milliseconds waitTime_(DEFAULT_WAIT_TIME);
static std::chrono::milliseconds forceThreadWaitTime_(100); // 100ms
static std::mutex g_mutex;
static std::mutex g_suspendMutex;
static std::mutex g_forceSuspendMutex;
static std::mutex g_autoSuspendThreadCreatedMutex;
static std::mutex g_forceSuspendThreadCreatedMutex;
static std::mutex g_controlSuspendThreadMutex;

static std::condition_variable g_suspendCv;
static std::condition_variable g_forceSuspendCv;
static std::unique_ptr<std::thread> g_daemon;
static std::unique_ptr<std::thread> g_forceDaemon;

static std::atomic_bool g_suspendRetry {false};
static std::atomic_bool g_forceSuspendRetry {false};
static std::atomic_bool g_autoSuspendThreadCreated {false};
static std::atomic_bool g_forceSuspendThreadCreated {false};

static sptr<IPowerHdiCallback> g_callback;
static UniqueFd wakeupCountFd;
static PowerHdfState g_powerState {PowerHdfState::AWAKE};
static void AutoSuspendLoop();
static void ForceSuspendLoop();
static int32_t DoSuspend();
static void LoadStringFd(int32_t fd, std::string &content);
static std::string ReadWakeCount();
static bool WriteWakeCount(const std::string &count);
static void NotifyCallback(int code);
namespace {
sptr<PowerInterfaceImpl::PowerDeathRecipient> g_deathRecipient = nullptr;
bool g_isHdiStart = false;
} // namespace

extern "C" IPowerInterface *PowerInterfaceImplGetInstance(void)
{
    using OHOS::HDI::Power::V1_2::PowerInterfaceImpl;
    PowerInterfaceImpl *service = new (std::nothrow) PowerInterfaceImpl();
    if (service == nullptr) {
        return nullptr;
    }

    if (service->Init() != HDF_SUCCESS) {
        delete service;
        return nullptr;
    }
    return service;
}

int32_t PowerInterfaceImpl::Init()
{
#ifdef DRIVER_PERIPHERAL_POWER_WAKEUP_CAUSE_PATH
    auto& powerConfig = PowerConfig::GetInstance();
    powerConfig.ParseConfig();
#endif
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::RegisterCallback(const sptr<IPowerHdiCallback> &ipowerHdiCallback)
{
    std::lock_guard<std::mutex> lock(g_mutex);
    if (!g_isHdiStart) {
        g_callback = ipowerHdiCallback;
        if (g_callback == nullptr) {
            UnRegister();
            return HDF_SUCCESS;
        }
        g_deathRecipient = new PowerDeathRecipient(this);
        if (g_deathRecipient == nullptr) {
            return HDF_FAILURE;
        }
        AddPowerDeathRecipient(g_callback);
        g_isHdiStart = true;
    }

    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::UnRegister()
{
    HDF_LOGI("UnRegister");
    RemovePowerDeathRecipient(g_callback);
    g_callback = nullptr;
    g_isHdiStart = false;
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::RegisterRunningLockCallback(const sptr<IPowerRunningLockCallback>
    &iPowerRunningLockCallback)
{
    if (iPowerRunningLockCallback != nullptr) {
        UnRegisterRunningLockCallback();
    }
    RunningLockImpl::RegisterRunningLockCallback(iPowerRunningLockCallback);
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::UnRegisterRunningLockCallback()
{
    RunningLockImpl::UnRegisterRunningLockCallback();
    return HDF_SUCCESS;
}

void AutoSuspendLoop()
{
    auto suspendLock = std::unique_lock(g_suspendMutex);
    while (true) {
        std::this_thread::sleep_for(waitTime_);

        const std::string wakeupCount = ReadWakeCount();
        if (wakeupCount.empty()) {
            continue;
        }
        if (!g_suspendRetry) {
            g_suspendCv.wait(suspendLock);
        }
        if (!WriteWakeCount(wakeupCount)) {
            continue;
        }
        if (g_forceSuspendRetry) {
            continue;
        }
        NotifyCallback(CMD_ON_SUSPEND);
        g_powerState = PowerHdfState::SLEEP;
        DoSuspend();
        g_powerState = PowerHdfState::AWAKE;
        NotifyCallback(CMD_ON_WAKEUP);
    }
}

void ForceSuspendLoop()
{
    auto suspendLock = std::unique_lock(g_forceSuspendMutex);
    while (true) {
        if (!g_forceSuspendRetry) {
            g_forceSuspendCv.wait(suspendLock);
        }

        NotifyCallback(CMD_ON_SUSPEND);
        g_powerState = PowerHdfState::SLEEP;
        DoSuspend();
        g_powerState = PowerHdfState::AWAKE;
        NotifyCallback(CMD_ON_WAKEUP);
        /*
         * Sleep for 10s when wake up form non-configuration source,
         * and just sleep until g_forceSuspendRetry is false when wake up
         * form configuration source in order to reduce response time of
         * next force suspend.
         */
        int count = 1;
        while (count <= FORCE_SLEEP_MAX_COUNT) {
            if (!g_forceSuspendRetry) {
                HDF_LOGI("do not need to sleep.");
                break;
            }
            std::this_thread::sleep_for(forceThreadWaitTime_);
            count++;
        }
    }
}

int32_t DoSuspend()
{
    std::lock_guard<std::mutex> lock(g_mutex);
    UniqueFd suspendStateFd(TEMP_FAILURE_RETRY(open(SUSPEND_STATE_PATH, O_RDWR | O_CLOEXEC)));
    if (suspendStateFd < 0) {
        return HDF_FAILURE;
    }
    bool ret = SaveStringToFd(suspendStateFd, SUSPEND_STATE);
    if (!ret) {
        HDF_LOGE("DoSuspend fail");
        waitTime_ = std::min(waitTime_ * WAIT_TIME_FACTOR, MAX_WAIT_TIME);
        return HDF_FAILURE;
    }
    waitTime_ = DEFAULT_WAIT_TIME;
    return HDF_SUCCESS;
}

void PowerInterfaceImpl::CreateAutoSuspendThread()
{
    std::lock_guard<std::mutex> lock(g_autoSuspendThreadCreatedMutex);
    if (g_autoSuspendThreadCreated) {
        return;
    }

    HDF_LOGI("create auto sleep thread");
    g_daemon = std::make_unique<std::thread>(&AutoSuspendLoop);
    g_daemon->detach();
    g_autoSuspendThreadCreated = true;
}

void PowerInterfaceImpl::CreateForceSuspendThread()
{
    std::lock_guard<std::mutex> lock(g_forceSuspendThreadCreatedMutex);
    if (g_forceSuspendThreadCreated) {
        return;
    }

    HDF_LOGI("create force sleep thread");
    g_forceDaemon = std::make_unique<std::thread>(&ForceSuspendLoop);
    g_forceDaemon->detach();
    g_forceSuspendThreadCreated = true;
}

void NotifyCallback(int code)
{
    if (g_callback == nullptr) {
        return;
    }
    switch (code) {
        case CMD_ON_SUSPEND:
            g_callback->OnSuspend();
            break;
        case CMD_ON_WAKEUP:
            g_callback->OnWakeup();
            break;
        default:
            break;
    }
}

int32_t PowerInterfaceImpl::StopSuspend()
{
    HDF_LOGI("stop suspend");
    std::lock_guard<std::mutex> lock(g_controlSuspendThreadMutex);
    g_suspendRetry = false;
    g_forceSuspendRetry = false;
    g_powerState = PowerHdfState::AWAKE;
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::StartSuspend()
{
    HDF_LOGI("start suspend");
    {
        std::lock_guard<std::mutex> lock(g_controlSuspendThreadMutex);
        g_powerState = PowerHdfState::INACTIVE;
        g_suspendRetry = true;
        g_suspendCv.notify_one();
    }
    CreateAutoSuspendThread();
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::ForceSuspend()
{
    HDF_LOGI("force suspend");
    {
        std::lock_guard<std::mutex> lock(g_controlSuspendThreadMutex);
        g_forceSuspendRetry = true;
        g_forceSuspendCv.notify_one();
    }
    CreateForceSuspendThread();
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::Hibernate()
{
    HDF_LOGI("hibernate begin.");
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::SuspendBlock(const std::string &name)
{
    std::lock_guard<std::mutex> lock(g_mutex);
    if (name.empty()) {
        return HDF_ERR_INVALID_PARAM;
    }
    UniqueFd fd(TEMP_FAILURE_RETRY(open(LOCK_PATH, O_RDWR | O_CLOEXEC)));
    bool ret = SaveStringToFd(fd, name);
    if (!ret) {
        return HDF_FAILURE;
    }
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::SuspendUnblock(const std::string &name)
{
    std::lock_guard<std::mutex> lock(g_mutex);
    if (name.empty()) {
        return HDF_ERR_INVALID_PARAM;
    }
    UniqueFd fd(TEMP_FAILURE_RETRY(open(UNLOCK_PATH, O_RDWR | O_CLOEXEC)));
    bool ret = SaveStringToFd(fd, name);
    if (!ret) {
        return HDF_FAILURE;
    }
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::AddPowerDeathRecipient(const sptr<IPowerHdiCallback> &callback)
{
    HDF_LOGI("AddPowerDeathRecipient");
    const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IPowerHdiCallback>(callback);
    bool result = remote->AddDeathRecipient(g_deathRecipient);
    if (!result) {
        HDF_LOGI("AddPowerDeathRecipient fail");
        return HDF_FAILURE;
    }
    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::RemovePowerDeathRecipient(const sptr<IPowerHdiCallback> &callback)
{
    HDF_LOGI("RemovePowerDeathRecipient");
    const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IPowerHdiCallback>(callback);
    bool result = remote->RemoveDeathRecipient(g_deathRecipient);
    if (!result) {
        HDF_LOGI("RemovePowerDeathRecipient fail");
        return HDF_FAILURE;
    }
    return HDF_SUCCESS;
}

void PowerInterfaceImpl::PowerDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
{
    HDF_LOGI("PowerDeathRecipient OnRemoteDied");
    powerInterfaceImpl_->UnRegister();
    RunningLockImpl::Clean();
}

void LoadStringFd(int32_t fd, std::string &content)
{
    if (fd <= 0) {
        HDF_LOGW("invalid fd: %{public}d", fd);
        return;
    }

    const int32_t fileLength = lseek(fd, 0, SEEK_END);
    if (fileLength > MAX_FILE_LENGTH || fileLength <= 0) {
        HDF_LOGW("invalid file length(%{public}d)!", fileLength);
        return;
    }
    int32_t loc = lseek(fd, 0, SEEK_SET);
    if (loc == -1) {
        HDF_LOGE("lseek file to begin failed!");
        return;
    }
    content.resize(fileLength);
    const int32_t len = static_cast<int32_t>(read(fd, content.data(), fileLength));
    if (len <= 0) {
        HDF_LOGW("the length read from file is failed, len: %{public}d, fileLen: %{public}d", len, fileLength);
        content.clear();
    }
}

std::string ReadWakeCount()
{
    if (wakeupCountFd < 0) {
        wakeupCountFd = UniqueFd(TEMP_FAILURE_RETRY(open(WAKEUP_COUNT_PATH, O_RDWR | O_CLOEXEC)));
    }
    std::string wakeupCount;
    LoadStringFd(wakeupCountFd, wakeupCount);

    return wakeupCount;
}

bool WriteWakeCount(const std::string &count)
{
    if (wakeupCountFd < 0) {
        wakeupCountFd = UniqueFd(TEMP_FAILURE_RETRY(open(WAKEUP_COUNT_PATH, O_RDWR | O_CLOEXEC)));
    }
    bool ret = SaveStringToFd(wakeupCountFd, count.c_str());
    return ret;
}

static void LoadSystemInfo(const std::string &path, std::string &info)
{
    UniqueFd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDWR | O_CLOEXEC)));
    std::string str;
    if (fd >= 0) {
        bool ret = LoadStringFromFd(fd, str);
        if (!ret) {
            str = "# Failed to read";
        }
    } else {
        str = "# Failed to open";
    }
    info.append(path);
    info.append(": " + str + "\n");
}

int32_t PowerInterfaceImpl::PowerDump(std::string &info)
{
    std::string dumpInfo("");
    LoadSystemInfo(SUSPEND_STATE_PATH, dumpInfo);
    LoadSystemInfo(LOCK_PATH, dumpInfo);
    LoadSystemInfo(UNLOCK_PATH, dumpInfo);
    info = dumpInfo;

    return HDF_SUCCESS;
}

int32_t PowerInterfaceImpl::HoldRunningLock(const RunningLockInfo &info)
{
    return RunningLockImpl::Hold(info, g_powerState);
}

int32_t PowerInterfaceImpl::UnholdRunningLock(const RunningLockInfo &info)
{
    return RunningLockImpl::Unhold(info);
}

int32_t PowerInterfaceImpl::HoldRunningLockExt(const RunningLockInfo &info,
    uint64_t lockid, const std::string &bundleName)
{
    return RunningLockImpl::HoldLock(info, g_powerState, lockid, bundleName);
}

int32_t PowerInterfaceImpl::UnholdRunningLockExt(const RunningLockInfo &info,
    uint64_t lockid, const std::string &bundleName)
{
    return RunningLockImpl::UnholdLock(info, lockid, bundleName);
}

int32_t PowerInterfaceImpl::GetWakeupReason(std::string &reason)
{
#ifdef DRIVER_PERIPHERAL_POWER_WAKEUP_CAUSE_PATH
    auto& powerConfig = PowerConfig::GetInstance();
    std::map<std::string, PowerConfig::PowerSceneConfig> sceneConfigMap= powerConfig.GetPowerSceneConfigMap();
    std::map<std::string, PowerConfig::PowerSceneConfig>::iterator it = sceneConfigMap.find("wakeuo_cause");
    if (it == sceneConfigMap.end()) {
        HDF_LOGW("wakeuo_cause getPath does not exist");
        return HDF_FAILURE;
    }
    std::string getPath = (it->second).getPath;
    HDF_LOGI("getPath = %{public}s", getPath.c_str());

    UniqueFd wakeupCauseFd(TEMP_FAILURE_RETRY(open(getPath.c_str(), O_RDONLY | O_CLOEXEC)));
    if (wakeupCauseFd < 0) {
        return HDF_FAILURE;
    }
    LoadStringFd(wakeupCauseFd, reason);
    return HDF_SUCCESS;
#else
    HDF_LOGW("wakrup cause path not config");
    return HDF_FAILURE;
#endif
}
} // namespace V1_2
} // namespace Power
} // namespace HDI
} // namespace OHOS