From 1158c9d675278db0dcecf80d711073b8ad625932 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 May 2020 17:01:48 +0200
Subject: [PATCH 1/6] storagemanager refactoring
---
storagemanager/LocalPool.h | 368 +++++-------------------------
storagemanager/LocalPool.tpp | 260 +++++++++++++++++++++
storagemanager/PoolManager.h | 84 ++-----
storagemanager/PoolManager.tpp | 50 ++++
storagemanager/StorageManagerIF.h | 22 +-
5 files changed, 407 insertions(+), 377 deletions(-)
create mode 100644 storagemanager/LocalPool.tpp
create mode 100644 storagemanager/PoolManager.tpp
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 08cb017f..3af37371 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -39,7 +39,64 @@ public:
* @brief This definition generally sets the number of different sized pools.
* @details This must be less than the maximum number of pools (currently 0xff).
*/
-// static const uint32_t NUMBER_OF_POOLS;
+ // static const uint32_t NUMBER_OF_POOLS;
+ /**
+ * @brief This is the default constructor for a pool manager instance.
+ * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor
+ * allocates memory (with \c new) for store and size_list. These
+ * regions are all set to zero on start up.
+ * @param setObjectId The object identifier to be set. This allows for
+ * multiple instances of LocalPool in the system.
+ * @param element_sizes An array of size NUMBER_OF_POOLS in which the size
+ * of a single element in each pool is determined.
+ * <b>The sizes must be provided in ascending order.
+ * </b>
+ * @param n_elements An array of size NUMBER_OF_POOLS in which the
+ * number of elements for each pool is determined.
+ * The position of these values correspond to those in
+ * element_sizes.
+ * @param registered Register the pool in object manager or not. Default is false (local pool).
+ * @param spillsToHigherPools
+ * A variable to determine whether higher n pools are used if the store is full.
+ */
+ LocalPool(object_id_t setObjectId,
+ const uint16_t element_sizes[NUMBER_OF_POOLS],
+ const uint16_t n_elements[NUMBER_OF_POOLS],
+ bool registered = false,
+ bool spillsToHigherPools = false);
+ /**
+ * @brief In the LocalPool's destructor all allocated memory is freed.
+ */
+ virtual ~LocalPool(void);
+
+ /**
+ * Documentation: See StorageManagerIF.h
+ */
+ ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+ size_t size, bool ignoreFault = false) override;
+ ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
+ uint8_t** p_data, bool ignoreFault = false) override;
+ ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+ size_t * size) override;
+ ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+ size_t * size) override;
+ virtual ReturnValue_t deleteData(store_address_t) override;
+ virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
+ store_address_t* storeId = NULL) override;
+ void clearStore() override;
+ ReturnValue_t initialize() override;
+protected:
+ /**
+ * With this helper method, a free element of \c size is reserved.
+ * @param size The minimum packet size that shall be reserved.
+ * @param[out] address Storage ID of the reserved data.
+ * @return - #RETURN_OK on success,
+ * - the return codes of #getPoolIndex or #findEmpty otherwise.
+ */
+ virtual ReturnValue_t reserveSpace(const uint32_t size,
+ store_address_t* address, bool ignoreFault);
+
+ InternalErrorReporterIF *internalErrorReporter;
private:
/**
* Indicates that this element is free.
@@ -78,7 +135,7 @@ private:
* @param data The data to be stored.
* @param size The size of the data to be stored.
*/
- void write(store_address_t packet_id, const uint8_t* data, uint32_t size);
+ void write(store_address_t packet_id, const uint8_t* data, size_t size);
/**
* @brief A helper method to read the element size of a certain pool.
* @param pool_index The pool in which to look.
@@ -101,7 +158,8 @@ private:
* @return - #RETURN_OK on success,
* - #DATA_TOO_LARGE otherwise.
*/
- ReturnValue_t getPoolIndex(uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex = 0);
+ ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+ uint16_t startAtIndex = 0);
/**
* @brief This helper method calculates the true array position in store
* of a given packet id.
@@ -121,310 +179,8 @@ private:
* - #DATA_STORAGE_FULL if the store is full
*/
ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
-protected:
- /**
- * With this helper method, a free element of \c size is reserved.
- * @param size The minimum packet size that shall be reserved.
- * @param[out] address Storage ID of the reserved data.
- * @return - #RETURN_OK on success,
- * - the return codes of #getPoolIndex or #findEmpty otherwise.
- */
- virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
-
- InternalErrorReporterIF *internalErrorReporter;
-public:
- /**
- * @brief This is the default constructor for a pool manager instance.
- * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor
- * allocates memory (with \c new) for store and size_list. These
- * regions are all set to zero on start up.
- * @param setObjectId The object identifier to be set. This allows for
- * multiple instances of LocalPool in the system.
- * @param element_sizes An array of size NUMBER_OF_POOLS in which the size
- * of a single element in each pool is determined.
- * <b>The sizes must be provided in ascending order.
- * </b>
- * @param n_elements An array of size NUMBER_OF_POOLS in which the
- * number of elements for each pool is determined.
- * The position of these values correspond to those in
- * element_sizes.
- * @param registered Register the pool in object manager or not. Default is false (local pool).
- */
- LocalPool(object_id_t setObjectId,
- const uint16_t element_sizes[NUMBER_OF_POOLS],
- const uint16_t n_elements[NUMBER_OF_POOLS],
- bool registered = false,
- bool spillsToHigherPools = false);
- /**
- * @brief In the LocalPool's destructor all allocated memory is freed.
- */
- virtual ~LocalPool(void);
- ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
- uint32_t size, bool ignoreFault = false);
-
- /**
- * With this helper method, a free element of \c size is reserved.
- *
- * @param size The minimum packet size that shall be reserved.
- * @return Returns the storage identifier within the storage or
- * StorageManagerIF::INVALID_ADDRESS (in raw).
- */
- ReturnValue_t getFreeElement(store_address_t* storageId,
- const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
- ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
- uint32_t* size);
- ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
- uint32_t* size);
- virtual ReturnValue_t deleteData(store_address_t);
- virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
- store_address_t* storeId = NULL);
- void clearStore();
- ReturnValue_t initialize();
};
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
- uint16_t* element) {
- ReturnValue_t status = DATA_STORAGE_FULL;
- for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
- foundElement++) {
- if (size_list[pool_index][foundElement] == STORAGE_FREE) {
- *element = foundElement;
- status = RETURN_OK;
- break;
- }
- }
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
- const uint8_t* data, uint32_t size) {
- uint8_t* ptr;
- uint32_t packet_position = getRawPosition(packet_id);
-
- //check size? -> Not necessary, because size is checked before calling this function.
- ptr = &store[packet_id.pool_index][packet_position];
- memcpy(ptr, data, size);
- size_list[packet_id.pool_index][packet_id.packet_index] = size;
-}
-
-//Returns page size of 0 in case store_index is illegal
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
- if (pool_index < NUMBER_OF_POOLS) {
- return element_sizes[pool_index];
- } else {
- return 0;
- }
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
- uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
- for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-// debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " << n << ", Element Size: " << element_sizes[n] << std::endl;
- if (element_sizes[n] >= packet_size) {
- *poolIndex = n;
- return RETURN_OK;
- }
- }
- return DATA_TOO_LARGE;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
- store_address_t packet_id) {
- return packet_id.packet_index * element_sizes[packet_id.pool_index];
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
- const uint32_t size, store_address_t* address, bool ignoreFault) {
- ReturnValue_t status = getPoolIndex(size, &address->pool_index);
- if (status != RETURN_OK) {
- error << "LocalPool( " << std::hex << getObjectId() << std::dec
- << " )::reserveSpace: Packet too large." << std::endl;
- return status;
- }
- status = findEmpty(address->pool_index, &address->packet_index);
- while (status != RETURN_OK && spillsToHigherPools) {
- status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
- if (status != RETURN_OK) {
- //We don't find any fitting pool anymore.
- break;
- }
- status = findEmpty(address->pool_index, &address->packet_index);
- }
- if (status == RETURN_OK) {
-// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
-// debug << "Reserve: Pool: " << std::dec << address->pool_index << " Index: " << address->packet_index << std::endl;
-// }
-
- size_list[address->pool_index][address->packet_index] = size;
- } else {
- if (!ignoreFault) {
- internalErrorReporter->storeFull();
- }
-// error << "LocalPool( " << std::hex << getObjectId() << std::dec
-// << " )::reserveSpace: Packet store is full." << std::endl;
- }
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
- const uint16_t element_sizes[NUMBER_OF_POOLS],
- const uint16_t n_elements[NUMBER_OF_POOLS], bool registered, bool spillsToHigherPools) :
- SystemObject(setObjectId, registered), spillsToHigherPools(spillsToHigherPools), internalErrorReporter(NULL) {
- for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
- this->element_sizes[n] = element_sizes[n];
- this->n_elements[n] = n_elements[n];
- store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
- size_list[n] = new uint32_t[n_elements[n]];
- memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
- memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list))); //TODO checkme
- }
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
- for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
- delete[] store[n];
- delete[] size_list[n];
- }
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
- store_address_t* storageId, const uint8_t* data, uint32_t size, bool ignoreFault) {
- ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
- if (status == RETURN_OK) {
- write(*storageId, data, size);
- }
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
- store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault) {
- ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
- if (status == RETURN_OK) {
- *p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
- } else {
- *p_data = NULL;
- }
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
- store_address_t packet_id, const uint8_t** packet_ptr, uint32_t* size) {
- uint8_t* tempData = NULL;
- ReturnValue_t status = modifyData(packet_id, &tempData, size);
- *packet_ptr = tempData;
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(store_address_t packet_id,
- uint8_t** packet_ptr, uint32_t* size) {
- ReturnValue_t status = RETURN_FAILED;
- if (packet_id.pool_index >= NUMBER_OF_POOLS) {
- return ILLEGAL_STORAGE_ID;
- }
- if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
- return ILLEGAL_STORAGE_ID;
- }
- if (size_list[packet_id.pool_index][packet_id.packet_index]
- != STORAGE_FREE) {
- uint32_t packet_position = getRawPosition(packet_id);
- *packet_ptr = &store[packet_id.pool_index][packet_position];
- *size = size_list[packet_id.pool_index][packet_id.packet_index];
- status = RETURN_OK;
- } else {
- status = DATA_DOES_NOT_EXIST;
- }
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
- store_address_t packet_id) {
-
-// if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
-// debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: " << packet_id.packet_index << std::endl;
-// }
- ReturnValue_t status = RETURN_OK;
- uint32_t page_size = getPageSize(packet_id.pool_index);
- if ((page_size != 0)
- && (packet_id.packet_index < n_elements[packet_id.pool_index])) {
- uint16_t packet_position = getRawPosition(packet_id);
- uint8_t* ptr = &store[packet_id.pool_index][packet_position];
- memset(ptr, 0, page_size);
- //Set free list
- size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
- } else {
- //pool_index or packet_index is too large
- error << "LocalPool:deleteData failed." << std::endl;
- status = ILLEGAL_STORAGE_ID;
- }
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
- for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
- memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));//TODO checkme
- }
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
- uint32_t size, store_address_t* storeId) {
- store_address_t localId;
- ReturnValue_t result = ILLEGAL_ADDRESS;
- for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
- //Not sure if new allocates all stores in order. so better be careful.
- if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
- localId.pool_index = n;
- uint32_t deltaAddress = ptr - store[n];
- //Getting any data from the right "block" is ok. This is necessary, as IF's sometimes don't point to the first element of an object.
- localId.packet_index = deltaAddress / element_sizes[n];
- result = deleteData(localId);
-// if (deltaAddress % element_sizes[n] != 0) {
-// error << "Pool::deleteData: address not aligned!" << std::endl;
-// }
- break;
- }
- }
- if (storeId != NULL) {
- *storeId = localId;
- }
- return result;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
- ReturnValue_t result = SystemObject::initialize();
- if (result != RETURN_OK) {
- return result;
- }
- internalErrorReporter = objectManager->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
- if (internalErrorReporter == NULL){
- return RETURN_FAILED;
- }
-
- //Check if any pool size is large than the maximum allowed.
- for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
- if (element_sizes[count] >= STORAGE_FREE) {
- error
- << "LocalPool::initialize: Pool is too large! Max. allowed size is: "
- << (STORAGE_FREE - 1) << std::endl;
- return RETURN_FAILED;
- }
- }
- return RETURN_OK;
-}
+#include <framework/storagemanager/LocalPool.tpp>
#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
new file mode 100644
index 00000000..649ec88a
--- /dev/null
+++ b/storagemanager/LocalPool.tpp
@@ -0,0 +1,260 @@
+#ifndef LOCALPOOL_TPP
+#define LOCALPOOL_TPP
+
+template<uint8_t NUMBER_OF_POOLS>
+inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
+ const uint16_t element_sizes[NUMBER_OF_POOLS],
+ const uint16_t n_elements[NUMBER_OF_POOLS], bool registered,
+ bool spillsToHigherPools) :
+ SystemObject(setObjectId, registered), internalErrorReporter(nullptr),
+ spillsToHigherPools(spillsToHigherPools)
+{
+ for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+ this->element_sizes[n] = element_sizes[n];
+ this->n_elements[n] = n_elements[n];
+ store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
+ size_list[n] = new uint32_t[n_elements[n]];
+ memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
+ //TODO checkme
+ memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
+ }
+}
+
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
+ uint16_t* element) {
+ ReturnValue_t status = DATA_STORAGE_FULL;
+ for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
+ foundElement++) {
+ if (size_list[pool_index][foundElement] == STORAGE_FREE) {
+ *element = foundElement;
+ status = RETURN_OK;
+ break;
+ }
+ }
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
+ const uint8_t* data, size_t size) {
+ uint8_t* ptr;
+ uint32_t packet_position = getRawPosition(packet_id);
+
+ //check size? -> Not necessary, because size is checked before calling this function.
+ ptr = &store[packet_id.pool_index][packet_position];
+ memcpy(ptr, data, size);
+ size_list[packet_id.pool_index][packet_id.packet_index] = size;
+}
+
+//Returns page size of 0 in case store_index is illegal
+template<uint8_t NUMBER_OF_POOLS>
+inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
+ if (pool_index < NUMBER_OF_POOLS) {
+ return element_sizes[pool_index];
+ } else {
+ return 0;
+ }
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
+ size_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
+ for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
+ //debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " <<
+ // n << ", Element Size: " << element_sizes[n] << std::endl;
+ if (element_sizes[n] >= packet_size) {
+ *poolIndex = n;
+ return RETURN_OK;
+ }
+ }
+ return DATA_TOO_LARGE;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
+ store_address_t packet_id) {
+ return packet_id.packet_index * element_sizes[packet_id.pool_index];
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
+ const uint32_t size, store_address_t* address, bool ignoreFault) {
+ ReturnValue_t status = getPoolIndex(size, &address->pool_index);
+ if (status != RETURN_OK) {
+ error << "LocalPool( " << std::hex << getObjectId() << std::dec
+ << " )::reserveSpace: Packet too large." << std::endl;
+ return status;
+ }
+ status = findEmpty(address->pool_index, &address->packet_index);
+ while (status != RETURN_OK && spillsToHigherPools) {
+ status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
+ if (status != RETURN_OK) {
+ //We don't find any fitting pool anymore.
+ break;
+ }
+ status = findEmpty(address->pool_index, &address->packet_index);
+ }
+ if (status == RETURN_OK) {
+ // if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
+ // debug << "Reserve: Pool: " << std::dec << address->pool_index <<
+ // " Index: " << address->packet_index << std::endl;
+ // }
+
+ size_list[address->pool_index][address->packet_index] = size;
+ } else {
+ if (!ignoreFault and internalErrorReporter != nullptr) {
+ internalErrorReporter->storeFull();
+ }
+ // error << "LocalPool( " << std::hex << getObjectId() << std::dec
+ // << " )::reserveSpace: Packet store is full." << std::endl;
+ }
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
+ for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+ delete[] store[n];
+ delete[] size_list[n];
+ }
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
+ const uint8_t* data, size_t size, bool ignoreFault) {
+ ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+ if (status == RETURN_OK) {
+ write(*storageId, data, size);
+ }
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
+ store_address_t* storageId, const size_t size,
+ uint8_t** p_data, bool ignoreFault) {
+ ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+ if (status == RETURN_OK) {
+ *p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
+ } else {
+ *p_data = NULL;
+ }
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
+ store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
+ uint8_t* tempData = NULL;
+ ReturnValue_t status = modifyData(packet_id, &tempData, size);
+ *packet_ptr = tempData;
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
+ store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
+ ReturnValue_t status = RETURN_FAILED;
+ if (packet_id.pool_index >= NUMBER_OF_POOLS) {
+ return ILLEGAL_STORAGE_ID;
+ }
+ if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
+ return ILLEGAL_STORAGE_ID;
+ }
+ if (size_list[packet_id.pool_index][packet_id.packet_index]
+ != STORAGE_FREE) {
+ uint32_t packet_position = getRawPosition(packet_id);
+ *packet_ptr = &store[packet_id.pool_index][packet_position];
+ *size = size_list[packet_id.pool_index][packet_id.packet_index];
+ status = RETURN_OK;
+ } else {
+ status = DATA_DOES_NOT_EXIST;
+ }
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
+ store_address_t packet_id) {
+ //if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
+ // debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: "
+ // << packet_id.packet_index << std::endl;
+ //}
+ ReturnValue_t status = RETURN_OK;
+ uint32_t page_size = getPageSize(packet_id.pool_index);
+ if ((page_size != 0)
+ && (packet_id.packet_index < n_elements[packet_id.pool_index])) {
+ uint16_t packet_position = getRawPosition(packet_id);
+ uint8_t* ptr = &store[packet_id.pool_index][packet_position];
+ memset(ptr, 0, page_size);
+ //Set free list
+ size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
+ } else {
+ //pool_index or packet_index is too large
+ error << "LocalPool:deleteData failed." << std::endl;
+ status = ILLEGAL_STORAGE_ID;
+ }
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
+ for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+ //TODO checkme
+ memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
+ }
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
+ size_t size, store_address_t* storeId) {
+ store_address_t localId;
+ ReturnValue_t result = ILLEGAL_ADDRESS;
+ for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+ //Not sure if new allocates all stores in order. so better be careful.
+ if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
+ localId.pool_index = n;
+ uint32_t deltaAddress = ptr - store[n];
+ // Getting any data from the right "block" is ok.
+ // This is necessary, as IF's sometimes don't point to the first
+ // element of an object.
+ localId.packet_index = deltaAddress / element_sizes[n];
+ result = deleteData(localId);
+ //if (deltaAddress % element_sizes[n] != 0) {
+ // error << "Pool::deleteData: address not aligned!" << std::endl;
+ //}
+ break;
+ }
+ }
+ if (storeId != NULL) {
+ *storeId = localId;
+ }
+ return result;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
+ ReturnValue_t result = SystemObject::initialize();
+ if (result != RETURN_OK) {
+ return result;
+ }
+ internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+ objects::INTERNAL_ERROR_REPORTER);
+ if (internalErrorReporter == NULL){
+ return RETURN_FAILED;
+ }
+
+ //Check if any pool size is large than the maximum allowed.
+ for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
+ if (element_sizes[count] >= STORAGE_FREE) {
+ error << "LocalPool::initialize: Pool is too large! "
+ "Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+ return RETURN_FAILED;
+ }
+ }
+ return RETURN_OK;
+}
+
+#endif
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 68a7addc..6e6c7613 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,12 +1,3 @@
-/**
- * @file PoolManager
- *
- * @date 02.02.2012
- * @author Bastian Baetz
- *
- * @brief This file contains the definition of the PoolManager class.
- */
-
#ifndef POOLMANAGER_H_
#define POOLMANAGER_H_
@@ -17,70 +8,39 @@
/**
* @brief The PoolManager class provides an intermediate data storage with
* a fixed pool size policy for inter-process communication.
- * \details Uses local pool, but is thread-safe.
+ * @details Uses local pool calls but is thread safe by protecting the call
+ * with a lock.
*/
template <uint8_t NUMBER_OF_POOLS = 5>
class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
-protected:
- /**
- * Overwritten for thread safety.
- * Locks during execution.
- */
- virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
-
- /**
- * \brief The mutex is created in the constructor and makes access mutual exclusive.
- * \details Locking and unlocking is done during searching for free slots and deleting existing slots.
- */
- MutexIF* mutex;
public:
- PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS], const uint16_t n_elements[NUMBER_OF_POOLS] );
+ PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS],
+ const uint16_t n_elements[NUMBER_OF_POOLS] );
/**
* @brief In the PoolManager's destructor all allocated memory is freed.
*/
- virtual ~PoolManager( void );
+ virtual ~PoolManager();
+
+ ReturnValue_t deleteData(store_address_t) override;
+ ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+ store_address_t* storeId = NULL) override;
+
+ ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+ size_t* size) override;
+protected:
+ ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+ bool ignoreFault) override;
+
/**
- * Overwritten for thread safety.
+ * @brief The mutex is created in the constructor and makes
+ * access mutual exclusive.
+ * @details Locking and unlocking is done during searching for free slots
+ * and deleting existing slots.
*/
- virtual ReturnValue_t deleteData(store_address_t);
- virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL);
+ MutexIF* mutex;
};
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault) {
- MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
- ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,address,ignoreFault);
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
- const uint16_t element_sizes[NUMBER_OF_POOLS],
- const uint16_t n_elements[NUMBER_OF_POOLS]) : LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
- mutex = MutexFactory::instance()->createMutex();
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
- MutexFactory::instance()->deleteMutex(mutex);
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
- store_address_t packet_id) {
- // debug << "PoolManager( " << translateObject(getObjectId()) << " )::deleteData from store " << packet_id.pool_index << ". id is " << packet_id.packet_index << std::endl;
- MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
- ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
- return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer, uint32_t size,
- store_address_t* storeId) {
- MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
- ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer, size, storeId);
- return status;
-}
+#include "PoolManager.tpp"
#endif /* POOLMANAGER_H_ */
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
new file mode 100644
index 00000000..ed340b91
--- /dev/null
+++ b/storagemanager/PoolManager.tpp
@@ -0,0 +1,50 @@
+template<uint8_t NUMBER_OF_POOLS>
+inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
+ const uint16_t element_sizes[NUMBER_OF_POOLS],
+ const uint16_t n_elements[NUMBER_OF_POOLS]) :
+ LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
+ mutex = MutexFactory::instance()->createMutex();
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
+ MutexFactory::instance()->deleteMutex(mutex);
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
+ const uint32_t size, store_address_t* address, bool ignoreFault) {
+ MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+ ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
+ address,ignoreFault);
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
+ store_address_t packet_id) {
+ // debug << "PoolManager( " << translateObject(getObjectId()) <<
+ // " )::deleteData from store " << packet_id.pool_index <<
+ // ". id is "<< packet_id.packet_index << std::endl;
+ MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+ ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
+ size_t size, store_address_t* storeId) {
+ MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+ ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
+ size, storeId);
+ return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::modifyData(
+ store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
+ MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+ ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::modifyData(packet_id,
+ packet_ptr, size);
+ return status;
+}
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 575e9caa..d85fe86f 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -6,9 +6,9 @@
#include <stddef.h>
/**
- * This union defines the type that identifies where a data packet is stored in the store.
- * It comprises of a raw part to read it as raw value and a structured part to use it in
- * pool-like stores.
+ * This union defines the type that identifies where a data packet is
+ * stored in the store. It comprises of a raw part to read it as raw value and
+ * a structured part to use it in pool-like stores.
*/
union store_address_t {
/**
@@ -94,7 +94,8 @@ public:
* @li RETURN_FAILED if data could not be added.
* storageId is unchanged then.
*/
- virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t * data, uint32_t size, bool ignoreFault = false) = 0;
+ virtual ReturnValue_t addData(store_address_t* storageId,
+ const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
/**
* @brief With deleteData, the storageManager frees the memory region
* identified by packet_id.
@@ -105,14 +106,16 @@ public:
*/
virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
/**
- * @brief Another deleteData which uses the pointer and size of the stored data to delete the content.
+ * @brief Another deleteData which uses the pointer and size of the
+ * stored data to delete the content.
* @param buffer Pointer to the data.
* @param size Size of data to be stored.
* @param storeId Store id of the deleted element (optional)
* @return @li RETURN_OK on success.
* @li failure code if deletion did not work
*/
- virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL) = 0;
+ virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+ store_address_t* storeId = nullptr) = 0;
/**
* @brief getData returns an address to data and the size of the data
* for a given packet_id.
@@ -125,12 +128,12 @@ public:
* (e.g. an illegal packet_id was passed).
*/
virtual ReturnValue_t getData(store_address_t packet_id,
- const uint8_t** packet_ptr, uint32_t* size) = 0;
+ const uint8_t** packet_ptr, size_t* size) = 0;
/**
* Same as above, but not const and therefore modifiable.
*/
virtual ReturnValue_t modifyData(store_address_t packet_id,
- uint8_t** packet_ptr, uint32_t* size) = 0;
+ uint8_t** packet_ptr, size_t* size) = 0;
/**
* This method reserves an element of \c size.
*
@@ -144,7 +147,8 @@ public:
* @li RETURN_FAILED if data could not be added.
* storageId is unchanged then.
*/
- virtual ReturnValue_t getFreeElement(store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+ virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+ const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
/**
* Clears the whole store.
* Use with care!
From c7856da81c77fca6caa31873f942e0998f9b4586 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 May 2020 16:53:04 +0200
Subject: [PATCH 2/6] size_t replacements
---
action/ActionHelper.cpp | 2 +-
action/CommandActionHelper.cpp | 2 +-
action/SimpleActionHelper.cpp | 2 +-
datapool/DataPoolAdmin.cpp | 2 +-
devicehandlers/DeviceHandlerBase.cpp | 2 +-
memory/MemoryHelper.cpp | 2 +-
parameters/ParameterHelper.cpp | 2 +-
subsystem/Subsystem.cpp | 4 ++--
tcdistribution/CCSDSDistributor.cpp | 2 +-
tmtcpacket/pus/TcPacketStored.cpp | 4 ++--
tmtcpacket/pus/TmPacketStored.cpp | 2 +-
11 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 9c1475f1..18e46fba 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -49,7 +49,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
store_address_t dataAddress) {
const uint8_t* dataPtr = NULL;
- uint32_t size = 0;
+ size_t size = 0;
ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
if (result != HasReturnvaluesIF::RETURN_OK) {
CommandMessage reply;
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 05eb9346..ceb97d3b 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -113,7 +113,7 @@ uint8_t CommandActionHelper::getCommandCount() const {
void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
const uint8_t * data = NULL;
- uint32_t size = 0;
+ size_t size = 0;
ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
if (result != HasReturnvaluesIF::RETURN_OK) {
return;
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 6de372fb..6861fc28 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -44,7 +44,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
queueToUse->sendMessage(commandedBy, &reply);
}
const uint8_t* dataPtr = NULL;
- uint32_t size = 0;
+ size_t size = 0;
ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
if (result != HasReturnvaluesIF::RETURN_OK) {
ActionMessage::setStepReply(&reply, actionId, 0, result);
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index fe6b9215..99d2b51b 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -215,7 +215,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
ParameterMessage::getParameterId(command));
const uint8_t *storedStream;
- uint32_t storedStreamSize;
+ size_t storedStreamSize;
result = storage->getData(ParameterMessage::getStoreId(command),
&storedStream, &storedStreamSize);
if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 22d49d37..aa2305fe 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -558,7 +558,7 @@ void DeviceHandlerBase::doGetRead() {
ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
uint8_t * *data, uint32_t * len) {
- uint32_t lenTmp;
+ size_t lenTmp;
if (IPCStore == NULL) {
*data = NULL;
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 69830084..b204ea42 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -152,7 +152,7 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
ipcAddress = MemoryMessage::getStoreID(message);
const uint8_t* p_data = NULL;
uint8_t* dataPointer = NULL;
- uint32_t size = 0;
+ size_t size = 0;
ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
if (returnCode == RETURN_OK) {
returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 75b71a7e..9e4fc493 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -37,7 +37,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
ParameterMessage::getParameterId(message));
const uint8_t *storedStream;
- uint32_t storedStreamSize;
+ size_t storedStreamSize;
result = storage->getData(
ParameterMessage::getStoreId(message), &storedStream,
&storedStreamSize);
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index e1ec544b..2d7d9c44 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -162,7 +162,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
case ModeSequenceMessage::ADD_SEQUENCE: {
FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
const uint8_t *pointer;
- uint32_t sizeRead;
+ size_t sizeRead;
result = IPCStore->getData(
ModeSequenceMessage::getStoreAddress(message), &pointer,
&sizeRead);
@@ -188,7 +188,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
case ModeSequenceMessage::ADD_TABLE: {
FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
const uint8_t *pointer;
- uint32_t sizeRead;
+ size_t sizeRead;
result = IPCStore->getData(
ModeSequenceMessage::getStoreAddress(message), &pointer,
&sizeRead);
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index ecd7702e..878b8f7d 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -13,7 +13,7 @@ CCSDSDistributor::~CCSDSDistributor() {
iterator_t CCSDSDistributor::selectDestination() {
// debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
const uint8_t* p_packet = NULL;
- uint32_t size = 0;
+ size_t size = 0;
//TODO check returncode?
this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
SpacePacketBase current_packet( p_packet );
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 1f31a763..4bfd0e37 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -59,7 +59,7 @@ bool TcPacketStored::checkAndSetStore() {
void TcPacketStored::setStoreAddress(store_address_t setAddress) {
this->storeAddress = setAddress;
const uint8_t* temp_data = NULL;
- uint32_t temp_size;
+ size_t temp_size;
ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
if (this->checkAndSetStore()) {
status = this->store->getData(this->storeAddress, &temp_data,
@@ -79,7 +79,7 @@ store_address_t TcPacketStored::getStoreAddress() {
bool TcPacketStored::isSizeCorrect() {
const uint8_t* temp_data = NULL;
- uint32_t temp_size;
+ size_t temp_size;
ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
&temp_size);
if (status == StorageManagerIF::RETURN_OK) {
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index f2c1eb28..529f8f8d 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -81,7 +81,7 @@ void TmPacketStored::deletePacket() {
void TmPacketStored::setStoreAddress(store_address_t setAddress) {
storeAddress = setAddress;
const uint8_t* temp_data = NULL;
- uint32_t temp_size;
+ size_t temp_size;
if (!checkAndSetStore()) {
return;
}
From 3ebc25796881bc8b2b75e6bfdba30ce5dc705d8f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 7 May 2020 23:00:09 +0200
Subject: [PATCH 3/6] some little formatting stuff
---
storagemanager/LocalPool.h | 19 ++++++++-----------
storagemanager/PoolManager.h | 12 ++++++------
storagemanager/StorageManagerIF.h | 11 ++++++-----
3 files changed, 20 insertions(+), 22 deletions(-)
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 3af37371..3ddcc491 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,14 +1,11 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-
/**
* @file LocalPool
- *
* @date 02.02.2012
* @author Bastian Baetz
- *
* @brief This file contains the definition of the LocalPool class.
*/
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
#include <framework/objectmanager/SystemObject.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
@@ -20,7 +17,7 @@
/**
* @brief The LocalPool class provides an intermediate data storage with
* a fixed pool size policy.
- * \details The class implements the StorageManagerIF interface. While the
+ * @details The class implements the StorageManagerIF interface. While the
* total number of pools is fixed, the element sizes in one pool and
* the number of pool elements per pool are set on construction.
* The full amount of memory is allocated on construction.
@@ -31,7 +28,6 @@
* It is possible to store empty packets in the pool.
* The local pool is NOT thread-safe.
*/
-
template<uint8_t NUMBER_OF_POOLS = 5>
class LocalPool: public SystemObject, public StorageManagerIF {
public:
@@ -55,9 +51,10 @@ public:
* number of elements for each pool is determined.
* The position of these values correspond to those in
* element_sizes.
- * @param registered Register the pool in object manager or not. Default is false (local pool).
- * @param spillsToHigherPools
- * A variable to determine whether higher n pools are used if the store is full.
+ * @param registered Register the pool in object manager or not.
+ * Default is false (local pool).
+ * @param spillsToHigherPools A variable to determine whether
+ * higher n pools are used if the store is full.
*/
LocalPool(object_id_t setObjectId,
const uint16_t element_sizes[NUMBER_OF_POOLS],
@@ -117,7 +114,7 @@ private:
/**
* @brief store represents the actual memory pool.
* @details It is an array of pointers to memory, which was allocated with
- * a \c new call on construction.
+ * a @c new call on construction.
*/
uint8_t* store[NUMBER_OF_POOLS];
/**
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 6e6c7613..67534cc5 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -15,17 +15,17 @@
template <uint8_t NUMBER_OF_POOLS = 5>
class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
public:
- PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS],
- const uint16_t n_elements[NUMBER_OF_POOLS] );
- /**
- * @brief In the PoolManager's destructor all allocated memory is freed.
- */
+ PoolManager(object_id_t setObjectId,
+ const uint16_t element_sizes[NUMBER_OF_POOLS],
+ const uint16_t n_elements[NUMBER_OF_POOLS]);
+
+ //! @brief In the PoolManager's destructor all allocated memory is freed.
virtual ~PoolManager();
+ //! @brief LocalPool overrides for thread-safety.
ReturnValue_t deleteData(store_address_t) override;
ReturnValue_t deleteData(uint8_t* buffer, size_t size,
store_address_t* storeId = NULL) override;
-
ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
size_t* size) override;
protected:
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d85fe86f..c29ffb70 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -6,8 +6,9 @@
#include <stddef.h>
/**
- * This union defines the type that identifies where a data packet is
- * stored in the store. It comprises of a raw part to read it as raw value and
+ * @brief This union defines the type that identifies where a data packet is
+ * stored in the store.
+ * It consists of a raw part to read it as raw value and
* a structured part to use it in pool-like stores.
*/
union store_address_t {
@@ -15,9 +16,9 @@ union store_address_t {
* Default Constructor, initializing to INVALID_ADDRESS
*/
store_address_t():raw(0xFFFFFFFF){}
+
/**
* Constructor to create an address object using the raw address
- *
* @param rawAddress
*/
store_address_t(uint32_t rawAddress):raw(rawAddress){}
@@ -30,7 +31,8 @@ union store_address_t {
* @param packetIndex
*/
store_address_t(uint16_t poolIndex, uint16_t packetIndex):
- pool_index(poolIndex),packet_index(packetIndex){}
+ pool_index(poolIndex),packet_index(packetIndex) {}
+
/**
* A structure with two elements to access the store address pool-like.
*/
@@ -154,7 +156,6 @@ public:
* Use with care!
*/
virtual void clearStore() = 0;
-
};
#endif /* STORAGEMANAGERIF_H_ */
From 71e103e2b6ce2623fba150aa77c907719863d5ed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 20 May 2020 14:40:50 +0200
Subject: [PATCH 4/6] better include guards
---
storagemanager/LocalPool.tpp | 4 ++--
storagemanager/PoolManager.tpp | 5 +++++
2 files changed, 7 insertions(+), 2 deletions(-)
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 649ec88a..6c4a7d6a 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -1,5 +1,5 @@
-#ifndef LOCALPOOL_TPP
-#define LOCALPOOL_TPP
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
template<uint8_t NUMBER_OF_POOLS>
inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index ed340b91..26eb2270 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,3 +1,6 @@
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
+
template<uint8_t NUMBER_OF_POOLS>
inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
const uint16_t element_sizes[NUMBER_OF_POOLS],
@@ -48,3 +51,5 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::modifyData(
packet_ptr, size);
return status;
}
+
+#endif
From 3a6b7f48959ca8648cc5f770873283dcea37ed81 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 20 May 2020 14:42:52 +0200
Subject: [PATCH 5/6] added new cast for MQ
---
osal/FreeRTOS/MessageQueue.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e5da0442..18e7aa3d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -97,7 +97,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
bool ignoreFault) {
message->setSender(sentFrom);
- BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
+ BaseType_t result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
+ reinterpret_cast<const void*>(message->getBuffer()), 0);
if (result != pdPASS) {
if (!ignoreFault) {
InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
From 91acc471b64a337c3d87fe90022f48deb662368c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 20 May 2020 14:47:58 +0200
Subject: [PATCH 6/6] include guard fix, sif replacements
---
storagemanager/LocalPool.tpp | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 6c4a7d6a..08685de2 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
template<uint8_t NUMBER_OF_POOLS>
inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
@@ -83,7 +83,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
const uint32_t size, store_address_t* address, bool ignoreFault) {
ReturnValue_t status = getPoolIndex(size, &address->pool_index);
if (status != RETURN_OK) {
- error << "LocalPool( " << std::hex << getObjectId() << std::dec
+ sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
<< " )::reserveSpace: Packet too large." << std::endl;
return status;
}
@@ -193,7 +193,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
} else {
//pool_index or packet_index is too large
- error << "LocalPool:deleteData failed." << std::endl;
+ sif::error << "LocalPool:deleteData failed." << std::endl;
status = ILLEGAL_STORAGE_ID;
}
return status;
@@ -249,7 +249,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
//Check if any pool size is large than the maximum allowed.
for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
if (element_sizes[count] >= STORAGE_FREE) {
- error << "LocalPool::initialize: Pool is too large! "
+ sif::error << "LocalPool::initialize: Pool is too large! "
"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
return RETURN_FAILED;
}