tests/bluetooth/mesh/blob_io_flash/src/main.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2023 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/ztest.h>
 #include <zephyr/storage/flash_map.h>
 #include <zephyr/bluetooth/mesh.h>

 #include "mesh/blob.h"

 #define SLOT1_PARTITION		slot1_partition
 #define SLOT1_PARTITION_ID	FIXED_PARTITION_ID(SLOT1_PARTITION)
 #define SLOT1_PARTITION_SIZE	FIXED_PARTITION_SIZE(SLOT1_PARTITION)
 /* Chunk size is set to value that is not multiple of 4, to verify that chunks are written correctly
  * even if they are not aligned with word length used in flash
  */
 #define CHUNK_SIZE		65

 static struct bt_mesh_blob_io_flash blob_flash_stream;

 static size_t chunk_size(const struct bt_mesh_blob_block *block,
 				uint16_t chunk_idx)
 {
 	if ((chunk_idx == block->chunk_count - 1) &&
 	    (block->size % CHUNK_SIZE)) {
 		return block->size % CHUNK_SIZE;
 	}

 	return CHUNK_SIZE;
 }

 static uint8_t block_size_to_log(size_t size)
 {
 	uint8_t block_size_log = 0;

 	while (size > 1) {
 		size = size / 2;
 		block_size_log++;
 	}

 	return block_size_log;
 }

 ZTEST_SUITE(blob_io_flash, NULL, NULL, NULL, NULL, NULL);

 ZTEST(blob_io_flash, test_chunk_read)
 {
 	const struct flash_area *fa = NULL;
 	struct bt_mesh_blob_xfer xfer;
 	struct bt_mesh_blob_block block = { 0 };
 	struct bt_mesh_blob_chunk chunk = { 0 };
 	size_t remaining = SLOT1_PARTITION_SIZE;
 	off_t block_idx = 0;
 	uint16_t chunk_idx = 0;
 	uint8_t chunk_data[CHUNK_SIZE];
 	uint8_t test_data[SLOT1_PARTITION_SIZE];
 	uint8_t ctrl_data[SLOT1_PARTITION_SIZE];
 	size_t tests_data_offset = 0;
 	int i, err;

 	/* Fill test data with pattern */
 	for (i = 0; i < SLOT1_PARTITION_SIZE; i++) {
 		test_data[i] = i % 0xFF;
 	}

 	err = flash_area_open(SLOT1_PARTITION_ID, &fa);
 	zassert_equal(err, 0, "Preparing test data failed with err=%d", err);

 	err = flash_area_erase(fa, 0, ARRAY_SIZE(ctrl_data));
 	zassert_equal(err, 0, "Preparing test data failed with err=%d", err);

 	err = flash_area_write(fa, 0, test_data, ARRAY_SIZE(ctrl_data));
 	zassert_equal(err, 0, "Preparing test data failed with err=%d", err);

 	err = flash_area_read(fa, 0, ctrl_data, ARRAY_SIZE(ctrl_data));
 	zassert_equal(err, 0, "Preparing test data failed with err=%d", err);

 	zassert_mem_equal(ctrl_data, test_data, ARRAY_SIZE(ctrl_data),
 			  "Incorrect data written into flash");

 	memset(ctrl_data, 0, SLOT1_PARTITION_SIZE);

 	flash_area_close(fa);

 	err = bt_mesh_blob_io_flash_init(&blob_flash_stream,
 					 SLOT1_PARTITION_ID, 0);
 	zassert_equal(err, 0, "BLOB I/O init failed with err=%d", err);

 	err = blob_flash_stream.io.open(&blob_flash_stream.io, &xfer, BT_MESH_BLOB_READ);
 	zassert_equal(err, 0, "BLOB I/O open failed with err=%d", err);

 	chunk.data = chunk_data;

 	/* Simulate reading whole partition divided into blocks and chunk of maximum sizes */
 	while (remaining > 0) {
 		block.chunk_count =
 			DIV_ROUND_UP(CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX,
 					 CHUNK_SIZE);
 		block.size = remaining > CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX
 				     ? CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX
 				     : remaining;

 		/* BLOB Client should do nothing to flash area as it's in read mode */
 		err = blob_flash_stream.io.block_start(&blob_flash_stream.io, &xfer, &block);
 		zassert_equal(err, 0, "BLOB I/O open failed with err=%d", err);

 		/* `block_start` in write mode will erase flash pages that can fit block.
 		 * Assert that at least block size of data was not erased in read mode
 		 */
 		flash_area_read(blob_flash_stream.area, block.offset, ctrl_data, block.size);
 		zassert_mem_equal(ctrl_data, &test_data[block.offset], block.size,
 				  "Flash data was altered by `block_start` in read mode");

 		memset(ctrl_data, 0, SLOT1_PARTITION_SIZE);

 		block.offset = block_idx * (1 << block_size_to_log(block.size));

 		for (i = 0; i < block.chunk_count; i++) {
 			chunk.size = chunk_size(&block, chunk_idx);
 			chunk.offset = CHUNK_SIZE * chunk_idx;

 			err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
 			zassert_equal(err, 0, "BLOB I/O read failed with err=%d off=%d len=%d",
 				      err, block.offset + chunk.offset, chunk.size);

 			zassert_mem_equal(&chunk_data, &test_data[tests_data_offset], chunk.size,
 					  "Incorrect data written into flash");
 			chunk_idx++;

 			remaining -= chunk.size;
 			tests_data_offset += chunk.size;
 		}
 		block_idx++;
 		chunk_idx = 0;
 	}

 	/* We read whole sector as BLOB. Try to increment every offset by one and read,
 	 * which should attempt to read outside flash area
 	 */
 	chunk.offset++;
 	err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
 	zassert_false(err == 0, "Read outside flash area successful");

 	chunk.offset--;
 	block.offset++;
 	err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
 	zassert_false(err == 0, "Read outside flash area successful");

 	block.offset--;
 	blob_flash_stream.offset++;
 	err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
 	zassert_false(err == 0, "Read outside flash area successful");

 	blob_flash_stream.io.close(&blob_flash_stream.io, &xfer);
 }

 ZTEST(blob_io_flash, test_chunk_write)
 {
 	struct bt_mesh_blob_xfer xfer;
 	struct bt_mesh_blob_block block = { 0 };
 	struct bt_mesh_blob_chunk chunk = { 0 };
 	size_t remaining = SLOT1_PARTITION_SIZE;
 	off_t block_idx = 0;
 	uint16_t chunk_idx = 0;
 	uint8_t chunk_data[CHUNK_SIZE];
 	/* 3 is maximum length of padding at the end of written chunk */
 	uint8_t chunk_ctrl_data[CHUNK_SIZE + 3];
 	uint8_t end_padding_len;
 	uint8_t test_data[SLOT1_PARTITION_SIZE];
 	uint8_t erased_block_data[CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX];
 	uint8_t ctrl_data[SLOT1_PARTITION_SIZE];
 	size_t tests_data_offset = 0;
 	int i, j, err;

 	/* Fill test data with pattern */
 	for (i = 0; i < SLOT1_PARTITION_SIZE; i++) {
 		test_data[i] = i % 0xFF;
 	}

 	err = bt_mesh_blob_io_flash_init(&blob_flash_stream,
 					 SLOT1_PARTITION_ID, 0);
 	zassert_equal(err, 0, "BLOB I/O init failed with err=%d", err);

 	err = blob_flash_stream.io.open(&blob_flash_stream.io, &xfer, BT_MESH_BLOB_WRITE);
 	zassert_equal(err, 0, "BLOB I/O open failed with err=%d", err);

 	chunk.data = chunk_data;

 	memset(erased_block_data, flash_area_erased_val(blob_flash_stream.area),
 	       CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX);
 	/* Simulate writing whole partition divided into blocks and chunk of maximum sizes */
 	while (remaining > 0) {
 		block.chunk_count =
 			DIV_ROUND_UP(CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX,
 					 CHUNK_SIZE);
 		block.size = remaining > CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX
 				     ? CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX
 				     : remaining;
 		block.offset = block_idx * (1 << block_size_to_log(block.size));

 		err = blob_flash_stream.io.block_start(&blob_flash_stream.io, &xfer, &block);
 		zassert_equal(err, 0, "BLOB I/O open failed with err=%d", err);

 		flash_area_read(blob_flash_stream.area, block.offset,
 				ctrl_data, block.size);

 		zassert_mem_equal(ctrl_data, erased_block_data, block.size,
 				  "Flash data was not erased by `block_start` in write mode");

 		memset(ctrl_data, 0, SLOT1_PARTITION_SIZE);

 		for (i = 0; i < block.chunk_count; i++) {
 			chunk.size = chunk_size(&block, chunk_idx);
 			chunk.offset = CHUNK_SIZE * chunk_idx;

 			memcpy(chunk.data,
 			       &test_data[chunk.offset + block.offset],
 			       chunk.size);

 			err = blob_flash_stream.io.wr(&blob_flash_stream.io, &xfer, &block, &chunk);
 			zassert_equal(err, 0, "BLOB I/O write failed with err=%d", err);

 			/* To calculate end padding length we must calculate size of whole buffer
 			 * and subtract start offset length and chunk size
 			 */
 			end_padding_len =
 				ROUND_UP((block.offset + chunk.offset) %
 					 flash_area_align(blob_flash_stream.area) +
 					 chunk.size, flash_area_align(blob_flash_stream.area)) -
 				(block.offset + chunk.offset) %
 				flash_area_align(blob_flash_stream.area) - chunk.size;

 			flash_area_read(blob_flash_stream.area, block.offset + chunk.offset,
 					chunk_ctrl_data, chunk.size + end_padding_len);

 			zassert_mem_equal(chunk_ctrl_data, chunk_data, chunk.size,
 					  "Incorrect data written into flash");

 			/* Assert that nothing was written into end padding */
 			for (j = 1; j <= end_padding_len; j++) {
 				zassert_equal(chunk_ctrl_data[chunk.size + j],
 					      flash_area_erased_val(blob_flash_stream.area));
 			}
 			chunk_idx++;

 			remaining -= chunk.size;
 			tests_data_offset += chunk.size;
 		}

 		block_idx++;
 		chunk_idx = 0;
 	}

 	flash_area_read(blob_flash_stream.area, 0, ctrl_data, SLOT1_PARTITION_SIZE);
 	zassert_mem_equal(ctrl_data, test_data, SLOT1_PARTITION_SIZE,
 			  "Incorrect chunks written into flash");

 	/* We wrote whole sector as BLOB. Try to increment every offset by one and write,
 	 * which should attempt to write outside flash area
 	 */
 	chunk.offset++;
 	err = blob_flash_stream.io.wr(&blob_flash_stream.io, &xfer, &block, &chunk);
 	zassert_false(err == 0, "Write outside flash area successful");

 	chunk.offset--;
 	block.offset++;
 	err = blob_flash_stream.io.wr(&blob_flash_stream.io, &xfer, &block, &chunk);
 	zassert_false(err == 0, "Write outside flash area successful");

 	block.offset--;
 	blob_flash_stream.offset++;
 	err = blob_flash_stream.io.wr(&blob_flash_stream.io, &xfer, &block, &chunk);
 	zassert_false(err == 0, "Write outside flash area successful");

 	blob_flash_stream.io.close(&blob_flash_stream.io, &xfer);
 }
	/*
	* Copyright (c) 2023 Nordic Semiconductor ASA
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/ztest.h>
	#include <zephyr/storage/flash_map.h>
	#include <zephyr/bluetooth/mesh.h>

	#include "mesh/blob.h"

	#define SLOT1_PARTITION slot1_partition
	#define SLOT1_PARTITION_ID FIXED_PARTITION_ID(SLOT1_PARTITION)
	#define SLOT1_PARTITION_SIZE FIXED_PARTITION_SIZE(SLOT1_PARTITION)
	/* Chunk size is set to value that is not multiple of 4, to verify that chunks are written correctly
	* even if they are not aligned with word length used in flash
	*/
	#define CHUNK_SIZE 65

	static struct bt_mesh_blob_io_flash blob_flash_stream;

	static size_t chunk_size(const struct bt_mesh_blob_block *block,
	uint16_t chunk_idx)
	{
	if ((chunk_idx == block->chunk_count - 1) &&
	(block->size % CHUNK_SIZE)) {
	return block->size % CHUNK_SIZE;
	}

	return CHUNK_SIZE;
	}

	static uint8_t block_size_to_log(size_t size)
	{
	uint8_t block_size_log = 0;

	while (size > 1) {
	size = size / 2;
	block_size_log++;
	}

	return block_size_log;
	}

	ZTEST_SUITE(blob_io_flash, NULL, NULL, NULL, NULL, NULL);

	ZTEST(blob_io_flash, test_chunk_read)
	{
	const struct flash_area *fa = NULL;
	struct bt_mesh_blob_xfer xfer;
	struct bt_mesh_blob_block block = { 0 };
	struct bt_mesh_blob_chunk chunk = { 0 };
	size_t remaining = SLOT1_PARTITION_SIZE;
	off_t block_idx = 0;
	uint16_t chunk_idx = 0;
	uint8_t chunk_data[CHUNK_SIZE];
	uint8_t test_data[SLOT1_PARTITION_SIZE];
	uint8_t ctrl_data[SLOT1_PARTITION_SIZE];
	size_t tests_data_offset = 0;
	int i, err;

	/* Fill test data with pattern */
	for (i = 0; i < SLOT1_PARTITION_SIZE; i++) {
	test_data[i] = i % 0xFF;
	}

	err = flash_area_open(SLOT1_PARTITION_ID, &fa);
	zassert_equal(err, 0, "Preparing test data failed with err=%d", err);

	err = flash_area_erase(fa, 0, ARRAY_SIZE(ctrl_data));
	zassert_equal(err, 0, "Preparing test data failed with err=%d", err);

	err = flash_area_write(fa, 0, test_data, ARRAY_SIZE(ctrl_data));
	zassert_equal(err, 0, "Preparing test data failed with err=%d", err);

	err = flash_area_read(fa, 0, ctrl_data, ARRAY_SIZE(ctrl_data));
	zassert_equal(err, 0, "Preparing test data failed with err=%d", err);

	zassert_mem_equal(ctrl_data, test_data, ARRAY_SIZE(ctrl_data),
	"Incorrect data written into flash");

	memset(ctrl_data, 0, SLOT1_PARTITION_SIZE);

	flash_area_close(fa);

	err = bt_mesh_blob_io_flash_init(&blob_flash_stream,
	SLOT1_PARTITION_ID, 0);
	zassert_equal(err, 0, "BLOB I/O init failed with err=%d", err);

	err = blob_flash_stream.io.open(&blob_flash_stream.io, &xfer, BT_MESH_BLOB_READ);
	zassert_equal(err, 0, "BLOB I/O open failed with err=%d", err);

	chunk.data = chunk_data;

	/* Simulate reading whole partition divided into blocks and chunk of maximum sizes */
	while (remaining > 0) {
	block.chunk_count =
	DIV_ROUND_UP(CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX,
	CHUNK_SIZE);
	block.size = remaining > CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX
	? CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX
	: remaining;

	/* BLOB Client should do nothing to flash area as it's in read mode */
	err = blob_flash_stream.io.block_start(&blob_flash_stream.io, &xfer, &block);
	zassert_equal(err, 0, "BLOB I/O open failed with err=%d", err);

	/* `block_start` in write mode will erase flash pages that can fit block.
	* Assert that at least block size of data was not erased in read mode
	*/
	flash_area_read(blob_flash_stream.area, block.offset, ctrl_data, block.size);
	zassert_mem_equal(ctrl_data, &test_data[block.offset], block.size,
	"Flash data was altered by `block_start` in read mode");

	memset(ctrl_data, 0, SLOT1_PARTITION_SIZE);

	block.offset = block_idx * (1 << block_size_to_log(block.size));

	for (i = 0; i < block.chunk_count; i++) {
	chunk.size = chunk_size(&block, chunk_idx);
	chunk.offset = CHUNK_SIZE * chunk_idx;

	err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
	zassert_equal(err, 0, "BLOB I/O read failed with err=%d off=%d len=%d",
	err, block.offset + chunk.offset, chunk.size);

	zassert_mem_equal(&chunk_data, &test_data[tests_data_offset], chunk.size,
	"Incorrect data written into flash");
	chunk_idx++;

	remaining -= chunk.size;
	tests_data_offset += chunk.size;
	}
	block_idx++;
	chunk_idx = 0;
	}

	/* We read whole sector as BLOB. Try to increment every offset by one and read,
	* which should attempt to read outside flash area
	*/
	chunk.offset++;
	err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
	zassert_false(err == 0, "Read outside flash area successful");

	chunk.offset--;
	block.offset++;
	err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
	zassert_false(err == 0, "Read outside flash area successful");

	block.offset--;
	blob_flash_stream.offset++;
	err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
	zassert_false(err == 0, "Read outside flash area successful");

	blob_flash_stream.io.close(&blob_flash_stream.io, &xfer);
	}

	ZTEST(blob_io_flash, test_chunk_write)
	{
	struct bt_mesh_blob_xfer xfer;
	struct bt_mesh_blob_block block = { 0 };
	struct bt_mesh_blob_chunk chunk = { 0 };
	size_t remaining = SLOT1_PARTITION_SIZE;
	off_t block_idx = 0;
	uint16_t chunk_idx = 0;
	uint8_t chunk_data[CHUNK_SIZE];
	/* 3 is maximum length of padding at the end of written chunk */
	uint8_t chunk_ctrl_data[CHUNK_SIZE + 3];
	uint8_t end_padding_len;
	uint8_t test_data[SLOT1_PARTITION_SIZE];
	uint8_t erased_block_data[CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX];
	uint8_t ctrl_data[SLOT1_PARTITION_SIZE];
	size_t tests_data_offset = 0;
	int i, j, err;

	/* Fill test data with pattern */
	for (i = 0; i < SLOT1_PARTITION_SIZE; i++) {
	test_data[i] = i % 0xFF;
	}

	err = bt_mesh_blob_io_flash_init(&blob_flash_stream,
	SLOT1_PARTITION_ID, 0);
	zassert_equal(err, 0, "BLOB I/O init failed with err=%d", err);

	err = blob_flash_stream.io.open(&blob_flash_stream.io, &xfer, BT_MESH_BLOB_WRITE);
	zassert_equal(err, 0, "BLOB I/O open failed with err=%d", err);

	chunk.data = chunk_data;

	memset(erased_block_data, flash_area_erased_val(blob_flash_stream.area),
	CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX);
	/* Simulate writing whole partition divided into blocks and chunk of maximum sizes */
	while (remaining > 0) {
	block.chunk_count =
	DIV_ROUND_UP(CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX,
	CHUNK_SIZE);
	block.size = remaining > CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX
	? CONFIG_BT_MESH_BLOB_BLOCK_SIZE_MAX
	: remaining;
	block.offset = block_idx * (1 << block_size_to_log(block.size));

	err = blob_flash_stream.io.block_start(&blob_flash_stream.io, &xfer, &block);
	zassert_equal(err, 0, "BLOB I/O open failed with err=%d", err);

	flash_area_read(blob_flash_stream.area, block.offset,
	ctrl_data, block.size);

	zassert_mem_equal(ctrl_data, erased_block_data, block.size,
	"Flash data was not erased by `block_start` in write mode");

	memset(ctrl_data, 0, SLOT1_PARTITION_SIZE);

	for (i = 0; i < block.chunk_count; i++) {
	chunk.size = chunk_size(&block, chunk_idx);
	chunk.offset = CHUNK_SIZE * chunk_idx;

	memcpy(chunk.data,
	&test_data[chunk.offset + block.offset],
	chunk.size);

	err = blob_flash_stream.io.wr(&blob_flash_stream.io, &xfer, &block, &chunk);
	zassert_equal(err, 0, "BLOB I/O write failed with err=%d", err);

	/* To calculate end padding length we must calculate size of whole buffer
	* and subtract start offset length and chunk size
	*/
	end_padding_len =
	ROUND_UP((block.offset + chunk.offset) %
	flash_area_align(blob_flash_stream.area) +
	chunk.size, flash_area_align(blob_flash_stream.area)) -
	(block.offset + chunk.offset) %
	flash_area_align(blob_flash_stream.area) - chunk.size;

	flash_area_read(blob_flash_stream.area, block.offset + chunk.offset,
	chunk_ctrl_data, chunk.size + end_padding_len);

	zassert_mem_equal(chunk_ctrl_data, chunk_data, chunk.size,
	"Incorrect data written into flash");

	/* Assert that nothing was written into end padding */
	for (j = 1; j <= end_padding_len; j++) {
	zassert_equal(chunk_ctrl_data[chunk.size + j],
	flash_area_erased_val(blob_flash_stream.area));
	}
	chunk_idx++;

	remaining -= chunk.size;
	tests_data_offset += chunk.size;
	}

	block_idx++;
	chunk_idx = 0;
	}

	flash_area_read(blob_flash_stream.area, 0, ctrl_data, SLOT1_PARTITION_SIZE);
	zassert_mem_equal(ctrl_data, test_data, SLOT1_PARTITION_SIZE,
	"Incorrect chunks written into flash");

	/* We wrote whole sector as BLOB. Try to increment every offset by one and write,
	* which should attempt to write outside flash area
	*/
	chunk.offset++;
	err = blob_flash_stream.io.wr(&blob_flash_stream.io, &xfer, &block, &chunk);
	zassert_false(err == 0, "Write outside flash area successful");

	chunk.offset--;
	block.offset++;
	err = blob_flash_stream.io.wr(&blob_flash_stream.io, &xfer, &block, &chunk);
	zassert_false(err == 0, "Write outside flash area successful");

	block.offset--;
	blob_flash_stream.offset++;
	err = blob_flash_stream.io.wr(&blob_flash_stream.io, &xfer, &block, &chunk);
	zassert_false(err == 0, "Write outside flash area successful");

	blob_flash_stream.io.close(&blob_flash_stream.io, &xfer);
	}