2018-07-12 16:29:32 +02:00
|
|
|
#include "InternalErrorReporter.h"
|
|
|
|
|
2020-12-03 13:21:44 +01:00
|
|
|
#include "../ipc/QueueFactory.h"
|
2020-08-13 20:53:35 +02:00
|
|
|
#include "../ipc/MutexFactory.h"
|
|
|
|
#include "../serviceinterface/ServiceInterfaceStream.h"
|
2018-07-12 16:29:32 +02:00
|
|
|
|
|
|
|
InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
|
2020-12-08 15:49:46 +01:00
|
|
|
uint32_t messageQueueDepth): SystemObject(setObjectId),
|
2020-12-03 13:21:44 +01:00
|
|
|
commandQueue(QueueFactory::instance()->
|
|
|
|
createMessageQueue(messageQueueDepth)),
|
|
|
|
poolManager(this, commandQueue),
|
|
|
|
internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
|
|
|
|
internalErrorDataset(this) {
|
2018-07-12 16:29:32 +02:00
|
|
|
mutex = MutexFactory::instance()->createMutex();
|
|
|
|
}
|
|
|
|
|
|
|
|
InternalErrorReporter::~InternalErrorReporter() {
|
|
|
|
MutexFactory::instance()->deleteMutex(mutex);
|
|
|
|
}
|
|
|
|
|
2020-12-03 13:21:44 +01:00
|
|
|
void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
|
|
|
|
this->diagnosticPrintout = enable;
|
|
|
|
}
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2020-12-03 13:21:44 +01:00
|
|
|
ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
|
|
|
|
internalErrorDataset.read(INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
|
|
|
|
uint32_t newQueueHits = getAndResetQueueHits();
|
|
|
|
uint32_t newTmHits = getAndResetTmHits();
|
|
|
|
uint32_t newStoreHits = getAndResetStoreHits();
|
|
|
|
|
2020-12-03 13:21:44 +01:00
|
|
|
#ifdef DEBUG
|
|
|
|
if(diagnosticPrintout) {
|
|
|
|
if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
|
|
|
|
sif::debug << "InternalErrorReporter::performOperation: Errors "
|
|
|
|
<< "occured!" << std::endl;
|
|
|
|
sif::debug << "Queue errors: " << newQueueHits << std::endl;
|
|
|
|
sif::debug << "TM errors: " << newTmHits << std::endl;
|
|
|
|
sif::debug << "Store errors: " << newStoreHits << std::endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
internalErrorDataset.queueHits.value += newQueueHits;
|
|
|
|
internalErrorDataset.storeHits.value += newStoreHits;
|
|
|
|
internalErrorDataset.tmHits.value += newTmHits;
|
|
|
|
|
|
|
|
internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
|
|
|
|
|
|
|
|
poolManager.performHkOperation();
|
|
|
|
|
|
|
|
CommandMessage message;
|
|
|
|
ReturnValue_t result = commandQueue->receiveMessage(&message);
|
|
|
|
if(result != MessageQueueIF::EMPTY) {
|
|
|
|
poolManager.handleHousekeepingMessage(&message);
|
|
|
|
}
|
2018-07-12 16:29:32 +02:00
|
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InternalErrorReporter::queueMessageNotSent() {
|
|
|
|
incrementQueueHits();
|
|
|
|
}
|
|
|
|
|
|
|
|
void InternalErrorReporter::lostTm() {
|
|
|
|
incrementTmHits();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t InternalErrorReporter::getAndResetQueueHits() {
|
|
|
|
uint32_t value;
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
value = queueHits;
|
|
|
|
queueHits = 0;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t InternalErrorReporter::getQueueHits() {
|
|
|
|
uint32_t value;
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
value = queueHits;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InternalErrorReporter::incrementQueueHits() {
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
queueHits++;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t InternalErrorReporter::getAndResetTmHits() {
|
|
|
|
uint32_t value;
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
value = tmHits;
|
|
|
|
tmHits = 0;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t InternalErrorReporter::getTmHits() {
|
|
|
|
uint32_t value;
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
value = tmHits;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InternalErrorReporter::incrementTmHits() {
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
tmHits++;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
}
|
|
|
|
|
|
|
|
void InternalErrorReporter::storeFull() {
|
|
|
|
incrementStoreHits();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t InternalErrorReporter::getAndResetStoreHits() {
|
|
|
|
uint32_t value;
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
value = storeHits;
|
|
|
|
storeHits = 0;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t InternalErrorReporter::getStoreHits() {
|
|
|
|
uint32_t value;
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
value = storeHits;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InternalErrorReporter::incrementStoreHits() {
|
2020-12-03 13:21:44 +01:00
|
|
|
mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
|
2018-07-12 16:29:32 +02:00
|
|
|
storeHits++;
|
|
|
|
mutex->unlockMutex();
|
|
|
|
}
|
2020-12-03 13:21:44 +01:00
|
|
|
|
|
|
|
object_id_t InternalErrorReporter::getObjectId() const {
|
|
|
|
return SystemObject::getObjectId();
|
|
|
|
}
|
|
|
|
|
|
|
|
MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
|
|
|
|
return this->commandQueue->getId();
|
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
|
|
|
|
LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
|
|
|
|
localDataPoolMap.emplace(errorPoolIds::TM_HITS,
|
|
|
|
new PoolEntry<uint32_t>());
|
|
|
|
localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
|
|
|
|
new PoolEntry<uint32_t>());
|
|
|
|
localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
|
|
|
|
new PoolEntry<uint32_t>());
|
|
|
|
poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
|
|
|
|
getPeriodicOperationFrequency(), true);
|
|
|
|
internalErrorDataset.setValidity(true, true);
|
|
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
|
|
|
|
return &poolManager;
|
|
|
|
}
|
|
|
|
|
|
|
|
dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
|
|
|
|
return this->executingTask->getPeriodMs();
|
|
|
|
}
|
|
|
|
|
|
|
|
LocalPoolDataSetBase* InternalErrorReporter::getDataSetHandle(sid_t sid) {
|
|
|
|
return &internalErrorDataset;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InternalErrorReporter::setTaskIF(PeriodicTaskIF *task) {
|
|
|
|
this->executingTask = task;
|
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t InternalErrorReporter::initialize() {
|
|
|
|
ReturnValue_t result = poolManager.initialize(commandQueue);
|
|
|
|
if(result != HasReturnvaluesIF::RETURN_OK) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return SystemObject::initialize();
|
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
|
|
|
|
return poolManager.initializeAfterTaskCreation();
|
|
|
|
}
|
|
|
|
|