FDS Write: Wrong Written Data

RE: FDS Write: Wrong Written Data

jloliveira — Tue, 29 May 2018 15:36:39 GMT

Thank you Rune, that worked.

RE: FDS Write: Wrong Written Data

Rune Holmgren — Fri, 27 Apr 2018 13:35:36 GMT

Sorry, I should have realized this when first looking at your post. The problem is not the flash, but rather that you are trying to print strings which are not null terminated.

The reason you are successfully able to write and later print strings that are not a length divisible by 4 is that the flash memory will be padded with '0's. When you write "tes" to flash, the actual flash will be padded with a 0 byte at the end. In flash the following values will be present [116, 101, 115, 0]. To C this is the string "tes" with the final byte telling sprintf that the string has ended. When you write the string "test" to flash, the actual content of flash will be [116, 101, 115, 116] with no null terminator. When you send a reference to this flash address to the logging framework, nrf_log will attempt to print all the bytes it can find until a '0' is found. This may be an incredibly long string and the buffers overflow and cause the device to hang.

To resolve the issue, simply ensure that the data you are writing to flash is either null terminated, or that you add a null terminator after reading it out.

In this image, I have changed the printing to print specifically the first 4 characters present in flash. As you can see the word "test" is present, but there is no null terminator. You can't send this string as is to sprintf without adding a null terminator.

Best regards,
Rune Holmgren

RE: FDS Write: Wrong Written Data

jloliveira — Fri, 27 Apr 2018 11:27:58 GMT

Hi Rune,

What I meant is for you to please to consider writing a string with 4 bytes, such as "test" or "test1234".

When reading it back and printing frec.p_data as you did with print all it should halt the application - at least on my side it does, everytime.

Thank you again,

João

RE: FDS Write: Wrong Written Data

Rune Holmgren — Fri, 27 Apr 2018 11:18:42 GMT

Hi,

Very sorry for the late reply.

I have tried reproducing this issue as you described, but there seems to be no problem writing the string to flash and reading it back. I added the log statement as you described and wrote the string and read it back without any issues. I performed my test on SDK 15.

I also discussed the issue with one of the developers working on FDS, and he was not familiar with the issue you are describing. Am I understanding it correctly, you are not getting any error while writing the record, but when you read it back it's not working as expected?

Any information you have which may help us recreating the issue is very welcome.

Best regards,
Rune Holmgren

RE: FDS Write: Wrong Written Data

jloliveira — Mon, 23 Apr 2018 15:45:17 GMT

Dear Rune,

Do you have any news regarding my issue reported above?

I need an answer urgently.

Thank you,

João

RE: FDS Write: Wrong Written Data

jloliveira — Sun, 15 Apr 2018 22:36:40 GMT

Hi again Rune,

After struggling a lot I just found out that the problem occurs when I try to write any userid string that has a number of bytes multiple of 4 (that is 4bytes, 8bytes, 12bytes, etc). It writes without any error but when I try to read that flash data afterwards the app gets stuck without reporting erros.

I found it very weird and tested it then in the flash_fds example directly and the same issue occurs.

Just try to write any multiple of 4 bytes string with the command "write fid key "multiple_of_4_bytes_string"" and then read the data by calling the "print all" command but with a NRF_LOG_INFO("%s", (char*)frec.p_data) line (or any other line that makes use of frec.p_data) inside the print_all_cmd function.

I guess this is a very weird bug in the FDS API that might be related to word-unalignment in flash.

Looking forward to hear about your clarification about this issue,

Best regards,

João

RE: FDS Write: Wrong Written Data

jloliveira — Thu, 12 Apr 2018 18:05:24 GMT

Dear Rune,

Thank you for your reply, I also used a static variable to make sure it is word-aligned but still required to declare __ALIGN(4) in the DEVICE struct declaration itself in order to make sure it never returns FDS_ERR_UNALIGNED_ADDR when writing to flash, as flash_write_config_record() is called from different scopes (from different .c files).

