localhorst/reHDD
1
0
Fork 0
Code Issues 7 Pull Requests Releases 9 Wiki Activity

filter drives with zero capacity

Browse Source
This commit is contained in:
Hendrik Schutter 2024-04-24 22:04:52 +02:00
parent 0ad7de4352
commit cb421885d0
2 changed files with 397 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/reHDD.h
View File

@ -89,6 +89,7 @@ private:
static void startShredAllDrives(list <Drive>* plistDrives); static void startShredAllDrives(list <Drive>* plistDrives);
static void updateShredMetrics(list <Drive>* plistDrives); static void updateShredMetrics(list <Drive>* plistDrives);
static void filterIgnoredDrives(list <Drive>* plistDrives); static void filterIgnoredDrives(list <Drive>* plistDrives);
static void filterInvalidDrives(list <Drive>* plistDrives);
static void filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives); static void filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives);
static void addSMARTData(list <Drive>* plistDrives); static void addSMARTData(list <Drive>* plistDrives);
static void ThreadScanDevices(); static void ThreadScanDevices();

773
src/reHDD.cpp
View File

@ -7,19 +7,19 @@
#include "../include/reHDD.h" #include "../include/reHDD.h"
static int fdNewDrivesInformPipe[2];//File descriptor for pipe that informs if new drives are found 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 int fdShredInformPipe[2]; // File descriptor for pipe that informs if a wipe thread signals
static std::mutex mxDrives; static std::mutex mxDrives;
list <Drive> listNewDrives; //store found drives that are updated every 5sec list<Drive> listNewDrives; // store found drives that are updated every 5sec
static list <Drive> listDrives; //stores all drive data from scan thread static list<Drive> listDrives; // stores all drive data from scan thread
TUI *ui; TUI *ui;
static uint8_t u8SelectedEntry; static uint8_t u8SelectedEntry;
static fd_set selectSet; static fd_set selectSet;
@ -46,251 +46,252 @@ void reHDD::app_logic(void)
pipe(fdNewDrivesInformPipe); pipe(fdNewDrivesInformPipe);
pipe(fdShredInformPipe); pipe(fdShredInformPipe);
thread thDevices(ThreadScanDevices); //start thread that scans for drives thread thDevices(ThreadScanDevices); // start thread that scans for drives
thread thUserInput(ThreadUserInput); //start thread that reads user input thread thUserInput(ThreadUserInput); // start thread that reads user input
thread thCheckFrozenDrives(ThreadCheckFrozenDrives); //start thread that checks timeout for drives thread thCheckFrozenDrives(ThreadCheckFrozenDrives); // start thread that checks timeout for drives
while(1) 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))
{ {
FD_ZERO(&selectSet); mxDrives.lock();
FD_SET(fdNewDrivesInformPipe[0], &selectSet); char dummy;
FD_SET(fdShredInformPipe[0], &selectSet); read(fdNewDrivesInformPipe[0], &dummy, 1);
filterNewDrives(&listDrives, &listNewDrives); // filter and copy to app logic vector
select(FD_SETSIZE, &selectSet, NULL, NULL, NULL); printDrives(&listDrives);
mxDrives.unlock();
if(FD_ISSET(fdNewDrivesInformPipe[0], &selectSet)) }
{ if (FD_ISSET(fdShredInformPipe[0], &selectSet))
mxDrives.lock(); {
char dummy; char dummy;
read (fdNewDrivesInformPipe[0],&dummy,1); read(fdShredInformPipe[0], &dummy, 1);
filterNewDrives(&listDrives, &listNewDrives); //filter and copy to app logic vector updateShredMetrics(&listDrives);
printDrives(&listDrives);
mxDrives.unlock();
}
if(FD_ISSET(fdShredInformPipe[0], &selectSet))
{
char dummy;
read (fdShredInformPipe[0],&dummy,1);
updateShredMetrics(&listDrives);
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("got progress signal from a shred task"); Logger::logThis()->info("got progress signal from a shred task");
#endif #endif
} }
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u8SelectedEntry);
} //endless loop } // endless loop
thDevices.join(); thDevices.join();
thUserInput.join(); thUserInput.join();
thCheckFrozenDrives.join(); thCheckFrozenDrives.join();
} }
Drive* reHDD::getSelectedDrive() Drive *reHDD::getSelectedDrive()
{ {
if(u8SelectedEntry < listDrives.size() ) if (u8SelectedEntry < listDrives.size())
{ {
list<Drive>::iterator it = listDrives.begin(); list<Drive>::iterator it = listDrives.begin();
advance(it, u8SelectedEntry); advance(it, u8SelectedEntry);
return &(*it); return &(*it);
} }
else else
{ {
Logger::logThis()->warning("selected drive not present"); Logger::logThis()->warning("selected drive not present");
return {}; return {};
} }
} }
void reHDD::ThreadScanDevices() void reHDD::ThreadScanDevices()
{ {
while(true) while (true)
{ {
mxDrives.lock(); mxDrives.lock();
listNewDrives.clear(); listNewDrives.clear();
searchDrives(&listNewDrives); //search for new drives and store them in list searchDrives(&listNewDrives); // search for new drives and store them in list
filterIgnoredDrives(&listNewDrives); //filter out ignored drives filterIgnoredDrives(&listNewDrives); // filter out ignored drives
addSMARTData(&listNewDrives); //add S.M.A.R.T. Data to the drives addSMARTData(&listNewDrives); // add S.M.A.R.T. Data to the drives
mxDrives.unlock(); filterInvalidDrives(&listNewDrives); // filter out drives that report zero capacity
write(fdNewDrivesInformPipe[1], "A",1); mxDrives.unlock();
sleep(5); //sleep 5 sec write(fdNewDrivesInformPipe[1], "A", 1);
} sleep(5); // sleep 5 sec
}
} }
void reHDD::ThreadCheckFrozenDrives() void reHDD::ThreadCheckFrozenDrives()
{ {
while(true) while (true)
{
mxDrives.lock();
for (auto it = begin(listDrives); it != end(listDrives); ++it)
{ {
mxDrives.lock(); if (it->state == Drive::SHRED_ACTIVE)
for(auto it = begin(listDrives); it != end(listDrives); ++it) {
{ it->checkFrozenDrive();
if(it->state == Drive::SHRED_ACTIVE) }
{
it->checkFrozenDrive();
}
}
mxDrives.unlock();
sleep(13); //sleep 13 sec
} }
mxDrives.unlock();
sleep(13); // sleep 13 sec
}
} }
void reHDD::ThreadUserInput() void reHDD::ThreadUserInput()
{ {
while(true) while (true)
{
// cout << TUI::readUserInput() << endl;
switch (TUI::readUserInput())
{ {
// cout << TUI::readUserInput() << endl; case TUI::UserInput::DownKey:
switch (TUI::readUserInput()) // 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)
{ {
case TUI::UserInput::DownKey: getSelectedDrive()->state = Drive::DELETE_SELECTED;
//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;
} }
}
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) void reHDD::ThreadShred(Drive *const pDrive)
{ {
if (pDrive != nullptr) if (pDrive != nullptr)
{ {
pDrive->setActionStartTimestamp(); //save timestamp at start of shredding pDrive->setActionStartTimestamp(); // save timestamp at start of shredding
Shred* pShredTask = new Shred(); //create new shred task Shred *pShredTask = new Shred(); // create new shred task
pShredTask->shredDrive(pDrive, &fdShredInformPipe[1]); //start new shred task pShredTask->shredDrive(pDrive, &fdShredInformPipe[1]); // start new shred task
delete pShredTask; //delete shred task delete pShredTask; // delete shred task
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u8SelectedEntry);
} }
} }
void reHDD::ThreadDelete() void reHDD::ThreadDelete()
{ {
if (getSelectedDrive() != nullptr) if (getSelectedDrive() != nullptr)
{ {
getSelectedDrive()->setActionStartTimestamp(); //save timestamp at start of deleting getSelectedDrive()->setActionStartTimestamp(); // save timestamp at start of deleting
Delete::deleteDrive(getSelectedDrive()); //blocking, no thread Delete::deleteDrive(getSelectedDrive()); // blocking, no thread
getSelectedDrive()->state = Drive::TaskState::NONE; //delete finished getSelectedDrive()->state = Drive::TaskState::NONE; // delete finished
getSelectedDrive()->bWasDeleted = true; getSelectedDrive()->bWasDeleted = true;
Logger::logThis()->info("Finished delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); Logger::logThis()->info("Finished delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u8SelectedEntry);
} }
} }
void reHDD::filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives) void reHDD::filterNewDrives(list<Drive> *plistOldDrives, list<Drive> *plistNewDrives)
{ {
list <Drive>::iterator itOld; //Iterator for current (old) drive list list<Drive>::iterator itOld; // Iterator for current (old) drive list
list <Drive>::iterator itNew; //Iterator for new drive list that was created from to scan thread list<Drive>::iterator itNew; // Iterator for new drive list that was created from to scan thread
//remove offline old drives from previously run // remove offline old drives from previously run
for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end();) for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end();)
{
if (itOld->bIsOffline == true)
{ {
if(itOld->bIsOffline == true) Logger::logThis()->warning("Offline drive found: " + itOld->getPath());
{ itOld = plistOldDrives->erase(itOld);
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;
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;
}
} }
else
//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 ++itOld;
for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end();) }
{ }
if((itOld->getSerial() == itNew->getSerial()) || (itOld->getPath() == itNew->getPath()))
{ // search offline drives and mark them
itOld->bIsOffline = false; //drive is still attached for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld)
//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()); 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 #ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Delete new drive, because already attached: " + itNew->getModelName()); Logger::logThis()->info("Delete new drive, because already attached: " + itNew->getModelName());
#endif #endif
itNew = plistNewDrives->erase(itNew); //This drive is already attached, remove from new list itNew = plistNewDrives->erase(itNew); // This drive is already attached, remove from new list
} }
else else
{ {
++itNew; ++itNew;
} }
}
} }
}
//mark offline old drives // mark offline old drives
for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld) for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld)
{
if (itOld->bIsOffline == true)
{ {
if(itOld->bIsOffline == true) // cout << "offline drive found: " << itOld->getPath() << endl;
{ Logger::logThis()->warning("Mark offline drive found: " + itOld->getPath());
//cout << "offline drive found: " << itOld->getPath() << endl; itOld->state = Drive::NONE; // clear state --> shred task will terminate
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 // add new drives to drive list
for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end(); ++itNew) for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end(); ++itNew)
{ {
plistOldDrives->push_back(*itNew); plistOldDrives->push_back(*itNew);
//Logger::logThis()->info("Add new drive: " + itNew->getModelName()); // Logger::logThis()->info("Add new drive: " + itNew->getModelName());
} }
plistNewDrives->clear(); plistNewDrives->clear();
} }
@ -299,40 +300,40 @@ void reHDD::filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNew
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
* \return void * \return void
*/ */
void reHDD::searchDrives(list <Drive>* plistDrives) void reHDD::searchDrives(list<Drive> *plistDrives)
{ {
//Logger::logThis()->info("--> search drives <--"); // Logger::logThis()->info("--> search drives <--");
char * cLine = NULL; char *cLine = NULL;
size_t len = 0; size_t len = 0;
FILE* outputfileHwinfo = popen("lsblk -e 11 -d -o NAME", "r"); FILE *outputfileHwinfo = popen("lsblk -e 11 -d -o NAME", "r");
if (outputfileHwinfo == NULL) if (outputfileHwinfo == NULL)
{ {
Logger::logThis()->error("Unable to scan attached drives"); Logger::logThis()->error("Unable to scan attached drives");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
while ((getline(&cLine, &len, outputfileHwinfo)) != -1) while ((getline(&cLine, &len, outputfileHwinfo)) != -1)
{
if (string(cLine).length() == 4)
{ {
if (string(cLine).length() == 4) Drive *tmpDrive = new Drive("/dev/" + string(cLine).substr(0, 3));
{ tmpDrive->state = Drive::NONE;
Drive* tmpDrive = new Drive("/dev/" + string(cLine).substr(0, 3)); tmpDrive->bIsOffline = false;
tmpDrive->state = Drive::NONE; plistDrives->push_back(*tmpDrive);
tmpDrive->bIsOffline = false; // Logger::logThis()->info("SATA drive found: " + tmpDrive->getPath());
plistDrives->push_back(*tmpDrive);
//Logger::logThis()->info("SATA drive found: " + tmpDrive->getPath());
}
if (string(cLine).length() == 8)
{
Drive* tmpDrive = new Drive("/dev/" + string(cLine).substr(0, 7));
tmpDrive->state = Drive::NONE;
tmpDrive->bIsOffline = false;
plistDrives->push_back(*tmpDrive);
//Logger::logThis()->info("NVME drive found: " + tmpDrive->getPath());
}
} }
if (string(cLine).length() == 8)
{
Drive *tmpDrive = new Drive("/dev/" + string(cLine).substr(0, 7));
tmpDrive->state = Drive::NONE;
tmpDrive->bIsOffline = false;
plistDrives->push_back(*tmpDrive);
// Logger::logThis()->info("NVME drive found: " + tmpDrive->getPath());
}
}
pclose(outputfileHwinfo); pclose(outputfileHwinfo);
} }
@ -341,59 +342,80 @@ void reHDD::searchDrives(list <Drive>* plistDrives)
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
* \return void * \return void
*/ */
void reHDD::filterIgnoredDrives(list <Drive>* plistDrives) void reHDD::filterIgnoredDrives(list<Drive> *plistDrives)
{ {
list<tuple<string>> vtlIgnoredDevices; //store drives from ignore file list<tuple<string>> vtlIgnoredDevices; // store drives from ignore file
ifstream input( "ignoreDrives.conf" ); //read ignore file ifstream input("ignoreDrives.conf"); // read ignore file
for(string sLine; getline( input, sLine );) 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 ignore file
for (auto row : vtlIgnoredDevices)
{
list<Drive>::iterator it;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{ {
//Logger::logThis()->info("read uuid: " + sLine); string sUUID;
vtlIgnoredDevices.emplace_back(sLine); //add found path and uuid from ignore file to vector char *cLine = NULL;
} size_t len = 0;
//loop through found entries in ignore file string sCMD = "blkid ";
for(auto row : vtlIgnoredDevices) sCMD.append(it->getPath());
{ // cout << "cmd: " << sCMD << endl;
list <Drive>::iterator it; FILE *outputfileBlkid = popen(sCMD.c_str(), "r"); // get UUID from drive
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) if (outputfileBlkid == NULL)
{
exit(EXIT_FAILURE);
}
while ((getline(&cLine, &len, outputfileBlkid)) != -1) // parse UUID from blkid
{
if (string(cLine).find("PTUUID") != string::npos)
{ {
string sUUID; string sBlkidOut = string(cLine);
char * cLine = NULL; sBlkidOut.erase(0, 18);
size_t len = 0; sBlkidOut.erase(8, sBlkidOut.length());
string sCMD = "blkid "; sUUID = sBlkidOut;
sCMD.append(it->getPath()); // cout << "blkid uuid:" << sUUID << endl;
//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--;
}
} }
}
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 filter out drives that are not indented for processing
* \param pointer of list <Drive>* plistDrives
* \return void
*/
void reHDD::filterInvalidDrives(list<Drive> *plistDrives)
{
list<Drive>::iterator it;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{
if (it->getCapacity() == 0U)
{
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Drive reports zero capacity --> ignore this drive: " + it->getPath());
#endif
it = plistDrives->erase(it);
it--;
}
}
} }
/** /**
@ -401,24 +423,24 @@ void reHDD::filterIgnoredDrives(list <Drive>* plistDrives)
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
* \return void * \return void
*/ */
void reHDD::startShredAllDrives(list <Drive>* plistDrives) void reHDD::startShredAllDrives(list<Drive> *plistDrives)
{ {
list <Drive>::iterator it; list<Drive>::iterator it;
mxDrives.lock(); mxDrives.lock();
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{
if (it->state == Drive::NONE)
{ {
if(it->state == Drive::NONE) Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it);
{
Drive* pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator > (it);
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
ostringstream address; ostringstream address;
address << (void const *)&(*pTmpDrive); address << (void const *)&(*pTmpDrive);
Logger::logThis()->info("Started shred (all) for: " + pTmpDrive->getModelName() + "-" + pTmpDrive->getSerial() + " @" + address.str()); Logger::logThis()->info("Started shred (all) for: " + pTmpDrive->getModelName() + "-" + pTmpDrive->getSerial() + " @" + address.str());
#endif #endif
pTmpDrive->state = Drive::TaskState::SHRED_ACTIVE; pTmpDrive->state = Drive::TaskState::SHRED_ACTIVE;
thread(ThreadShred, pTmpDrive).detach(); thread(ThreadShred, pTmpDrive).detach();
}
} }
}
mxDrives.unlock(); mxDrives.unlock();
} }
@ -427,33 +449,33 @@ void reHDD::startShredAllDrives(list <Drive>* plistDrives)
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
* \return void * \return void
*/ */
void reHDD::printDrives(list <Drive>* plistDrives) void reHDD::printDrives(list<Drive> *plistDrives)
{ {
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("------------DRIVES START------------"); Logger::logThis()->info("------------DRIVES START------------");
//cout << "------------DRIVES---------------" << endl; // cout << "------------DRIVES---------------" << endl;
list <Drive>::iterator it; list<Drive>::iterator it;
uint8_t u8Index = 0; uint8_t u8Index = 0;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{ {
/* /*
cout << " Drive: " << distance(pvecDrives->begin(), it) << endl; cout << " Drive: " << distance(pvecDrives->begin(), it) << endl;
cout << "Path: " << it->getPath() << endl; cout << "Path: " << it->getPath() << endl;
cout << "ModelFamily: " << it->getModelFamily() << endl; cout << "ModelFamily: " << it->getModelFamily() << endl;
cout << "ModelName: " << it->getModelName() << endl; cout << "ModelName: " << it->getModelName() << endl;
cout << "Capacity: " << it->getCapacity() << endl; cout << "Capacity: " << it->getCapacity() << endl;
cout << "Serial: " << it->getSerial() << endl; cout << "Serial: " << it->getSerial() << endl;
cout << "PowerOnHours: " << it->getPowerOnHours() << endl; cout << "PowerOnHours: " << it->getPowerOnHours() << endl;
cout << "PowerCycle: " << it->getPowerCycles() << endl; cout << "PowerCycle: " << it->getPowerCycles() << endl;
cout << "ErrorCount: " << it->getErrorCount() << endl; cout << "ErrorCount: " << it->getErrorCount() << endl;
cout << endl;*/ cout << endl;*/
ostringstream address; ostringstream address;
address << (void const *)&(*it); address << (void const *)&(*it);
Logger::logThis()->info(to_string(u8Index++) + ": " + it->getPath() + " - " + it->getModelFamily() + " - " + it->getSerial() + " @" + address.str()); Logger::logThis()->info(to_string(u8Index++) + ": " + it->getPath() + " - " + it->getModelFamily() + " - " + it->getSerial() + " @" + address.str());
} }
Logger::logThis()->info("------------DRIVES END--------------"); Logger::logThis()->info("------------DRIVES END--------------");
//cout << "---------------------------------" << endl; // cout << "---------------------------------" << endl;
#endif #endif
} }
@ -462,26 +484,26 @@ void reHDD::printDrives(list <Drive>* plistDrives)
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
* \return void * \return void
*/ */
void reHDD::updateShredMetrics(list <Drive>* plistDrives) void reHDD::updateShredMetrics(list<Drive> *plistDrives)
{ {
list <Drive>::iterator it; list<Drive>::iterator it;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{
if (it->state == Drive::SHRED_ACTIVE)
{ {
if(it->state == Drive::SHRED_ACTIVE) Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it);
{ // set metrics for calculating shred speed
Drive* pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator > (it); std::chrono::time_point<std::chrono::system_clock> chronoCurrentTimestamp = std::chrono::system_clock::now();
//set metrics for calculating shred speed time_t u32ShredTimeDelta = (chronoCurrentTimestamp - pTmpDrive->sShredSpeed.chronoShredTimestamp).count();
std::chrono::time_point<std::chrono::system_clock> chronoCurrentTimestamp = std::chrono::system_clock::now(); if (u32ShredTimeDelta > METRIC_THRESHOLD)
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.u32ShredTimeDelta = u32ShredTimeDelta; pTmpDrive->sShredSpeed.ulWrittenBytes = pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten;
pTmpDrive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now(); pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten = 0U;
pTmpDrive->sShredSpeed.ulWrittenBytes = pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten; }
pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten = 0U;
}
}
} }
}
} }
/** /**
@ -489,100 +511,97 @@ void reHDD::updateShredMetrics(list <Drive>* plistDrives)
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
* \return void * \return void
*/ */
void reHDD::addSMARTData(list <Drive>* plistDrives) void reHDD::addSMARTData(list<Drive> *plistDrives)
{ {
list <Drive>::iterator it; list<Drive>::iterator it;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{ {
Drive* pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator > (it); Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it);
SMART::readSMARTData(pTmpDrive); SMART::readSMARTData(pTmpDrive);
} }
} }
void reHDD::handleArrowKey(TUI::UserInput userInput) void reHDD::handleArrowKey(TUI::UserInput userInput)
{ {
int8_t u8EntrySize = (int8_t) listDrives.size(); int8_t u8EntrySize = (int8_t)listDrives.size();
switch (userInput) switch (userInput)
{
case TUI::UserInput::DownKey:
u8SelectedEntry++;
if (u8SelectedEntry >= u8EntrySize)
{ {
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; u8SelectedEntry = 0;
break;
} }
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)); // Logger::logThis()->info("ArrowKey - selected drive: " + to_string(u8SelectedEntry));
} }
void reHDD::handleEnter() void reHDD::handleEnter()
{ {
if (getSelectedDrive() != nullptr) if (getSelectedDrive() != nullptr)
{
if (getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED)
{ {
if(getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED) Logger::logThis()->info("Started shred/check for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
{ getSelectedDrive()->state = Drive::TaskState::SHRED_ACTIVE;
Logger::logThis()->info("Started shred/check for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); // task for drive is running --> don´t show more task options
getSelectedDrive()->state = Drive::TaskState::SHRED_ACTIVE; Drive *pTmpDrive = getSelectedDrive();
//task for drive is running --> don´t show more task options thread(ThreadShred, pTmpDrive).detach();
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();
}
} }
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() void reHDD::handleESC()
{ {
if (getSelectedDrive() != nullptr) if (getSelectedDrive() != nullptr)
{
if (getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED)
{ {
if(getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED) getSelectedDrive()->state = Drive::TaskState::NONE;
{ // task for drive is selected --> remove selection
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
}
} }
if (getSelectedDrive()->state == Drive::TaskState::DELETE_SELECTED)
{
getSelectedDrive()->state = Drive::TaskState::NONE;
// task for drive is selected --> remove selection
}
}
} }
void reHDD::handleAbort() void reHDD::handleAbort()
{ {
if (getSelectedDrive() != nullptr) if (getSelectedDrive() != nullptr)
{
if (getSelectedDrive()->state == Drive::SHRED_ACTIVE || getSelectedDrive()->state == Drive::DELETE_ACTIVE)
{ {
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());
getSelectedDrive()->state = Drive::NONE; // task for drive is running --> remove selection
Logger::logThis()->info("Abort-Shred-Signal for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
//task for drive is running --> remove selection
}
} }
}
} }