eive-obsw/bsp_q7s/memory/SdCardManager.cpp

#include "SdCardManager.h"
#include "scratchApi.h"

#include "linux/utility/utility.h"

#include "fsfw/ipc/MutexFactory.h"
#include "fsfw/serviceinterface/ServiceInterface.h"

#include <unistd.h>

#include <fstream>
#include <memory>
#include <filesystem>
#include <cstring>

SdCardManager* SdCardManager::factoryInstance = nullptr;

SdCardManager::SdCardManager(): cmdExecutor(256) {
}

SdCardManager::~SdCardManager() {
}

void SdCardManager::create() {
    if(factoryInstance == nullptr) {
        factoryInstance = new SdCardManager();
    }
}

SdCardManager* SdCardManager::instance() {
    SdCardManager::create();
    return SdCardManager::factoryInstance;
}

ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCard,
        SdStatePair* statusPair) {
    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
    if(doMountSdCard) {
        if(not blocking) {
            sif::warning << "SdCardManager::switchOnSdCard: Two-step command but manager is"
                    " not configured for blocking operation. "
                    "Forcing blocking mode.." << std::endl;
            blocking = true;
        }
    }
    std::unique_ptr<SdStatePair> sdStatusPtr;
    if(statusPair == nullptr) {
        sdStatusPtr = std::make_unique<SdStatePair>();
        statusPair = sdStatusPtr.get();
        result = getSdCardActiveStatus(*statusPair);
        if(result != HasReturnvaluesIF::RETURN_OK) {
            return result;
        }
    }

    // Not allowed, this function turns on one SD card
    if(sdCard == sd::SdCard::BOTH) {
        sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
                << std::endl;
        return HasReturnvaluesIF::RETURN_FAILED;
    }

    sd::SdState currentState;
    if(sdCard == sd::SdCard::SLOT_0) {
        currentState = statusPair->first;
    }
    else if(sdCard == sd::SdCard::SLOT_1) {
        currentState = statusPair->second;
    }
    else {
        // Should not happen
        currentState = sd::SdState::OFF;
    }

    if(currentState == sd::SdState::ON) {
        if(not doMountSdCard) {
            return ALREADY_ON;
        }
        else {
            return mountSdCard(sdCard);
        }
    }
    else if(currentState == sd::SdState::MOUNTED) {
        result = ALREADY_MOUNTED;
    }
    else if(currentState == sd::SdState::OFF) {
        result = setSdCardState(sdCard, true);
    }
    else {
        result = HasReturnvaluesIF::RETURN_FAILED;
    }

    if(result != HasReturnvaluesIF::RETURN_OK or not doMountSdCard) {
        return result;
    }

    return mountSdCard(sdCard);
}

ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard,
        SdStatePair* statusPair) {
    std::pair<sd::SdState, sd::SdState> active;
    ReturnValue_t result = getSdCardActiveStatus(active);
    if(result != HasReturnvaluesIF::RETURN_OK) {
        return result;
    }
    if(doUnmountSdCard) {
        if(not blocking) {
            sif::warning << "SdCardManager::switchOffSdCard: Two-step command but manager is"
                    " not configured for blocking operation. Forcing blocking mode.." << std::endl;
            blocking = true;
        }
    }
    // Not allowed, this function turns off one SD card
    if(sdCard == sd::SdCard::BOTH) {
        sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
                << std::endl;
        return HasReturnvaluesIF::RETURN_FAILED;
    }
    if(sdCard == sd::SdCard::SLOT_0) {
        if(active.first == sd::SdState::OFF) {
            return ALREADY_OFF;
        }
    }
    else if(sdCard == sd::SdCard::SLOT_1) {
        if(active.second == sd::SdState::OFF) {
            return ALREADY_OFF;
        }
    }

    if(doUnmountSdCard) {
        result = unmountSdCard(sdCard);
        if(result != HasReturnvaluesIF::RETURN_OK) {
            return result;
        }
    }

    return setSdCardState(sdCard, false);
}

ReturnValue_t SdCardManager::setSdCardState(sd::SdCard sdCard, bool on) {
    using namespace std;
    if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
        return CommandExecutor::COMMAND_PENDING;
    }
    string sdstring = "";
    string statestring = "";
    if(sdCard == sd::SdCard::SLOT_0) {
        sdstring = "0";
    }
    else if(sdCard == sd::SdCard::SLOT_1) {
        sdstring = "1";
    }
    if(on) {
        currentOp = Operations::SWITCHING_ON;
        statestring = "on";
    }
    else {
        currentOp = Operations::SWITCHING_OFF;
        statestring = "off";
    }
    ostringstream command;
    command << "q7hw sd set " << sdstring << " " << statestring;
    cmdExecutor.load(command.str(), blocking, printCmdOutput);
    ReturnValue_t result = cmdExecutor.execute();
    if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
        utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::setSdCardState");
    }
    return result;
}