In the meantime I also created read/write fds functions for a userid in char* format. As these are also called from different scopes, in order to guarantee no word-alignment errors, the flash_write_userid_record() function copies the userid2write data into an __ALIGN(4) static char* variable to be written into flash.

As per flash_read_userid(), I had to use a pointer to char* pointing to the flash data char* to return it.

Although every read/write call seem to work fine, for some reason I can't identify some rare times the app crashes when calling flash_read_userid() just after setting up the BLE connection without any assert, and the flash record seem to get corrupted as I can't write to it anymore unless I delete it before.

Is there anything I'm doing wrong with the read/write user id functions and calls, or could it be colliding with the BLE radio activity somehow?

Find the new code below:

/* Declarations in flash.h */

/* File ID and Key used for the configuration record. */

#define CONFIG_FILE     (0xF010)
#define CONFIG_REC_KEY  (0x7010)

/* File ID and Key used for the userid record. */

#define USERID_FILE     (0xF050)
#define USERID_REC_KEY  (0x7050)

typedef struct
{
	uint8_t enable;
	uint8_t time_adv;
}ADVERTISE;

typedef struct
{
	uint8_t state;
	ADVERTISE adv2;
}__ALIGN(4) DEVICE;


/* ========= flash.c ==========

ret_code_t flash_read_config(DEVICE * p_cfg)
{
    ret_code_t read_success = FDS_ERR_NOT_FOUND;

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

    //Loop until all records with the given key and file ID have been found.
    while (fds_record_find(CONFIG_FILE, CONFIG_REC_KEY, &desc, &tok) == FDS_SUCCESS)
    {
        ret_code_t rc;
        fds_flash_record_t frec = {0};

        rc = fds_record_open(&desc, &frec);

        switch (rc)
        {
            case FDS_SUCCESS:
                break;

            case FDS_ERR_CRC_CHECK_FAILED:
                #ifdef _UART_FLASH_
                NRF_LOG_INFO("error: CRC check failed!");
                #endif
                continue;

            case FDS_ERR_NOT_FOUND:
                #ifdef _UART_FLASH_
                NRF_LOG_INFO("error: record not found!");
                #endif
                continue;

            default:
            {
                #ifdef _UART_FLASH_
                NRF_LOG_INFO("error: unexpected error %s.",
                                fds_err_str[rc]);
                #endif

                continue;
            }
        }

        //memcpy to pass p_cfg pointer with flash data from frec.p_data
        memcpy(p_cfg, frec.p_data, sizeof(DEVICE));

        NRF_LOG_INFO("FLASH READ CONFIG 00%x0%x0%x @ %x:",
        p_cfg->adv2.time_adv, p_cfg->adv2.enable, p_cfg->state, tok.p_addr);
        NRF_LOG_INFO("state: %d\r\n" 
                      "adv2.enable: %d\r\n"
                      "adv2.time_adv: %d\r\n",
                      p_cfg->state, p_cfg->adv2.enable, p_cfg->adv2.time_adv);

        rc = fds_record_close(&desc);
        APP_ERROR_CHECK(rc);

        read_success = FDS_SUCCESS; //if found and read record
    }

    return read_success;
}

void flash_write_config_record(DEVICE * config2write)
{
    ret_code_t rc;

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

    // Copy write data to static word-aligned variable.
    uint32_t const len_cfg = sizeof(config2write);
    __ALIGN(4) static DEVICE flash_write_data;
    memcpy(&flash_write_data, config2write, len_cfg);

    //CONFIG_FILE and CONFIG_REC_KEY defined in flash.h
    rc = fds_record_find(CONFIG_FILE, CONFIG_REC_KEY, &desc, &tok);
    if (rc == FDS_SUCCESS) //record exists => update it
    {
        /* A config file is in flash. Let's update it. */
        fds_flash_record_t config = {0};

        /* Open the record and read its contents. */
        rc = fds_record_open(&desc, &config);
        APP_ERROR_CHECK(rc);

        //compare existing config in flash with new one      
        NRF_LOG_INFO("CONFIG IN FLASH:\r\n"
                  "state: %d\r\n" 
                  "adv2.enable: %d\r\n"
                  "adv2.time_adv: %d\r\n",
                  ((DEVICE*)config.p_data)->state, ((DEVICE*)config.p_data)->adv2.enable, ((DEVICE*)config.p_data)->adv2.time_adv);
        
        NRF_LOG_INFO("NEW CONFIG TO UPDATE:\r\n"
                      "state: %d\r\n" 
                      "adv2.enable: %d\r\n"
                      "adv2.time_adv: %d\r\n",
                      flash_write_data.state, flash_write_data.adv2.enable, flash_write_data.adv2.time_adv);

        uint8_t ret = memcmp(&flash_write_data, config.p_data, len_cfg);
        
        // Close the record when done reading. 
        rc = fds_record_close(&desc);
        APP_ERROR_CHECK(rc);
        
        if(ret != 0) //if different update config in flash
        {
            record_update(CONFIG_FILE, CONFIG_REC_KEY, desc, &flash_write_data, len_cfg);

            NRF_LOG_INFO("===== UPDATED FDS FLASH =====);

            m_write_finished = false;
        }
        else
        {
             #ifdef _UART_FLASH_
             NRF_LOG_INFO("FLASH: same config data as previous, nothing to be done:\r\n"
                      "state: %d\r\n" 
                      "adv2.enable: %d\r\n"
                      "adv2.time_adv: %d\r\n",
                      ((DEVICE*)config.p_data)->state, ((DEVICE*)config.p_data)->adv2.enable, ((DEVICE*)config.p_data)->adv2.time_adv);
             #endif
        }
    }
    else
    {
        /* System config not found; write a new one. */
        NRF_LOG_INFO("NEW CONFIG TO WRITE:\r\n"
                      "state: %d\r\n" 
                      "adv2.enable: %d\r\n"
                      "adv2.time_adv: %d\r\n",
                      flash_write_data.state, flash_write_data.adv2.enable, flash_write_data.adv2.time_adv);

        record_write(CONFIG_FILE, CONFIG_REC_KEY, &flash_write_data, len_cfg);

        NRF_LOG_INFO("===== WROTE FDS FLASH =====");

        m_write_finished = false;
    }
}

