eive-obsw/bsp_q7s/memory/SdCardManager.cpp

459 lines
14 KiB
C++
Raw Normal View History

#include <fsfw/osal/linux/Timer.h>
2021-07-07 20:50:11 +02:00
#include "SdCardManager.h"
#include "scratchApi.h"
2021-07-12 11:37:10 +02:00
#include "linux/utility/utility.h"
2021-07-07 20:50:11 +02:00
#include "fsfw/ipc/MutexFactory.h"
2021-07-08 00:03:17 +02:00
#include "fsfw/serviceinterface/ServiceInterface.h"
2021-07-07 20:50:11 +02:00
2021-08-05 10:14:17 +02:00
#include <unistd.h>
2021-07-07 20:50:11 +02:00
#include <fstream>
2021-07-12 17:23:32 +02:00
#include <memory>
2021-07-07 20:50:11 +02:00
#include <filesystem>
2021-08-05 10:14:17 +02:00
#include <cstring>
2021-07-07 20:50:11 +02:00
SdCardManager* SdCardManager::factoryInstance = nullptr;
2021-08-05 15:43:19 +02:00
SdCardManager::SdCardManager(): cmdExecutor(256) {
2021-07-07 20:50:11 +02:00
}
SdCardManager::~SdCardManager() {
}
void SdCardManager::create() {
if(factoryInstance == nullptr) {
factoryInstance = new SdCardManager();
}
}
SdCardManager* SdCardManager::instance() {
SdCardManager::create();
return SdCardManager::factoryInstance;
}
2021-07-12 15:19:06 +02:00
ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCard,
2021-08-06 01:25:36 +02:00
SdStatePair* statusPair) {
2021-07-12 15:19:06 +02:00
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
2021-08-06 01:25:36 +02:00
if(doMountSdCard) {
if(not blocking) {
sif::warning << "SdCardManager::switchOnSdCard: Two-step command but manager is"
2021-08-08 00:11:21 +02:00
" not configured for blocking operation. "
"Forcing blocking mode.." << std::endl;
2021-08-06 01:25:36 +02:00
blocking = true;
}
}
std::unique_ptr<SdStatePair> sdStatusPtr;
2021-07-12 15:19:06 +02:00
if(statusPair == nullptr) {
2021-08-06 01:25:36 +02:00
sdStatusPtr = std::make_unique<SdStatePair>();
statusPair = sdStatusPtr.get();
2021-07-12 15:19:06 +02:00
result = getSdCardActiveStatus(*statusPair);
if(result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
}
2021-07-12 11:37:10 +02:00
// 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;
}
2021-07-12 15:19:06 +02:00
sd::SdState currentState;
2021-07-12 11:37:10 +02:00
if(sdCard == sd::SdCard::SLOT_0) {
currentState = statusPair->first;
2021-07-12 15:19:06 +02:00
}
else if(sdCard == sd::SdCard::SLOT_1) {
currentState = statusPair->second;
2021-07-12 15:19:06 +02:00
}
2021-07-16 22:20:53 +02:00
else {
// Should not happen
currentState = sd::SdState::OFF;
2021-07-16 22:20:53 +02:00
}
2021-07-12 15:19:06 +02:00
if(currentState == sd::SdState::ON) {
if(not doMountSdCard) {
return ALREADY_ON;
2021-07-12 15:19:06 +02:00
}
else {
return mountSdCard(sdCard);
2021-07-12 15:19:06 +02:00
}
}
else if(currentState == sd::SdState::MOUNTED) {
result = ALREADY_MOUNTED;
}
else if(currentState == sd::SdState::OFF) {
result = setSdCardState(sdCard, true);
}
else {
result = HasReturnvaluesIF::RETURN_FAILED;
}
2021-07-12 15:19:06 +02:00
2021-07-12 11:37:10 +02:00
if(result != HasReturnvaluesIF::RETURN_OK or not doMountSdCard) {
return result;
}
return mountSdCard(sdCard);
2021-07-07 20:50:11 +02:00
}
2021-07-12 15:19:06 +02:00
ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard,
2021-08-06 01:25:36 +02:00
SdStatePair* statusPair) {
std::pair<sd::SdState, sd::SdState> active;
ReturnValue_t result = getSdCardActiveStatus(active);
2021-07-08 12:07:39 +02:00
if(result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
2021-08-06 01:25:36 +02:00
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;
}
}
2021-07-12 15:58:43 +02:00
// Not allowed, this function turns off one SD card
2021-07-12 11:37:10 +02:00
if(sdCard == sd::SdCard::BOTH) {
sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
<< std::endl;
return HasReturnvaluesIF::RETURN_FAILED;
2021-07-08 12:07:39 +02:00
}
2021-07-12 11:37:10 +02:00
if(sdCard == sd::SdCard::SLOT_0) {
if(active.first == sd::SdState::OFF) {
2021-07-12 11:37:10 +02:00
return ALREADY_OFF;
}
}
else if(sdCard == sd::SdCard::SLOT_1) {
if(active.second == sd::SdState::OFF) {
2021-07-12 11:37:10 +02:00
return ALREADY_OFF;
}
}
if(doUnmountSdCard) {
result = unmountSdCard(sdCard);
if(result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
}
2021-07-08 11:23:08 +02:00
return setSdCardState(sdCard, false);
}
ReturnValue_t SdCardManager::setSdCardState(sd::SdCard sdCard, bool on) {
using namespace std;
2021-08-05 16:02:35 +02:00
if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
return CommandExecutor::COMMAND_PENDING;
}
string sdstring = "";
string statestring = "";
2021-07-08 11:23:08 +02:00
if(sdCard == sd::SdCard::SLOT_0) {
sdstring = "0";
}
else if(sdCard == sd::SdCard::SLOT_1) {
sdstring = "1";
}
if(on) {
2021-08-05 10:14:17 +02:00
currentOp = Operations::SWITCHING_ON;
2021-07-08 11:23:08 +02:00
statestring = "on";
}
else {
2021-08-05 10:14:17 +02:00
currentOp = Operations::SWITCHING_OFF;
2021-07-08 11:23:08 +02:00
statestring = "off";
}
ostringstream command;
2021-07-09 17:21:26 +02:00
command << "q7hw sd set " << sdstring << " " << statestring;
2021-08-08 00:11:21 +02:00
cmdExecutor.load(command.str(), blocking, printCmdOutput);
2021-08-05 15:43:19 +02:00
ReturnValue_t result = cmdExecutor.execute();
if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::setSdCardState");
}
return result;
2021-07-07 20:50:11 +02:00
}
2021-08-06 01:25:36 +02:00
ReturnValue_t SdCardManager::getSdCardActiveStatus(SdStatePair& active) {
2021-07-08 00:03:17 +02:00
using namespace std;
2021-07-12 11:47:23 +02:00
if(not filesystem::exists(SD_STATE_FILE)) {
2021-07-08 11:23:08 +02:00
return STATUS_FILE_NEXISTS;
2021-07-07 20:50:11 +02:00
}
2021-07-08 00:03:17 +02:00
// Now the file should exist in any case. Still check whether it exists.
2021-07-12 11:47:23 +02:00
fstream sdStatus(SD_STATE_FILE);
2021-07-08 00:03:17 +02:00
if (not sdStatus.good()) {
2021-07-08 11:23:08 +02:00
return STATUS_FILE_NEXISTS;
2021-07-08 00:03:17 +02:00
}
string line;
uint8_t idx = 0;
2021-07-12 11:37:10 +02:00
sd::SdCard currentSd = sd::SdCard::SLOT_0;
// Process status file line by line
2021-07-08 00:03:17 +02:00
while (std::getline(sdStatus, line)) {
2021-07-12 11:37:10 +02:00
processSdStatusLine(active, line, idx, currentSd);
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
using namespace std;
2021-08-05 16:02:35 +02:00
if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
return CommandExecutor::COMMAND_PENDING;
2021-08-05 10:14:17 +02:00
}
2021-07-12 11:37:10 +02:00
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;
2021-07-12 11:37:10 +02:00
if(sdCard == sd::SdCard::SLOT_0) {
mountDev = SD_0_DEV_NAME;
mountPoint = SD_0_MOUNT_POINT;
}
else if(sdCard == sd::SdCard::SLOT_1) {
2021-07-12 15:19:06 +02:00
mountDev = SD_1_DEV_NAME;
2021-07-12 11:37:10 +02:00
mountPoint = SD_1_MOUNT_POINT;
}
if(not filesystem::exists(mountDev)) {
2021-07-12 11:37:10 +02:00
sif::warning << "SdCardManager::mountSdCard: Device file does not exists. Make sure to"
" turn on the SD card" << std::endl;
return MOUNT_ERROR;
}
2021-08-05 16:02:35 +02:00
if(not blocking) {
currentOp = Operations::MOUNTING;
}
2021-07-12 11:37:10 +02:00
string sdMountCommand = "mount " + mountDev + " " + mountPoint;
2021-08-08 00:11:21 +02:00
cmdExecutor.load(sdMountCommand, blocking, printCmdOutput);
2021-08-05 15:43:19 +02:00
ReturnValue_t result = cmdExecutor.execute();
if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
}
return result;
2021-07-12 11:37:10 +02:00
}
ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
2021-08-05 16:02:35 +02:00
if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
return CommandExecutor::COMMAND_PENDING;
}
2021-07-12 11:37:10 +02:00
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;
}
2021-07-23 18:20:01 +02:00
if(not filesystem::exists(mountPoint)) {
sif::error << "SdCardManager::unmountSdCard: Default mount point " << mountPoint <<
"does not exist" << std::endl;
return UNMOUNT_ERROR;
}
2021-07-12 11:37:10 +02:00
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;
2021-08-05 16:02:35 +02:00
if(not blocking) {
currentOp = Operations::UNMOUNTING;
}
2021-08-08 00:11:21 +02:00
cmdExecutor.load(sdUnmountCommand, blocking, printCmdOutput);
2021-08-05 15:43:19 +02:00
ReturnValue_t result = cmdExecutor.execute();
if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::unmountSdCard");
}
return result;
2021-07-12 11:37:10 +02:00
}
2021-08-06 01:25:36 +02:00
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) {
2021-08-06 01:25:36 +02:00
result = getPreferredSdCard(prefSdCard);
if(result != HasReturnvaluesIF::RETURN_OK) {}
2021-07-12 17:23:32 +02:00
}
if(statusPair == nullptr) {
2021-08-06 01:25:36 +02:00
sdStatusPtr = std::make_unique<SdStatePair>();
statusPair = sdStatusPtr.get();
2021-07-12 17:23:32 +02:00
getSdCardActiveStatus(*statusPair);
}
if(statusPair->first == sd::SdState::ON) {
2021-08-06 01:25:36 +02:00
result = mountSdCard(prefSdCard);
}
2021-07-12 17:23:32 +02:00
2021-08-06 01:25:36 +02:00
result = switchOnSdCard(prefSdCard, true, statusPair);
if(resetNonBlockingState) {
blocking = false;
}
return result;
2021-07-12 17:23:32 +02:00
}
2021-08-05 16:02:35 +02:00
void SdCardManager::resetState() {
cmdExecutor.reset();
currentOp = Operations::IDLE;
}
void SdCardManager::processSdStatusLine(std::pair<sd::SdState, sd::SdState> &active,
2021-07-12 11:37:10 +02:00
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) {
2021-07-09 17:54:32 +02:00
if (word == "1:") {
currentSd = sd::SdCard::SLOT_1;
}
2021-07-08 11:23:08 +02:00
if(word == "on") {
2021-07-09 17:54:32 +02:00
if(currentSd == sd::SdCard::SLOT_0) {
active.first = sd::SdState::ON;
2021-07-09 17:54:32 +02:00
}
else {
active.second = sd::SdState::ON;
2021-07-09 17:54:32 +02:00
}
2021-07-08 11:23:08 +02:00
}
else if (word == "off") {
2021-07-09 17:54:32 +02:00
if(currentSd == sd::SdCard::SLOT_0) {
active.first = sd::SdState::OFF;
2021-07-09 17:54:32 +02:00
}
else {
active.second = sd::SdState::OFF;
2021-07-09 17:54:32 +02:00
}
2021-07-08 11:23:08 +02:00
}
2021-07-12 11:37:10 +02:00
}
if(mountLine) {
if(currentSd == sd::SdCard::SLOT_0) {
active.first = sd::SdState::MOUNTED;
2021-07-12 11:37:10 +02:00
}
2021-07-08 11:23:08 +02:00
else {
active.second = sd::SdState::MOUNTED;
2021-07-08 11:23:08 +02:00
}
2021-07-12 11:37:10 +02:00
}
2021-07-09 17:54:32 +02:00
2021-07-12 11:37:10 +02:00
if(idx > 5) {
sif::warning << "SdCardManager::sdCardActive: /tmp/sd_status.txt has more than 6 "
"lines and might be invalid!" << std::endl;
2021-07-08 00:03:17 +02:00
}
}
2021-07-12 11:37:10 +02:00
idx++;
2021-07-07 20:50:11 +02:00
}
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;
2021-07-07 20:50:11 +02:00
}
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));
2021-07-07 20:50:11 +02:00
}
2021-07-08 00:03:17 +02:00
ReturnValue_t SdCardManager::updateSdCardStateFile() {
2021-08-05 16:02:35 +02:00
if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
return CommandExecutor::COMMAND_PENDING;
}
2021-07-12 11:47:23 +02:00
// Use q7hw utility and pipe the command output into the state file
2021-07-12 11:49:19 +02:00
std::string updateCmd = "q7hw sd info all > " + std::string(SD_STATE_FILE);
2021-08-08 00:11:21 +02:00
cmdExecutor.load(updateCmd, blocking, printCmdOutput);
2021-08-05 15:43:19 +02:00
ReturnValue_t result = cmdExecutor.execute();
if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
2021-07-08 00:03:17 +02:00
}
2021-08-05 15:43:19 +02:00
return result;
2021-07-07 20:50:11 +02:00
}
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;
}
}
2021-08-05 10:14:17 +02:00
SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations &currentOp) {
2021-08-05 16:02:35 +02:00
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;
2021-08-05 18:37:14 +02:00
#if OBSW_ENABLE_TIMERS == 1
Timer timer;
2021-08-05 18:37:14 +02:00
timer.setTimer(100);
uint32_t remainingTimeMs = 0;
2021-08-05 18:37:14 +02:00
#endif
2021-08-05 16:02:35 +02:00
while(true) {
ReturnValue_t result = cmdExecutor.check(bytesRead);
2021-08-05 18:37:14 +02:00
// 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;
}
2021-08-05 18:37:14 +02:00
#endif
2021-08-05 16:02:35 +02:00
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;
}
}
}
2021-08-05 10:14:17 +02:00
}
2021-08-05 15:43:19 +02:00
void SdCardManager::setBlocking(bool blocking) {
this->blocking = blocking;
}
2021-08-08 00:11:21 +02:00
void SdCardManager::setPrintCommandOutput(bool print) {
this->printCmdOutput = print;
}