ReturnValue_t SdCardManager::getSdCardActiveStatus(SdStatePair& active) {
    using namespace std;
    if(not filesystem::exists(SD_STATE_FILE)) {
        return STATUS_FILE_NEXISTS;
    }

    // Now the file should exist in any case. Still check whether it exists.
    fstream sdStatus(SD_STATE_FILE);
    if (not sdStatus.good()) {
        return STATUS_FILE_NEXISTS;
    }
    string line;
    uint8_t idx = 0;
    sd::SdCard currentSd = sd::SdCard::SLOT_0;
    // Process status file line by line
    while (std::getline(sdStatus, line)) {
        processSdStatusLine(active, line, idx, currentSd);
    }
    return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
    using namespace std;
    if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
        return CommandExecutor::COMMAND_PENDING;
    }
    if(sdCard == sd::SdCard::BOTH) {
        sif::warning << "SdCardManager::mountSdCard: API does not allow sd::SdStatus::BOTH"
                << std::endl;
        return HasReturnvaluesIF::RETURN_FAILED;
    }
    string mountDev;
    string mountPoint;
    if(sdCard == sd::SdCard::SLOT_0) {
        mountDev = SD_0_DEV_NAME;
        mountPoint = SD_0_MOUNT_POINT;
    }
    else if(sdCard == sd::SdCard::SLOT_1) {
        mountDev = SD_1_DEV_NAME;
        mountPoint = SD_1_MOUNT_POINT;
    }
    if(not filesystem::exists(mountDev)) {
        sif::warning << "SdCardManager::mountSdCard: Device file does not exists. Make sure to"
                " turn on the SD card" << std::endl;
        return MOUNT_ERROR;
    }

    if(not blocking) {
        currentOp = Operations::MOUNTING;
    }
    string sdMountCommand = "mount " + mountDev + " " + mountPoint;
    cmdExecutor.load(sdMountCommand, blocking, printCmdOutput);
    ReturnValue_t result = cmdExecutor.execute();
    if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
        utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
    }
    return result;
}

ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
    if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
        return CommandExecutor::COMMAND_PENDING;
    }
    using namespace std;
    if(sdCard == sd::SdCard::BOTH) {
        sif::warning << "SdCardManager::unmountSdCard: API does not allow sd::SdStatus::BOTH"
                << std::endl;
        return HasReturnvaluesIF::RETURN_FAILED;
    }
    string mountPoint;
    if(sdCard == sd::SdCard::SLOT_0) {
        mountPoint = SD_0_MOUNT_POINT;
    }
    else if(sdCard == sd::SdCard::SLOT_1) {
        mountPoint = SD_1_MOUNT_POINT;
    }
    if(not filesystem::exists(mountPoint)) {
        sif::error << "SdCardManager::unmountSdCard: Default mount point " << mountPoint <<
                "does not exist" << std::endl;
        return UNMOUNT_ERROR;
    }
    if(filesystem::is_empty(mountPoint)) {
        // The mount point will always exist, but if it is empty, that is strong hint that
        // the SD card was not mounted properly. Still proceed with operation.
        sif::warning << "SdCardManager::unmountSdCard: Mount point is empty!" << std::endl;
    }
    string sdUnmountCommand = "umount " + mountPoint;
    if(not blocking) {
        currentOp = Operations::UNMOUNTING;
    }
    cmdExecutor.load(sdUnmountCommand, blocking, printCmdOutput);
    ReturnValue_t result = cmdExecutor.execute();
    if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
        utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::unmountSdCard");
    }
    return result;
}

ReturnValue_t SdCardManager::sanitizeState(SdStatePair* statusPair, sd::SdCard prefSdCard) {
    std::unique_ptr<SdStatePair> sdStatusPtr;
    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
    // Enforce blocking operation for now. Be careful to reset it when returning prematurely!
    bool resetNonBlockingState = false;
    if(not this->blocking) {
        blocking = true;
        resetNonBlockingState = true;
    }
    if(prefSdCard == sd::SdCard::NONE) {
        result = getPreferredSdCard(prefSdCard);
        if(result != HasReturnvaluesIF::RETURN_OK) {}
    }
    if(statusPair == nullptr) {
        sdStatusPtr = std::make_unique<SdStatePair>();
        statusPair = sdStatusPtr.get();
        getSdCardActiveStatus(*statusPair);
    }

    if(statusPair->first == sd::SdState::ON) {
        result =  mountSdCard(prefSdCard);
    }

    result = switchOnSdCard(prefSdCard, true, statusPair);
    if(resetNonBlockingState) {
        blocking = false;
    }
    return result;
}

void SdCardManager::resetState() {
    cmdExecutor.reset();
    currentOp = Operations::IDLE;
}