//NOTE: Need Pointer to Pointer for userid to return the char* in the address pointing to freq.p_data because it is an array of chars and therefore can't use memcpy to copy freq.p_data and return because it loses scope
static void record_write(uint32_t fid,
                         uint32_t key,
                         void const * p_data,
                         uint32_t len)
{
    fds_record_t const rec =
    {
        .file_id           = fid,
        .key               = key,
        .data.p_data       = p_data,
        .data.length_words = (len + 3) / sizeof(uint32_t)
    };

    #ifdef _UART_FLASH_
    NRF_LOG_INFO("--> writing record to flash...\r\n"
                    "file: 0x%x, key: 0x%x, \"%s\", len: %u bytes",
                    fid, key, p_data, len);
    #endif

    ret_code_t rc = fds_record_write(NULL, &rec);

    #ifdef _UART_FLASH_
    if (rc != FDS_SUCCESS)
    {
        NRF_LOG_INFO("--> error: fds_record_write() returned %s.",
                        fds_err_str[rc]);
    }
    #endif
}

static void record_update(uint32_t fid,
                         uint32_t key,
                         fds_record_desc_t desc, 
                         void const * p_data,
                         uint32_t len)
{
    fds_record_t const rec =
    {
        .file_id           = fid,
        .key               = key,
        .data.p_data       = p_data,
        .data.length_words = (len + 3) / sizeof(uint32_t)
    };

    #ifdef _UART_FLASH_
    NRF_LOG_INFO("--> updating record in flash...\r\n"
                    "file: 0x%x, key: 0x%x, \"%s\", len: %u bytes",
                    fid, key, p_data, len);
    #endif

    ret_code_t rc = fds_record_update(&desc, &rec);

    #ifdef _UART_FLASH_
    if (rc != FDS_SUCCESS)
    {
        NRF_LOG_INFO("--> error: fds_record_write() returned %s.",
                        fds_err_str[rc]);
    }
    #endif
}

