How to make FDS blocking

[RPDben]

Hi,

I am using an nRF52840 with SDK 17.0.2 and S140 7.2.0. I am running a scheduler based on app_scheduler.

I am trying to make my FDS implementation blocking as it is too complex to run a synchronously as there are quite a few calls to it that are causing havoc with the queues. I have set up a flag that I set to true before executing an FDS operation and then I want to wait for that flag to become false before continuing. I have tried the following:

Simple, empty while loop. This just locks the processor up and the command is never received

while( _fdsBusy ) ;

NRF Delay. This has a similar effect to above

while( _fdsBusy )
{
    nrf_delay_ms(1);
}

Using my scheduler to wait. While the event is received in the Event Handler, the code never carries on executing.

while( _fdsBusy )
{
   app_sched_execute( );
   nrf_pwr_mgmt_run( );
}

Is there any way to achieve what I want?

Thanks,

[Susheel Nuguru]

Hi,

I still do not have a complete picture of the problem based on the info but have 2 small observations.

1. _fdsBusy seems like a global (.bss) level flag which is not an atomic operation so this flag wherever used might need to fenced into a critical section (enter and exit).
2. nrf_delay_ms is very power inefficient, and I would suggest sleeping instead of busy waiting (__WFE or sd_app_evt_wait depending on whether you are using BLE stack, softdevice or not)

[RPDben]

Hi Susheel,

Here is a snippet of my code including initialisation and an example write. The function "Storage_Wait" is the function I am referring to about making the code blocking. I hope this helps shed some light on the situation?

I tried "sd_app_evt_wait()" but that also did not work. The event handler is never invoked after the write or garbage collection.

#define MAX_EVENT_SIZE 128
#define QUEUE_SIZE	   180

static uint32_t _eventBuffer[CEIL_DIV( APP_SCHED_BUF_SIZE( MAX_EVENT_SIZE, QUEUE_SIZE ), sizeof( uint32_t ) )] __ALIGN( 4 );

#define TEST_FILE ( 0xBFFE )
#define TEST_KEY  ( 0x0001 )

static bool volatile _fdsBusy = false;
static bool volatile m_fds_initialised = false;

static char const* fds_evt_str[] = {
	"FDS_EVT_INIT", "FDS_EVT_WRITE", "FDS_EVT_UPDATE", "FDS_EVT_DEL_RECORD", "FDS_EVT_DEL_FILE", "FDS_EVT_GC",
};

static void fds_evt_handler( fds_evt_t const* p_evt );
static void Storage_Wait( void );
const char* fds_err_str( ret_code_t ret );

const char* fds_err_str( ret_code_t ret )
{
	// Array to map FDS return values to strings.
	static char const* err_str[] = {
		"FDS_ERR_OPERATION_TIMEOUT", "FDS_ERR_NOT_INITIALIZED",
		"FDS_ERR_UNALIGNED_ADDR",	 "FDS_ERR_INVALID_ARG",
		"FDS_ERR_NULL_ARG",			 "FDS_ERR_NO_OPEN_RECORDS",
		"FDS_ERR_NO_SPACE_IN_FLASH", "FDS_ERR_NO_SPACE_IN_QUEUES",
		"FDS_ERR_RECORD_TOO_LARGE",	 "FDS_ERR_NOT_FOUND",
		"FDS_ERR_NO_PAGES",			 "FDS_ERR_USER_LIMIT_REACHED",
		"FDS_ERR_CRC_CHECK_FAILED",	 "FDS_ERR_BUSY",
		"FDS_ERR_INTERNAL",
	};

	return err_str[ret - NRF_ERROR_FDS_ERR_BASE];
}

static void fds_evt_handler( fds_evt_t const* p_evt )
{
	if( p_evt->result == NRF_SUCCESS )
	{
		Log_Info( "Event: %s received (NRF_SUCCESS)", fds_evt_str[p_evt->id] );
	}
	else
	{
		Log_Info( "Event: %s received (%s)", fds_evt_str[p_evt->id], fds_err_str( p_evt->result ) );
	}

	switch( p_evt->id )
	{
		case FDS_EVT_INIT:
			if( p_evt->result == NRF_SUCCESS )
			{
				m_fds_initialised = true;
			}
			break;
		default:
			break;
	}

	_fdsBusy = false;

	while( nrf_log_frontend_dequeue( ) )
		;
}

