xref: /developtools/hdc/src/host/host_unity.cpp (revision cc290419)

/*
 * Copyright (C) 2021 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 "host_unity.h"

namespace Hdc {
HdcHostUnity::HdcHostUnity(HTaskInfo hTaskInfo)
    : HdcTaskBase(hTaskInfo)
{
    opContext.thisClass = this;
}

HdcHostUnity::~HdcHostUnity()
{
    WRITE_LOG(LOG_DEBUG, "~HdcHostUnity channelId:%u", taskInfo->channelId);
}

bool HdcHostUnity::ReadyForRelease()
{
    if (!HdcTaskBase::ReadyForRelease()) {
        WRITE_LOG(LOG_WARN, "not ready for release channelId:%u", taskInfo->channelId);
        return false;
    }
    if (opContext.enableLog && !opContext.hasFilelogClosed) {
        WRITE_LOG(LOG_WARN, "enableLog true hasFilelogClosed false channelId:%u", taskInfo->channelId);
        return false;
    }
    return true;
}

void HdcHostUnity::StopTask()
{
    // Do not detect RunningProtect, force to close
    if (opContext.hasFilelogClosed) {
        WRITE_LOG(LOG_WARN, "StopTask hasFilelogClosed true channelId:%u", taskInfo->channelId);
        return;
    }
    if (opContext.enableLog) {
        ++refCount;
        opContext.fsClose.data = &opContext;
        WRITE_LOG(LOG_DEBUG, "taskInfo->channelId:%u fileLog:%d", taskInfo->channelId, opContext.fileLog);
        uv_fs_close(loopTask, &opContext.fsClose, opContext.fileLog, OnFileClose);
    }
};

void HdcHostUnity::OnFileClose(uv_fs_t *req)
{
    uv_fs_req_cleanup(req);
    ContextUnity *context = reinterpret_cast<ContextUnity *>(req->data);
    HdcHostUnity *thisClass = reinterpret_cast<HdcHostUnity *>(context->thisClass);
    context->hasFilelogClosed = true;
    --thisClass->refCount;
    return;
}

bool HdcHostUnity::InitLocalLog(const char *path)
{
    uv_fs_t reqFs;
    // block open
    if (uv_fs_open(nullptr, &reqFs, path, UV_FS_O_TRUNC | UV_FS_O_CREAT | UV_FS_O_WRONLY, S_IWUSR | S_IRUSR, nullptr)
        < 0) {
        WRITE_LOG(LOG_FATAL, "InitLocalLog uv_fs_open failed taskInfo->channelId:%u", taskInfo->channelId);
        return false;
    }
    uv_fs_req_cleanup(&reqFs);
    opContext.fileLog = reqFs.result;
    return true;
}

void HdcHostUnity::OnFileIO(uv_fs_t *req)
{
    CtxUnityIO *contextIO = reinterpret_cast<CtxUnityIO *>(req->data);
    ContextUnity *context = reinterpret_cast<ContextUnity *>(contextIO->context);
    HdcHostUnity *thisClass = reinterpret_cast<HdcHostUnity *>(context->thisClass);
    uint8_t *bufIO = contextIO->bufIO;
    uv_fs_req_cleanup(req);
    --thisClass->refCount;
    while (true) {
        if (req->result <= 0) {
            if (req->result < 0) {
                constexpr int bufSize = 1024;
                char buf[bufSize] = { 0 };
                uv_strerror_r((int)req->result, buf, bufSize);
                WRITE_LOG(LOG_DEBUG, "Error OnFileIO: %s", buf);
            }
            break;
        }
        context->fileIOIndex += req->result;
        break;
    }
    delete[] bufIO;
    delete contextIO;  // req is part of contextIO, no need to release
}

bool HdcHostUnity::AppendLocalLog(const char *bufLog, const int sizeLog)
{
    auto buf = new uint8_t[sizeLog];
    auto contextIO = new CtxUnityIO();
    if (!buf || !contextIO) {
        if (buf) {
            delete[] buf;
        }
        if (contextIO) {
            delete contextIO;
        }
        return false;
    }
    uv_fs_t *req = &contextIO->fs;
    contextIO->bufIO = buf;
    contextIO->context = &opContext;
    req->data = contextIO;
    ++refCount;

    if (memcpy_s(buf, sizeLog, bufLog, sizeLog)) {
    }
    uv_buf_t iov = uv_buf_init(reinterpret_cast<char *>(buf), sizeLog);
    uv_fs_write(loopTask, req, opContext.fileLog, &iov, 1, opContext.fileBufIndex, OnFileIO);
    opContext.fileBufIndex += sizeLog;
    return true;
}

bool HdcHostUnity::CommandDispatch(const uint16_t command, uint8_t *payload, const int payloadSize)
{
    bool ret = true;
    // Both are executed, do not need to detect ChildReady
    switch (command) {
        case CMD_UNITY_BUGREPORT_INIT: {
            if (strlen(reinterpret_cast<char *>(payload))) {  // enable local log
                if (!InitLocalLog(reinterpret_cast<const char *>(payload))) {
                    LogMsg(MSG_FAIL, "Cannot set locallog");
                    ret = false;
                    break;
                };
                opContext.enableLog = true;
            }
            SendToAnother(CMD_UNITY_BUGREPORT_INIT, nullptr, 0);
            break;
        }
        case CMD_UNITY_BUGREPORT_DATA: {
            if (opContext.enableLog) {
                AppendLocalLog(reinterpret_cast<const char *>(payload), payloadSize);
            } else {
                ServerCommand(CMD_KERNEL_ECHO_RAW, payload, payloadSize);
            }
            break;
        }
        default:
            break;
    }
    return ret;
};
}  // namespace Hdc