ret_code_t flash_read_userid(char ** userid)
{
    ret_code_t read_success = FDS_ERR_NOT_FOUND;

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

    //Loop until all records with the given key and file ID have been found.
    while (fds_record_find(USERID_FILE, USERID_REC_KEY, &desc, &tok) == FDS_SUCCESS)
    {
        ret_code_t rc;
        fds_flash_record_t frec = {0};

        rc = fds_record_open(&desc, &frec);
        switch (rc)
        {
            case FDS_SUCCESS:
                break;

            case FDS_ERR_CRC_CHECK_FAILED:
                #ifdef _UART_FLASH_
                NRF_LOG_INFO("error: CRC check failed!");
                #endif
                continue;

            case FDS_ERR_NOT_FOUND:
                #ifdef _UART_FLASH_
                NRF_LOG_INFO("error: record not found!");
                #endif
                continue;

            default:
            {
                #ifdef _UART_FLASH_
                NRF_LOG_INFO("error: unexpecte error %s.",
                                fds_err_str[rc]);
                #endif

                continue;
            }
        }

        //Memcpy frec.p_data address and point to copy's address
        uint32_t const len_str = strlen((char*)frec.p_data)+1; //NOTE: +1 to include NULL char in end of string
        __ALIGN(4) static uint8_t * flash_read_data;
        flash_read_data = malloc(sizeof(uint8_t) * len_str);
        memset(flash_read_data, 0x00, sizeof(flash_read_data));
        memcpy(flash_read_data, frec.p_data, len_str);
        
        *userid = (char*)flash_read_data;

        rc = fds_record_close(&desc);
        APP_ERROR_CHECK(rc);

        read_success = FDS_SUCCESS; //if found and read record
    }

    return read_success;
}

void flash_write_userid_record(char * userid2write)
{
    ret_code_t rc;

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

    // Copy write data to static word-aligned variable.
    uint32_t const len_str = strlen(userid2write)+1; //NOTE: +1 to include NULL char in end of string
    __ALIGN(4) static char * flash_write_data;
    flash_write_data = malloc(sizeof(char) * len_str);
    memset(flash_write_data, 0x00, sizeof(flash_write_data));
    memcpy(flash_write_data, userid2write, len_str);

    //CONFIG_FILE and CONFIG_REC_KEY defined in flash.h
    rc = fds_record_find(USERID_FILE, USERID_REC_KEY, &desc, &tok);
    if (rc == FDS_SUCCESS) //record exists => update it
    {
        /// A userid file is in flash. Let's update it.
        fds_flash_record_t userid = {0};

        // Open the record and read its contents. 
        rc = fds_record_open(&desc, &userid);
        APP_ERROR_CHECK(rc);
 
        //compare existing config in flash with new one      
        //NOTE: need to copy flash data to static var to hold the data correctly, and __ALIGNED(4) to guarantee word-alignment
        uint32_t const len_str = strlen((char*)userid.p_data)+1; //NOTE: +1 to include NULL char in end of string
        __ALIGN(4) static char * flash_read_data;
        flash_read_data = malloc(sizeof(char) * len_str);
        memset(flash_read_data, 0x00, sizeof(flash_read_data));
        memcpy(flash_read_data, userid.p_data, len_str);
        

        //__ALIGN(4) static char * flash_read_data;
        //flash_read_data = (char*)userid.p_data;

        #ifdef _UART_FLASH_
        NRF_LOG_INFO("NEW USERID TO UPDATE: %s", userid2write);
        NRF_LOG_INFO("USERID IN FLASH     : %s", flash_read_data);
        #endif

        //NOTE: Use strlen to compare strings until end of first string
        uint8_t ret = memcmp(userid2write, flash_read_data, len_str);

        // Close the record when done reading. 
        rc = fds_record_close(&desc);
        APP_ERROR_CHECK(rc);

        if(ret != 0) //if different update config in flash
        {
            // Write the updated record to flash.
            #ifdef _UART_FLASH_            
            NRF_LOG_INFO("FLASH TO UPDATE W/ NEW USERID: %s", flash_write_data);       
            #endif

            record_update(USERID_FILE, USERID_REC_KEY, desc, flash_write_data, len_str);

            #ifdef _UART_FLASH_
            NRF_LOG_INFO("===== UPDATED FDS FLASH W/ USERID =====");
            #endif

            m_write_finished = false;
        }
        else
        {
             #ifdef _UART_FLASH_
             NRF_LOG_INFO("FLASH: same userid data as previous, nothing to be done");
             #endif
        }
    }
    else
    {
        // System config not found; write a new one.
        #ifdef _UART_FLASH_
        NRF_LOG_INFO("FLASH TO WRITE NEW USERID: %s", flash_write_data);
        #endif

        record_write(USERID_FILE, USERID_REC_KEY, flash_write_data, len_str);

        #ifdef _UART_FLASH_
        NRF_LOG_INFO("===== WROTE FDS FLASH =====");
        #endif

        m_write_finished = false;
    }
}