static void Storage_Wait( void )
{
	while( _fdsBusy )
	{
		sd_app_evt_wait( );
	}
}

int main( void )
{
	// Initialise clocks and power
	ret_code_t rc = nrf_drv_clock_init( );
	APP_ERROR_CHECK( rc );

	if( !nrf_drv_power_init_check( ) )
	{
		nrf_drv_power_init( NULL );
	}

	// Initialise Scheduler
	rc = nrf_pwr_mgmt_init( );
	APP_ERROR_CHECK( rc );

	rc = app_sched_init( MAX_EVENT_SIZE, QUEUE_SIZE, ( void* )_eventBuffer );
	APP_ERROR_CHECK( rc );

	uint32_t   ram_start;

	// Enable the SoftDevice
	rc = nrf_sdh_enable_request( );
	APP_ERROR_CHECK( rc );

	rc = nrf_sdh_ble_default_cfg_set( 1, &ram_start );
	APP_ERROR_CHECK( rc );

	rc = nrf_sdh_ble_enable( &ram_start );
	APP_ERROR_CHECK( rc );

	// Initialise Logging
	rc = NRF_LOG_INIT( NULL );
	APP_ERROR_CHECK( rc );

	// Initialise the default backends as enabled in the configuration
	NRF_LOG_DEFAULT_BACKENDS_INIT( );

	NRF_LOG_INFO( "Application Started" );

	// Initialise Storage

	rc = fds_register( fds_evt_handler );
	APP_ERROR_CHECK( rc );

	rc = fds_init( );
	APP_ERROR_CHECK( rc );

	while( !m_fds_initialised )
	{
		sd_app_evt_wait();
	}

	Log_Info( "FDS Initialised" );

	fds_stat_t stat = { 0 };

	rc = fds_stat( &stat );
	APP_ERROR_CHECK( rc );

	NRF_LOG_INFO( "Found %d valid records.", stat.valid_records );
	NRF_LOG_INFO( "Found %d dirty records (ready to be garbage collected).", stat.dirty_records );

	if( stat.dirty_records > 0 )
	{
		_fdsBusy = true;

		rc = fds_gc( );
		APP_ERROR_CHECK( rc );

		Storage_Wait( );
	}

	fds_record_desc_t desc = { 0 };
	fds_find_token_t  tok  = { 0 };


	// Test Write

	static uint32_t const m_deadbeef = 0xDEADBEEF;

	fds_record_t	  record;
	fds_record_desc_t record_desc;

	record.file_id			 = TEST_FILE;
	record.key				 = TEST_KEY;
	record.data.p_data		 = &m_deadbeef;
	record.data.length_words = 1;

	_fdsBusy = true;
	rc = fds_record_write( &record_desc, &record );
	APP_ERROR_CHECK( rc );
	
	Storage_Wait( );

	while(1)
	{
		app_sched_execute( );

		if( nrf_log_frontend_dequeue( ) == false )
		{
			nrf_pwr_mgmt_run( );
		}
	}
}

Thanks

[Susheel Nuguru]

I looked deeper into your code and it looks clean except the usage of while( nrf_log_frontend_dequeue( ) ); in your fds_evt_handler. It is wrong to wait endless like this for dequeue in an event handler which is in the interrupt context. remove this line and check if the deadlock breaks on waiting.

[RPDben]

Hi Susheel,

I have tried just running the snippet above only, with the nrf_log_frontend_dequeue() removed and I am getting some strange behaviour. Sometimes the event handler is never invoked (even for INIT), and sometimes it is. Even if it gets through Init, as soon as it gets to the Garbage Collection, it enters the while loop and then gets stuck. If I step through the while loop, I get the error "<error> app: SOFTDEVICE: ASSERTION FAILED".

Do you have any ideas on this?

[Susheel Nuguru]

I just tested your code with only the snippet you provided which turned out to be complete in itself and remove the dequeue function made the program run normally without any issues. I think there is something else going on in other parts of the code which is not shown here.