modules: storage: Move from FIFO to pipe

Use pipe internally instead of FIFO. This aboids dynamic allocation
and requirement of the consumer freeing data.

Signed-off-by: Jan Tore Guggedal <jantore.guggedal@nordicsemi.no>

Author: jtguggedal

app/src/modules/storage/Kconfig.storage

@@ -70,16 +70,17 @@ config APP_STORAGE_RAM_LIMIT_KB
 	  MAX_TYPES * MAX_RECORDS_PER_TYPE * RECORD_SIZE bytes.
 	  Set this based on your system's available RAM.
 
-config APP_STORAGE_FIFO_ITEM_COUNT
-	int "FIFO item count"
-	default 20
+config APP_STORAGE_BATCH_BUFFER_SIZE
+	int "Storage batch buffer size in bytes"
+	default 1024
 	help
-	  Maximum number of memory slabs available to use in the storage module's FIFO.
-	  The FIFO is used when data is sent from the storage module to other modules.
-	  This option is also used to set the number of each registered data type that can be stored
-	  in the FIFO.
-	  For example, if set to 20, there will be 20 memory slabs available for each registered
-	  data type, and a total of 20 items can be stored in the FIFO at any time.
+	  Size of the internal buffer for batch data access.
+	  This buffer is used to transfer data from the storage backend
+	  to consuming modules via the batch interface.
+
+	  Larger buffers can improve throughput but use more RAM.
+	  Must be large enough to hold at least one complete data item
+	  plus its header.
 
 if APP_STORAGE_BACKEND_INTERNAL_FLASH
 
@@ -133,7 +134,6 @@ config APP_STORAGE_INITIAL_MODE_BUFFER
 
 endchoice
 
-
 config APP_STORAGE_SHELL
 	bool "Enable storage shell commands"
 	default y

app/src/modules/storage/backends/ram_ring_buffer_backend.c

@@ -142,7 +142,7 @@ static int ram_init(void)
 
 		LOG_DBG("RAM backend initialized with %d types, using %zu bytes of RAM",
 			ctx.num_registered_types,
-			sizeof(t->data_size) * RECORDS_PER_TYPE);
+			t->data_size * (size_t)RECORDS_PER_TYPE);
 
 		LOG_DBG("Ring buffer %s initialized with size %u, item size: %zu", t->name,
 			ring_buf_capacity_get(get_ring_buf_ptr(idx)), t->data_size);
@@ -217,6 +217,62 @@ static int ram_store(const struct storage_data *type, const void *data, size_t s
 	return 0;
 }
 
+/**
+ * @brief Peek at data from the RAM backend without removing it
+ *
+ * Returns the size of the next item without copying data (if data is NULL)
+ * or copies the data if data buffer is provided.
+ *
+ * @param type Storage data type to peek at
+ * @param data Pointer where the peeked data will be stored (can be NULL for size-only)
+ * @param size Size of the data buffer in bytes (ignored if data is NULL)
+ * @return Number of bytes that would be read on success, negative errno on failure
+ */
+static int ram_peek(const struct storage_data *type, void *data, size_t size)
+{
+	struct ring_buf *ring_buf;
+	int idx;
+	uint32_t bytes_peeked;
+
+	if (!type) {
+		return -EINVAL;
+	}
+
+	idx = get_type_index(type);
+	if (idx < 0) {
+		return -EINVAL;
+	}
+
+	ring_buf = get_ring_buf_ptr(idx);
+
+	if (ring_buf_is_empty(ring_buf)) {
+		return -EAGAIN;
+	}
+
+	/* If data is NULL, just return the size without copying */
+	if (data == NULL) {
+		return (int)type->data_size;
+	}
+
+	/* Data buffer provided - ensure it's large enough */
+	if (type->data_size > size) {
+		LOG_ERR("Buffer too small for data: needed %zu, have %zu", type->data_size, size);
+
+		return -ENOMEM;
+	}
+
+	/* Peek at the data without removing it */
+	bytes_peeked = ring_buf_peek(ring_buf, data, (uint32_t)type->data_size);
+	if (bytes_peeked != (uint32_t)type->data_size) {
+		LOG_ERR("Failed to peek data: expected %zu bytes, got %u",
+			type->data_size, bytes_peeked);
+
+		return -EIO;
+	}
+
+	return (int)bytes_peeked;
+}
+
 /**
  * @brief Retrieve data from the RAM backend
  *
@@ -347,6 +403,7 @@ static int ram_clear(void)
 static const struct storage_backend ram_backend = {
 	.init = ram_init,
 	.store = ram_store,
+	.peek = ram_peek,
 	.retrieve = ram_retrieve,
 	.count = ram_records_count,
 	.clear = ram_clear,