Thank you,

João

RE: FDS Write: Wrong Written Data

Rune Holmgren — Wed, 11 Apr 2018 08:03:12 GMT

Sorry for the late reply.

The flash in the nRF5 series can only handle whole words, so you need to make sure all data is aligned with 4-byte words. My guess would be that you are having problems with "config2write" not being word aligned. In my code above I had it stored as a static variable, so my compiler will just put it in RAM at some suitable address and there will never be a problem. If I were to store it in a struct or array of some kind it's possible to get into a situation where the data is not aligned.

Best regards,
Rune Holmgren

RE: FDS Write: Wrong Written Data

jloliveira — Fri, 06 Apr 2018 11:41:06 GMT

Hi Rune,

Thank you for your help.

I tried the code directly in the flash_fds example as per your code and it works fine.

Yet, when I use exactly the same code in my app I'm struggling with code alignment erros with the fds_record_update() returning error FDS_ERR_UNALIGNED_ADDR. I guess the same could happen in your code eventually. How can I guarantee that the config2write address I'm trying to save on flash is word aligned?

Thank you,

João

RE: FDS Write: Wrong Written Data

Rune Holmgren — Wed, 04 Apr 2018 14:24:46 GMT

Hi,

I tested the flash part of your code by copying it over into the fds example in SDK15.0.0. I added some logging of the state struct member to see the initial write, value on boot and update writes. As you can see below where I started with an empty device and pressed reset twice, I first write the initial value of 1, then I update it to 2 and after that, the value is 2 already so no new update is performed.

Here is the main.c file I used, the rest is just the FDS example in SDK15.0.0 unaltered:

/**
 * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA
 * 
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 * 
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 * 
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 * 
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 * 
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 */

#include <stdint.h>
#include <string.h>
#include "nrf.h"
#include "nordic_common.h"
#ifdef SOFTDEVICE_PRESENT
#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#else
#include "nrf_drv_clock.h"
#endif
#include "fds.h"
#include "app_timer.h"
#include "app_error.h"
#include "nrf_cli.h"
#include "fds_example.h"

#define NRF_LOG_MODULE_NAME app
#include "nrf_log.h"
#include "nrf_log_ctrl.h"


/* A tag identifying the SoftDevice BLE configuration. */
#define APP_BLE_CONN_CFG_TAG    1


/* Array to map FDS return values to strings. */
char const * fds_err_str[] =
{
    "FDS_SUCCESS",
    "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",
};

/* Array to map FDS events to strings. */
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",
};

/* Dummy configuration data. */
static configuration_t m_dummy_cfg =
{
    .config1_on  = false,
    .config2_on  = true,
    .boot_count  = 0x0,
    .device_name = "dummy",
};

/* A record containing dummy configuration data. */
static fds_record_t const m_dummy_record =
{
    .file_id           = CONFIG_FILE,
    .key               = CONFIG_REC_KEY,
    .data.p_data       = &m_dummy_cfg,
    /* The length of a record is always expressed in 4-byte units (words). */
    .data.length_words = (sizeof(m_dummy_cfg) + 3) / sizeof(uint32_t),
};