void SdCardManager::processSdStatusLine(std::pair<sd::SdState, sd::SdState> &active,
        std::string& line, uint8_t& idx, sd::SdCard& currentSd) {
    using namespace std;
    istringstream iss(line);
    string word;
    bool slotLine = false;
    bool mountLine = false;
    while(iss >> word) {
        if (word == "Slot") {
            slotLine = true;
        }
        if(word == "Mounted") {
            mountLine = true;
        }

        if(slotLine) {
            if (word == "1:") {
                currentSd = sd::SdCard::SLOT_1;
            }

            if(word == "on") {
                if(currentSd == sd::SdCard::SLOT_0) {
                    active.first = sd::SdState::ON;
                }
                else {
                    active.second = sd::SdState::ON;
                }
            }
            else if (word == "off") {
                if(currentSd == sd::SdCard::SLOT_0) {
                    active.first = sd::SdState::OFF;
                }
                else {
                    active.second = sd::SdState::OFF;
                }
            }
        }

        if(mountLine) {
            if(currentSd == sd::SdCard::SLOT_0) {
                active.first = sd::SdState::MOUNTED;
            }
            else {
                active.second = sd::SdState::MOUNTED;
            }
        }

        if(idx > 5) {
            sif::warning << "SdCardManager::sdCardActive: /tmp/sd_status.txt has more than 6 "
                    "lines and might be invalid!" << std::endl;
        }
    }
    idx++;
}

ReturnValue_t SdCardManager::getPreferredSdCard(sd::SdCard& sdCard) const {
    uint8_t prefSdCard = 0;
    ReturnValue_t result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdCard);
    if(result != HasReturnvaluesIF::RETURN_OK) {
        return result;
    }
    sdCard = static_cast<sd::SdCard>(prefSdCard);
    return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t SdCardManager::setPreferredSdCard(sd::SdCard sdCard) {
    if(sdCard == sd::SdCard::BOTH) {
        return HasReturnvaluesIF::RETURN_FAILED;
    }
    return scratch::writeNumber(scratch::PREFERED_SDC_KEY, static_cast<uint8_t>(sdCard));
}

ReturnValue_t SdCardManager::updateSdCardStateFile() {
    if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
        return CommandExecutor::COMMAND_PENDING;
    }
    // Use q7hw utility and pipe the command output into the state file
    std::string updateCmd = "q7hw sd info all > " + std::string(SD_STATE_FILE);
    cmdExecutor.load(updateCmd, blocking, printCmdOutput);
    ReturnValue_t result = cmdExecutor.execute();
    if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
        utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
    }
    return result;
}

std::string SdCardManager::getCurrentMountPrefix(sd::SdCard prefSdCard) {
    if(prefSdCard == sd::SdCard::NONE) {
        ReturnValue_t result = getPreferredSdCard(prefSdCard);
        if(result != HasReturnvaluesIF::RETURN_OK) {
            return SD_0_MOUNT_POINT;
        }
    }
    if(prefSdCard == sd::SdCard::SLOT_0) {
        return SD_0_MOUNT_POINT;
    }
    else {
        return SD_1_MOUNT_POINT;
    }
}

SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations &currentOp) {
    CommandExecutor::States state = cmdExecutor.getCurrentState();
    if(state == CommandExecutor::States::IDLE or state == CommandExecutor::States::COMMAND_LOADED) {
        return OpStatus::IDLE;
    }
    currentOp = this->currentOp;
    bool bytesRead = false;

#if OBSW_ENABLE_TIMERS == 1
    Timer timer;
    timer.setTimer(100);
    uint32_t remainingTimeMs = 0;
#endif
    while(true) {
        ReturnValue_t result = cmdExecutor.check(bytesRead);
        // This timer can prevent deadlocks due to missconfigurations
#if OBSW_ENABLE_TIMERS == 1
        timer.getTimer(&remainingTimeMs);
        if(remainingTimeMs == 0) {
            sif::error << "SdCardManager::checkCurrentOp: Timeout!" << std::endl;
            return OpStatus::FAIL;
        }
#endif
        switch(result) {
        case(CommandExecutor::BYTES_READ): {
            continue;
        }
        case(CommandExecutor::EXECUTION_FINISHED): {
            return OpStatus::SUCCESS;
        }
        case(HasReturnvaluesIF::RETURN_OK): {
            return OpStatus::ONGOING;
        }
        case(HasReturnvaluesIF::RETURN_FAILED): {
            return OpStatus::FAIL;
        }
        default: {
            sif::warning << "SdCardManager::checkCurrentOp: Unhandled case" << std::endl;
        }
        }
    }
}

void SdCardManager::setBlocking(bool blocking) {
    this->blocking = blocking;
}

void SdCardManager::setPrintCommandOutput(bool print) {
    this->printCmdOutput = print;

}

bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) {
    SdCardManager::SdStatePair active;
    ReturnValue_t result = this->getSdCardActiveStatus(active);
    if (result != HasReturnvaluesIF::RETURN_OK) {
        sif::debug << "SdCardManager::isSdCardMounted: Failed to get SD card active state";
        return false;
    }
    if (sdCard == sd::SLOT_0) {
        if (active.first == sd::MOUNTED) {
            return true;
        }
        else {
            return false;
        }
    }
    else if (sdCard == sd::SLOT_1) {
        if (active.second == sd::MOUNTED) {
            return true;
        }
        else {
            return false;
        }
    }
    else {
        sif::debug << "SdCardManager::isSdCardMounted: Unknown SD card specified" << std::endl;
    }
    return false;
}