584 lines
21 KiB
C++
584 lines
21 KiB
C++
/**
|
||
* @file reHDD.cpp
|
||
* @brief app logic
|
||
* @author hendrik schutter
|
||
* @date 01.05.2020
|
||
*/
|
||
|
||
#include "../include/reHDD.h"
|
||
|
||
static int fdNewDrivesInformPipe[2];//File descriptor for pipe that informs if new drives are found
|
||
|
||
static int fdShredInformPipe[2];//File descriptor for pipe that informs if a wipe thread signals
|
||
|
||
static std::mutex mxDrives;
|
||
|
||
list <Drive> listNewDrives; //store found drives that are updated every 5sec
|
||
|
||
static list <Drive> listDrives; //stores all drive data from scann thread
|
||
|
||
TUI *ui;
|
||
|
||
static uint8_t u8SelectedEntry;
|
||
|
||
static fd_set selectSet;
|
||
|
||
/**
|
||
* \brief app constructor
|
||
* \param void
|
||
* \return instance of App
|
||
*/
|
||
reHDD::reHDD(void)
|
||
{
|
||
u8SelectedEntry = 0U;
|
||
}
|
||
|
||
/**
|
||
* \brief app logic
|
||
* \param void
|
||
* \return void
|
||
*/
|
||
void reHDD::app_logic(void)
|
||
{
|
||
ui = new TUI();
|
||
ui->initTUI();
|
||
|
||
pipe(fdNewDrivesInformPipe);
|
||
pipe(fdShredInformPipe);
|
||
|
||
thread thDevices(ThreadScannDevices); //start thread that scanns for drives
|
||
thread thUserInput(ThreadUserInput); //start thread that reads user input
|
||
thread thCheckFrozenDrives(ThreadCheckFrozenDrives); //start thread that checks timeout for drives
|
||
|
||
while(1)
|
||
{
|
||
FD_ZERO(&selectSet);
|
||
FD_SET(fdNewDrivesInformPipe[0], &selectSet);
|
||
FD_SET(fdShredInformPipe[0], &selectSet);
|
||
|
||
select(FD_SETSIZE, &selectSet, NULL, NULL, NULL);
|
||
|
||
if(FD_ISSET(fdNewDrivesInformPipe[0], &selectSet))
|
||
{
|
||
mxDrives.lock();
|
||
char dummy;
|
||
read (fdNewDrivesInformPipe[0],&dummy,1);
|
||
filterNewDrives(&listDrives, &listNewDrives); //filter and copy to app logic vector
|
||
printDrives(&listDrives);
|
||
mxDrives.unlock();
|
||
}
|
||
if(FD_ISSET(fdShredInformPipe[0], &selectSet))
|
||
{
|
||
char dummy;
|
||
read (fdShredInformPipe[0],&dummy,1);
|
||
updateShredMetrics(&listDrives);
|
||
#ifdef LOG_LEVEL_HIGH
|
||
Logger::logThis()->info("got progress signal from a shred task");
|
||
#endif
|
||
|
||
|
||
|
||
|
||
}
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
} //endless loop
|
||
thDevices.join();
|
||
thUserInput.join();
|
||
thCheckFrozenDrives.join();
|
||
}
|
||
|
||
Drive* reHDD::getSelectedDrive()
|
||
{
|
||
if(u8SelectedEntry < listDrives.size() )
|
||
{
|
||
list<Drive>::iterator it = listDrives.begin();
|
||
advance(it, u8SelectedEntry);
|
||
return &(*it);
|
||
}
|
||
else
|
||
{
|
||
Logger::logThis()->warning("selected drive not present");
|
||
return {};
|
||
}
|
||
}
|
||
|
||
void reHDD::ThreadScannDevices()
|
||
{
|
||
while(true)
|
||
{
|
||
mxDrives.lock();
|
||
listNewDrives.clear();
|
||
searchDrives(&listNewDrives); //search for new drives and store them in list
|
||
filterIgnoredDrives(&listNewDrives); //filter out ignored drives
|
||
addSMARTData(&listNewDrives); //add S.M.A.R.T. Data to the drives
|
||
mxDrives.unlock();
|
||
write(fdNewDrivesInformPipe[1], "A",1);
|
||
sleep(5); //sleep 5 sec
|
||
}
|
||
}
|
||
|
||
void reHDD::ThreadCheckFrozenDrives()
|
||
{
|
||
while(true)
|
||
{
|
||
mxDrives.lock();
|
||
for(auto it = begin(listDrives); it != end(listDrives); ++it)
|
||
{
|
||
if(it->state == Drive::SHRED_ACTIVE)
|
||
{
|
||
it->checkFrozenDrive();
|
||
}
|
||
}
|
||
mxDrives.unlock();
|
||
sleep(13); //sleep 13 sec
|
||
}
|
||
}
|
||
|
||
void reHDD::ThreadUserInput()
|
||
{
|
||
while(true)
|
||
{
|
||
// cout << TUI::readUserInput() << endl;
|
||
switch (TUI::readUserInput())
|
||
{
|
||
case TUI::UserInput::DownKey:
|
||
//cout << "Down" << endl;
|
||
handleArrowKey(TUI::UserInput::DownKey);
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
break;
|
||
case TUI::UserInput::UpKey:
|
||
//cout << "Up" << endl;
|
||
handleArrowKey(TUI::UserInput::UpKey);
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
break;
|
||
case TUI::UserInput::Undefined:
|
||
//cout << "Undefined" << endl;
|
||
break;
|
||
case TUI::UserInput::Abort:
|
||
//cout << "Abort" << endl;
|
||
handleAbort();
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
break;
|
||
case TUI::UserInput::Delete:
|
||
//cout << "Delete" << endl;
|
||
|
||
if (getSelectedDrive() != nullptr)
|
||
{
|
||
if(getSelectedDrive()->state == Drive::NONE)
|
||
{
|
||
getSelectedDrive()->state = Drive::DELETE_SELECTED;
|
||
}
|
||
}
|
||
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
break;
|
||
case TUI::UserInput::Shred:
|
||
//cout << "Shred" << endl;
|
||
|
||
if (getSelectedDrive() != nullptr)
|
||
{
|
||
if(getSelectedDrive()->state == Drive::NONE)
|
||
{
|
||
getSelectedDrive()->state = Drive::SHRED_SELECTED;
|
||
}
|
||
}
|
||
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
break;
|
||
case TUI::UserInput::ShredAll:
|
||
//cout << "ShredAll" << endl;
|
||
startShredAllDrives(&listDrives);
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
break;
|
||
case TUI::UserInput::Enter:
|
||
//cout << "Enter" << endl;
|
||
handleEnter();
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
break;
|
||
case TUI::UserInput::ESC:
|
||
//cout << "ESC" << endl;
|
||
handleESC();
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void reHDD::ThreadShred(Drive* const pDrive)
|
||
{
|
||
if (pDrive != nullptr)
|
||
{
|
||
pDrive->setActionStartTimestamp(); //save timestamp at start of shredding
|
||
Shred* pShredTask = new Shred(); //create new shred task
|
||
pShredTask->shredDrive(pDrive, &fdShredInformPipe[1]); //start new shred task
|
||
delete pShredTask; //delete shred task
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
}
|
||
}
|
||
|
||
void reHDD::ThreadDelete()
|
||
{
|
||
if (getSelectedDrive() != nullptr)
|
||
{
|
||
getSelectedDrive()->setActionStartTimestamp(); //save timestamp at start of deleting
|
||
Delete::deleteDrive(getSelectedDrive()); //blocking, no thread
|
||
getSelectedDrive()->state = Drive::TaskState::NONE; //delete finished
|
||
getSelectedDrive()->bWasDeleteted = true;
|
||
Logger::logThis()->info("Finished delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
|
||
ui->updateTUI(&listDrives, u8SelectedEntry);
|
||
}
|
||
}
|
||
|
||
void reHDD::filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives)
|
||
{
|
||
list <Drive>::iterator itOld; //Iterator for current (old) drive list
|
||
list <Drive>::iterator itNew; //Iterator for new drive list that was created from to scann thread
|
||
|
||
//remove offline old drives from previously run
|
||
for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end();)
|
||
{
|
||
if(itOld->bIsOffline == true)
|
||
{
|
||
Logger::logThis()->warning("Offline drive found: " + itOld->getPath());
|
||
itOld = plistOldDrives->erase(itOld);
|
||
/*
|
||
if(plistOldDrives->size() > 0){ //This can be a risk if the user starts a task for the selected drive and the selected drive changes
|
||
u8SelectedEntry = 0U;
|
||
}
|
||
*/
|
||
}
|
||
else
|
||
{
|
||
++itOld;
|
||
}
|
||
}
|
||
|
||
//search offline drives and mark them
|
||
for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld)
|
||
{
|
||
itOld->bIsOffline = true; //set offline before searching in the new list
|
||
for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end();)
|
||
{
|
||
if((itOld->getSerial() == itNew->getSerial()) || (itOld->getPath() == itNew->getPath()))
|
||
{
|
||
itOld->bIsOffline = false; //drive is still attached
|
||
//copy new smart data to existing drive
|
||
itOld->setDriveSMARTData(itNew->getModelFamily(), itNew->getModelName(), itNew->getSerial(), itNew->getCapacity(), itNew->getErrorCount(), itNew->getPowerOnHours(), itNew->getPowerCycles(), itNew->getTemperature());
|
||
#ifdef LOG_LEVEL_HIGH
|
||
Logger::logThis()->info("Delete new drive, because allready attached: " + itNew->getModelName());
|
||
#endif
|
||
itNew = plistNewDrives->erase(itNew); //This drive is allready attached, remove from new list
|
||
}
|
||
else
|
||
{
|
||
++itNew;
|
||
}
|
||
}
|
||
}
|
||
|
||
//mark offline old drives
|
||
for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld)
|
||
{
|
||
if(itOld->bIsOffline == true)
|
||
{
|
||
//cout << "offline drive found: " << itOld->getPath() << endl;
|
||
Logger::logThis()->warning("Mark offline drive found: " + itOld->getPath());
|
||
itOld->state = Drive::NONE; //clear state --> shred task will terminate
|
||
}
|
||
}
|
||
|
||
//add new drives to drive list
|
||
for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end(); ++itNew)
|
||
{
|
||
plistOldDrives->push_back(*itNew);
|
||
//Logger::logThis()->info("Add new drive: " + itNew->getModelName());
|
||
}
|
||
plistNewDrives->clear();
|
||
}
|
||
|
||
/**
|
||
* \brief search attached drives on /dev/sd*
|
||
* \param pointer of list <Drive>* plistDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::searchDrives(list <Drive>* plistDrives)
|
||
{
|
||
//Logger::logThis()->info("--> search drives <--");
|
||
char * cLine = NULL;
|
||
size_t len = 0;
|
||
|
||
FILE* outputfileHwinfo = popen("lsblk -I 8 -d -o NAME", "r");
|
||
|
||
if (outputfileHwinfo == NULL)
|
||
{
|
||
Logger::logThis()->error("Unable to scan attached drives");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
while ((getline(&cLine, &len, outputfileHwinfo)) != -1)
|
||
{
|
||
if (string(cLine).length() == 4)
|
||
{
|
||
Drive* tmpDrive = new Drive("/dev/" + string(cLine).substr(0, 3));
|
||
tmpDrive->state = Drive::NONE;
|
||
tmpDrive->bIsOffline = false;
|
||
plistDrives->push_back(*tmpDrive);
|
||
//Logger::logThis()->info("drive found: " + tmpDrive->getPath());
|
||
}
|
||
}
|
||
pclose(outputfileHwinfo);
|
||
}
|
||
|
||
/**
|
||
* \brief filter out drives that are listed in "ignoreDrives.conf"
|
||
* \param pointer of list <Drive>* plistDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::filterIgnoredDrives(list <Drive>* plistDrives)
|
||
{
|
||
list<tuple<string>> vtlIgnoredDevices; //store drives from ingnore file
|
||
ifstream input( "ignoreDrives.conf" ); //read ingnore file
|
||
|
||
for(string sLine; getline( input, sLine );)
|
||
{
|
||
//Logger::logThis()->info("read uuid: " + sLine);
|
||
vtlIgnoredDevices.emplace_back(sLine); //add found path and uuid from ignore file to vector
|
||
}
|
||
//loop through found entries in ingnore file
|
||
for(auto row : vtlIgnoredDevices)
|
||
{
|
||
list <Drive>::iterator it;
|
||
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
|
||
{
|
||
string sUUID;
|
||
char * cLine = NULL;
|
||
size_t len = 0;
|
||
string sCMD = "blkid ";
|
||
sCMD.append(it->getPath());
|
||
//cout << "cmd: " << sCMD << endl;
|
||
FILE* outputfileBlkid = popen(sCMD.c_str(), "r"); //get UUID from drive
|
||
if (outputfileBlkid == NULL)
|
||
{
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
while ((getline(&cLine, &len, outputfileBlkid)) != -1) //parse UUID from blkid
|
||
{
|
||
if (string(cLine).find("PTUUID") != string::npos)
|
||
{
|
||
string sBlkidOut = string(cLine);
|
||
sBlkidOut.erase(0, 18);
|
||
sBlkidOut.erase(8, sBlkidOut.length());
|
||
sUUID = sBlkidOut;
|
||
//cout << "blkid uuid:" << sUUID << endl;
|
||
}
|
||
}
|
||
pclose(outputfileBlkid);
|
||
//cout << "blkid uuid:" << sUUID << endl;
|
||
|
||
if (!get<0>(row).compare(sUUID)) //compare uuid from ignore file and uuid from drive
|
||
{
|
||
// same uuid found than in ignore file --> ignore this drive
|
||
#ifdef LOG_LEVEL_HIGH
|
||
Logger::logThis()->info("same uuid found than in ignore file --> ignore this drive: " + it->getPath());
|
||
#endif
|
||
it = plistDrives->erase(it);
|
||
it--;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* \brief start shred for all drives
|
||
* \param pointer of list <Drive>* plistDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::startShredAllDrives(list <Drive>* plistDrives)
|
||
{
|
||
list <Drive>::iterator it;
|
||
mxDrives.lock();
|
||
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
|
||
{
|
||
if(it->state == Drive::NONE)
|
||
{
|
||
Drive* pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator > (it);
|
||
#ifdef LOG_LEVEL_HIGH
|
||
ostringstream address;
|
||
address << (void const *)&(*pTmpDrive);
|
||
Logger::logThis()->info("Started shred (all) for: " + pTmpDrive->getModelName() + "-" + pTmpDrive->getSerial() + " @" + address.str());
|
||
#endif
|
||
pTmpDrive->state = Drive::TaskState::SHRED_ACTIVE;
|
||
thread(ThreadShred, pTmpDrive).detach();
|
||
}
|
||
}
|
||
mxDrives.unlock();
|
||
}
|
||
|
||
/**
|
||
* \brief print drives with all information
|
||
* \param pointer of list <Drive>* plistDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::printDrives(list <Drive>* plistDrives)
|
||
{
|
||
#ifdef LOG_LEVEL_HIGH
|
||
Logger::logThis()->info("------------DRIVES START------------");
|
||
//cout << "------------DRIVES---------------" << endl;
|
||
list <Drive>::iterator it;
|
||
uint8_t u8Index = 0;
|
||
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
|
||
{
|
||
/*
|
||
cout << " Drive: " << distance(pvecDrives->begin(), it) << endl;
|
||
cout << "Path: " << it->getPath() << endl;
|
||
cout << "ModelFamily: " << it->getModelFamily() << endl;
|
||
cout << "ModelName: " << it->getModelName() << endl;
|
||
cout << "Capacity: " << it->getCapacity() << endl;
|
||
cout << "Serial: " << it->getSerial() << endl;
|
||
cout << "PowerOnHours: " << it->getPowerOnHours() << endl;
|
||
cout << "PowerCycle: " << it->getPowerCycles() << endl;
|
||
cout << "ErrorCount: " << it->getErrorCount() << endl;
|
||
cout << endl;*/
|
||
|
||
ostringstream address;
|
||
address << (void const *)&(*it);
|
||
Logger::logThis()->info(to_string(u8Index++) + ": " + it->getPath() + " - " + it->getModelFamily() + " - " + it->getSerial() + " @" + address.str());
|
||
}
|
||
Logger::logThis()->info("------------DRIVES END--------------");
|
||
//cout << "---------------------------------" << endl;
|
||
#endif
|
||
}
|
||
|
||
/**
|
||
* \brief update shred metrics for all drives
|
||
* \param pointer of list <Drive>* plistDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::updateShredMetrics(list <Drive>* plistDrives)
|
||
{
|
||
list <Drive>::iterator it;
|
||
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
|
||
{
|
||
if(it->state == Drive::SHRED_ACTIVE)
|
||
{
|
||
Drive* pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator > (it);
|
||
//set metrics for calculating shred speed
|
||
std::chrono::time_point<std::chrono::system_clock> chronoCurrentTimestamp = std::chrono::system_clock::now();
|
||
time_t u32ShredTimeDelta = (chronoCurrentTimestamp - pTmpDrive->sShredSpeed.chronoShredTimestamp).count();
|
||
if(u32ShredTimeDelta > METRIC_THRESHOLD)
|
||
{
|
||
pTmpDrive->sShredSpeed.u32ShredTimeDelta = u32ShredTimeDelta;
|
||
pTmpDrive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now();
|
||
pTmpDrive->sShredSpeed.ulWrittenBytes = pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten;
|
||
pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten = 0U;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* \brief add S.M.A.R.T data from SMART
|
||
* \param pointer of list <Drive>* plistDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::addSMARTData(list <Drive>* plistDrives)
|
||
{
|
||
list <Drive>::iterator it;
|
||
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
|
||
{
|
||
Drive* pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator > (it);
|
||
SMART::readSMARTData(pTmpDrive);
|
||
}
|
||
}
|
||
|
||
void reHDD::handleArrowKey(TUI::UserInput userInput)
|
||
{
|
||
int8_t u8EntrySize = (int8_t) listDrives.size();
|
||
switch (userInput)
|
||
{
|
||
case TUI::UserInput::DownKey:
|
||
u8SelectedEntry++;
|
||
if(u8SelectedEntry >= u8EntrySize)
|
||
{
|
||
u8SelectedEntry = 0;
|
||
}
|
||
break;
|
||
case TUI::UserInput::UpKey:
|
||
if(u8SelectedEntry == 0)
|
||
{
|
||
u8SelectedEntry = (u8EntrySize-1);
|
||
}
|
||
else
|
||
{
|
||
u8SelectedEntry--;
|
||
}
|
||
break;
|
||
default:
|
||
u8SelectedEntry = 0;
|
||
break;
|
||
}
|
||
|
||
//Logger::logThis()->info("ArrowKey - selected drive: " + to_string(u8SelectedEntry));
|
||
}
|
||
|
||
void reHDD::handleEnter()
|
||
{
|
||
|
||
if (getSelectedDrive() != nullptr)
|
||
{
|
||
if(getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED)
|
||
{
|
||
Logger::logThis()->info("Started shred for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
|
||
getSelectedDrive()->state = Drive::TaskState::SHRED_ACTIVE;
|
||
//task for drive is running --> don´t show more task options
|
||
Drive* pTmpDrive = getSelectedDrive();
|
||
thread(ThreadShred, pTmpDrive).detach();
|
||
}
|
||
|
||
if(getSelectedDrive()->state == Drive::TaskState::DELETE_SELECTED)
|
||
{
|
||
Logger::logThis()->info("Started delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
|
||
getSelectedDrive()->state = Drive::TaskState::DELETE_ACTIVE;
|
||
//task for drive is running --> don´t show more task options
|
||
thread(ThreadDelete).detach();
|
||
}
|
||
}
|
||
}
|
||
|
||
void reHDD::handleESC()
|
||
{
|
||
if (getSelectedDrive() != nullptr)
|
||
{
|
||
if(getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED)
|
||
{
|
||
getSelectedDrive()->state = Drive::TaskState::NONE;
|
||
//task for drive is selected --> remove selection
|
||
}
|
||
|
||
if(getSelectedDrive()->state == Drive::TaskState::DELETE_SELECTED)
|
||
{
|
||
getSelectedDrive()->state = Drive::TaskState::NONE;
|
||
//task for drive is selected --> remove selection
|
||
}
|
||
}
|
||
}
|
||
|
||
void reHDD::handleAbort()
|
||
{
|
||
if (getSelectedDrive() != nullptr)
|
||
{
|
||
if(getSelectedDrive()->state == Drive::SHRED_ACTIVE || getSelectedDrive()->state == Drive::DELETE_ACTIVE )
|
||
{
|
||
getSelectedDrive()->state = Drive::NONE;
|
||
Logger::logThis()->info("Abort-Shred-Signal for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
|
||
//task for drive is running --> remove selection
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|