/* Keep track of the progress of a delete_all operation. */
static struct
{
    bool delete_next;   //!< Delete next record.
    bool pending;       //!< Waiting for an fds FDS_EVT_DEL_RECORD event, to delete the next record.
} m_delete_all;

/* Flag to check fds initialization. */
static bool volatile m_fds_initialized;


static void fds_evt_handler(fds_evt_t const * p_evt)
{
    NRF_LOG_GREEN("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 == FDS_SUCCESS)
            {
                m_fds_initialized = true;
            }
            break;

        case FDS_EVT_WRITE:
        {
            if (p_evt->result == FDS_SUCCESS)
            {
                NRF_LOG_INFO("Record ID:\t0x%04x",  p_evt->write.record_id);
                NRF_LOG_INFO("File ID:\t0x%04x",    p_evt->write.file_id);
                NRF_LOG_INFO("Record key:\t0x%04x", p_evt->write.record_key);
            }
        } break;

        case FDS_EVT_DEL_RECORD:
        {
            if (p_evt->result == FDS_SUCCESS)
            {
                NRF_LOG_INFO("Record ID:\t0x%04x",  p_evt->del.record_id);
                NRF_LOG_INFO("File ID:\t0x%04x",    p_evt->del.file_id);
                NRF_LOG_INFO("Record key:\t0x%04x", p_evt->del.record_key);
            }
            m_delete_all.pending = false;
        } break;

        default:
            break;
    }
}


/**@brief   Begin deleting all records, one by one. */
void delete_all_begin(void)
{
    m_delete_all.delete_next = true;
}


/**@brief   Process a delete all command.
 *
 * Delete records, one by one, until no records are left.
 */
void delete_all_process(void)
{
    if (   m_delete_all.delete_next
        & !m_delete_all.pending)
    {
        NRF_LOG_INFO("Deleting next record.");

        m_delete_all.delete_next = record_delete_next();
        if (!m_delete_all.delete_next)
        {
            NRF_LOG_CYAN("No records left to delete.");
        }
    }
}


#ifdef SOFTDEVICE_PRESENT
/**@brief   Function for initializing the SoftDevice and enabling the BLE stack. */
static void ble_stack_init(void)
{
    ret_code_t rc;
    uint32_t   ram_start;

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

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

    rc = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(rc);
}
#else
static void clock_init(void)
{
    /* Initialize the clock. */
    ret_code_t rc = nrf_drv_clock_init();
    APP_ERROR_CHECK(rc);

    nrf_drv_clock_lfclk_request(NULL);

    /* Wait for the clock to be ready. */
    while (!nrf_clock_lf_is_running()) {;}
}
#endif


/**@brief   Initialize the timer. */
static void timer_init(void)
{
    ret_code_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);
}


/**@brief   Initialize logging. */
static void log_init(void)
{
    ret_code_t rc = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(rc);
}


/**@brief   Sleep until an event is received. */
static void power_manage(void)
{
#ifdef SOFTDEVICE_PRESENT
    (void) sd_app_evt_wait();
#else
    __WFE();
#endif
}


/**@brief   Wait for fds to initialize. */
static void wait_for_fds_ready(void)
{
    while (!m_fds_initialized)
    {
        power_manage();
    }
}


typedef struct
{
    uint8_t enable;
    uint8_t time_adv;
}ADVERTISE;

typedef struct
{
    uint8_t state;
    ADVERTISE adv2;
}DEVICE;

static DEVICE config2write;

void flash_write_record_setup(DEVICE * config2write)
{
    ret_code_t rc;
    fds_record_desc_t desc = {0};
    fds_find_token_t  tok  = {0};

    rc = fds_record_find(CONFIG_FILE, CONFIG_REC_KEY, &desc, &tok);

    if (rc == FDS_SUCCESS)
    {
        config2write->state = 2;

        /* A config file is in flash. Let's update it. */
        fds_flash_record_t config = {0};

        /* Open the record and read its contents. */
        rc = fds_record_open(&desc, &config);
        APP_ERROR_CHECK(rc);

        DEVICE * tmp = (DEVICE*)config.p_data;
        NRF_LOG_INFO("Current file content: %d .", tmp->state);

        //compare existing config in flash with new one
        uint8_t ret = memcmp(config2write, config.p_data, sizeof(DEVICE));

        /* Close the record when done reading. */
        rc = fds_record_close(&desc);
        APP_ERROR_CHECK(rc);
 
        NRF_LOG_INFO("NEW  : %d", ((uint32_t*)config2write)[0]);
        NRF_LOG_INFO("FLASH: %d", ((uint32_t*)config.p_data)[0]);

        if(ret != 0) //if different update config in flash
        {
            NRF_LOG_INFO("Updating state value to 2");
            config2write->state = 2;
            /* Write the updated record to flash. */
            fds_record_t const rec =
            {
                .file_id           = CONFIG_FILE,
                .key               = CONFIG_REC_KEY,
                .data.p_data       = config2write,
                .data.length_words = (sizeof(DEVICE) + 3) / sizeof(uint32_t)
            };

            rc = fds_record_update(&desc, &rec);
            APP_ERROR_CHECK(rc);
        }
        else
        {
            /* Same config data as previous, nothing to be done */
        }
    }
    else
    {
        /* System config not found; write a new one. */
        NRF_LOG_INFO("Writing config file...");

        fds_record_t const rec =
        {
            .file_id           = CONFIG_FILE,
            .key               = CONFIG_REC_KEY,
            .data.p_data       = config2write,
            .data.length_words = (sizeof(DEVICE) + 3) / sizeof(uint32_t)
        };

  
        DEVICE * tmp = (DEVICE*)rec.data.p_data;
        NRF_LOG_INFO("Wrinting state value for the first time with value: %d .", tmp->state);

        rc = fds_record_write(&desc, &rec);
        APP_ERROR_CHECK(rc);
    }
}


int main(void)
{
    ret_code_t rc;

#ifdef SOFTDEVICE_PRESENT
    ble_stack_init();
#else
    clock_init();
#endif

    timer_init();
    log_init();
    cli_init();

    NRF_LOG_INFO("FDS example started.")

    /* Register first to receive an event when initialization is complete. */
    (void) fds_register(fds_evt_handler);

    NRF_LOG_INFO("Initializing fds...");

    rc = fds_init();
    APP_ERROR_CHECK(rc);

    /* Wait for fds to initialize. */
    wait_for_fds_ready();

    NRF_LOG_INFO("Available commands:");
    NRF_LOG_INFO("- print all\t\tprint records");
    NRF_LOG_INFO("- print config\tprint configuration");
    NRF_LOG_INFO("- update\t\tupdate configuration");
    NRF_LOG_INFO("- stat\t\tshow statistics");
    NRF_LOG_INFO("- write\t\twrite a new record");
    NRF_LOG_INFO("- delete\t\tdelete a record");
    NRF_LOG_INFO("- delete_all\tdelete all records");
    NRF_LOG_INFO("- gc\t\trun garbage collection");

    NRF_LOG_INFO("Reading flash usage statistics...");

    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);

    config2write.state = 1;
    config2write.adv2.enable = 12;
    config2write.adv2.time_adv = 13;


    flash_write_record_setup(&config2write);

    cli_start();

    /* Enter main loop. */
    for (;;)
    {
        if (!NRF_LOG_PROCESS())
        {
            power_manage();
        }
        cli_process();
        delete_all_process();
    }
}


/**
 * @}
 */

Basically, it seems like the code you sent me is working.

My guess is that your "config2write" variable is in the wrong scope. You have to keep this variable unchanged until you get the callback from FDS. I just use a static variable in my implementation above. If this does not resolve the issue for you, please compare my code above to your own and if you still can't find a cause feel free to send me a reply below, preferably with your full source code as a zip.

A final note: Since this is during initialization it's most likely not going to be a problem, but you open, close and read the record. You have to change the order so that you open, read and close it instead.

Best regards,
Rune Holmgren