src/adaptations/device-layer/nRF5/nRF5Config.cpp - third_party/openweave-core - Git at Google

 /*
  *
  *    Copyright (c) 2018 Nest Labs, Inc.
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 /**
  *    @file
  *          Utilities for accessing persisted device configuration on
  *          platforms based on the Nordic nRF5 SDK.
  */

 #include <atomic>

 #include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
 #include <Weave/DeviceLayer/nRF5/nRF5Config.h>
 #include <Weave/Core/WeaveEncoding.h>
 #include <Weave/DeviceLayer/internal/testing/ConfigUnitTest.h>

 #include "FreeRTOS.h"
 #include "semphr.h"

 #include "fds.h"
 #include "mem_manager.h"

 namespace nl {
 namespace Weave {
 namespace DeviceLayer {
 namespace Internal {

 NRF5Config::FDSAsyncOp * volatile NRF5Config::sActiveAsyncOp;
 SemaphoreHandle_t NRF5Config::sAsyncOpCompletionSem;

 WEAVE_ERROR NRF5Config::Init()
 {
     WEAVE_ERROR err;
     ret_code_t fdsRes;

     // Create a semaphore to signal the completion of async FDS operations.
     sAsyncOpCompletionSem = xSemaphoreCreateBinary();
     VerifyOrExit(sAsyncOpCompletionSem != NULL, err = WEAVE_ERROR_NO_MEMORY);

     // Register an FDS event handler.
     fdsRes = fds_register(HandleFDSEvent);
     SuccessOrExit(err = MapFDSError(fdsRes));

     // Initialize the FDS module.
     {
         FDSAsyncOp initOp(FDSAsyncOp::kInit);
         err = DoAsyncFDSOp(initOp);
         SuccessOrExit(err);
     }

 exit:
     return err;
 }

 WEAVE_ERROR NRF5Config::ReadConfigValue(Key key, bool & val)
 {
     WEAVE_ERROR err;
     fds_record_desc_t recDesc;
     fds_flash_record_t rec;
     uint32_t wordVal;
     bool needClose = false;

     err = OpenRecord(key, recDesc, rec);
     SuccessOrExit(err);
     needClose = true;

     VerifyOrExit(rec.p_header->length_words == 1, err = WEAVE_ERROR_INVALID_ARGUMENT);

     wordVal = Encoding::LittleEndian::Get32((const uint8_t *)rec.p_data);
     val = (wordVal != 0);

 exit:
     if (needClose)
     {
         fds_record_close(&recDesc);
     }
     return err;
 }

 WEAVE_ERROR NRF5Config::ReadConfigValue(Key key, uint32_t & val)
 {
     WEAVE_ERROR err;
     fds_record_desc_t recDesc;
     fds_flash_record_t rec;
     bool needClose = false;

     err = OpenRecord(key, recDesc, rec);
     SuccessOrExit(err);
     needClose = true;

     VerifyOrExit(rec.p_header->length_words == 1, err = WEAVE_ERROR_INVALID_ARGUMENT);

     val = Encoding::LittleEndian::Get32((const uint8_t *)rec.p_data);

 exit:
     if (needClose)
     {
         fds_record_close(&recDesc);
     }
     return err;
 }

 WEAVE_ERROR NRF5Config::ReadConfigValue(Key key, uint64_t & val)
 {
     WEAVE_ERROR err;
     fds_record_desc_t recDesc;
     fds_flash_record_t rec;
     bool needClose = false;

     err = OpenRecord(key, recDesc, rec);
     SuccessOrExit(err);
     needClose = true;

     VerifyOrExit(rec.p_header->length_words == 2, err = WEAVE_ERROR_INVALID_ARGUMENT);

     val = Encoding::LittleEndian::Get64((const uint8_t *)rec.p_data);

 exit:
     if (needClose)
     {
         fds_record_close(&recDesc);
     }
     return err;
 }

 WEAVE_ERROR NRF5Config::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen)
 {
     WEAVE_ERROR err;
     fds_flash_record_t rec;
     fds_record_desc_t recDesc;
     bool needClose = false;
     const uint8_t * strEnd;

     err = OpenRecord(key, recDesc, rec);
     SuccessOrExit(err);
     needClose = true;

     strEnd = (const uint8_t *)memchr(rec.p_data, 0, rec.p_header->length_words * kFDSWordSize);
     VerifyOrExit(strEnd != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

     outLen = strEnd - (const uint8_t *)rec.p_data;

     // NOTE: the caller is allowed to pass NULL for buf to query the length of the stored
     // value.

     if (buf != NULL)
     {
         VerifyOrExit(bufSize > outLen, err = WEAVE_ERROR_BUFFER_TOO_SMALL);

         memcpy(buf, rec.p_data, outLen + 1);
     }

 exit:
     if (needClose)
     {
         fds_record_close(&recDesc);
     }
     return err;
 }

 WEAVE_ERROR NRF5Config::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen)
 {
     WEAVE_ERROR err;
     fds_flash_record_t rec;
     fds_record_desc_t recDesc;
     bool needClose = false;

     err = OpenRecord(key, recDesc, rec);
     SuccessOrExit(err);
     needClose = true;

     VerifyOrExit(rec.p_header->length_words >= 1, err = WEAVE_ERROR_INVALID_ARGUMENT);

     // First two bytes are length.
     outLen = Encoding::LittleEndian::Get16((const uint8_t *)rec.p_data);

     VerifyOrExit((rec.p_header->length_words * kFDSWordSize) >= (outLen + 2), err = WEAVE_ERROR_INVALID_ARGUMENT);

     // NOTE: the caller is allowed to pass NULL for buf to query the length of the stored
     // value.

     if (buf != NULL)
     {
         VerifyOrExit(bufSize >= outLen, err = WEAVE_ERROR_BUFFER_TOO_SMALL);

         memcpy(buf, ((const uint8_t *)rec.p_data) + 2, outLen);
     }

 exit:
     if (needClose)
     {
         fds_record_close(&recDesc);
     }
     return err;
 }

 WEAVE_ERROR NRF5Config::WriteConfigValue(Key key, bool val)
 {
     WEAVE_ERROR err;
     uint32_t storedVal = (val) ? 1 : 0;

     FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
     addOrUpdateOp.FileId = GetFileId(key);
     addOrUpdateOp.RecordKey = GetRecordKey(key);
     addOrUpdateOp.RecordData = (const uint8_t *)&storedVal;
     addOrUpdateOp.RecordDataLengthWords = 1;

     err = DoAsyncFDSOp(addOrUpdateOp);
     SuccessOrExit(err);

     WeaveLogProgress(DeviceLayer, "FDS set: %04" PRIX16 "/%04" PRIX16 " = %s", GetFileId(key), GetRecordKey(key), val ? "true" : "false");

 exit:
     return err;
 }

 WEAVE_ERROR NRF5Config::WriteConfigValue(Key key, uint32_t val)
 {
     WEAVE_ERROR err;

     FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
     addOrUpdateOp.FileId = GetFileId(key);
     addOrUpdateOp.RecordKey = GetRecordKey(key);
     addOrUpdateOp.RecordData = (const uint8_t *)&val;
     addOrUpdateOp.RecordDataLengthWords = 1;

     err = DoAsyncFDSOp(addOrUpdateOp);
     SuccessOrExit(err);

     WeaveLogProgress(DeviceLayer, "FDS set: 0x%04" PRIX16 "/0x%04" PRIX16 " = %" PRIu32 " (0x%" PRIX32 ")", GetFileId(key), GetRecordKey(key), val, val);

 exit:
     return err;
 }

 WEAVE_ERROR NRF5Config::WriteConfigValue(Key key, uint64_t val)
 {
     WEAVE_ERROR err;

     FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
     addOrUpdateOp.FileId = GetFileId(key);
     addOrUpdateOp.RecordKey = GetRecordKey(key);
     addOrUpdateOp.RecordData = (const uint8_t *)&val;
     addOrUpdateOp.RecordDataLengthWords = 2;

     err = DoAsyncFDSOp(addOrUpdateOp);
     SuccessOrExit(err);

     WeaveLogProgress(DeviceLayer, "FDS set: 0x%04" PRIX16 "/0x%04" PRIX16 " = %" PRIu64 " (0x%" PRIX64 ")", GetFileId(key), GetRecordKey(key), val, val);

 exit:
     return err;
 }

 WEAVE_ERROR NRF5Config::WriteConfigValueStr(Key key, const char * str)
 {
     return WriteConfigValueStr(key, str, (str != NULL) ? strlen(str) : 0);
 }

 WEAVE_ERROR NRF5Config::WriteConfigValueStr(Key key, const char * str, size_t strLen)
 {
     WEAVE_ERROR err;
     uint8_t * storedVal = NULL;

     if (str != NULL)
     {
         uint32_t storedValWords = FDSWords(strLen + 1);

         storedVal = (uint8_t *)nrf_malloc(storedValWords * kFDSWordSize);
         VerifyOrExit(storedVal != NULL, err = WEAVE_ERROR_NO_MEMORY);

         memcpy(storedVal, str, strLen);
         storedVal[strLen] = 0;

         FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
         addOrUpdateOp.FileId = GetFileId(key);
         addOrUpdateOp.RecordKey = GetRecordKey(key);
         addOrUpdateOp.RecordData = storedVal;
         addOrUpdateOp.RecordDataLengthWords = storedValWords;

         err = DoAsyncFDSOp(addOrUpdateOp);
         SuccessOrExit(err);

         WeaveLogProgress(DeviceLayer, "FDS set: 0x%04" PRIX16 "/0x%04" PRIX16 " = \"%s\"", GetFileId(key), GetRecordKey(key), (const char *)storedVal);
     }

     else
     {
         err = ClearConfigValue(key);
         SuccessOrExit(err);
     }

 exit:
     if (storedVal != NULL)
     {
         nrf_free(storedVal);
     }
     return err;
 }

 WEAVE_ERROR NRF5Config::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen)
 {
     WEAVE_ERROR err;
     uint8_t * storedVal = NULL;

     if (data != NULL)
     {
         uint32_t storedValWords = FDSWords(dataLen + 2);

         storedVal = (uint8_t *)nrf_malloc(storedValWords * kFDSWordSize);
         VerifyOrExit(storedVal != NULL, err = WEAVE_ERROR_NO_MEMORY);

         // First two bytes encode the length.
         Encoding::LittleEndian::Put16(storedVal, (uint16_t)dataLen);

         memcpy(storedVal + 2, data, dataLen);

         FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
         addOrUpdateOp.FileId = GetFileId(key);
         addOrUpdateOp.RecordKey = GetRecordKey(key);
         addOrUpdateOp.RecordData = storedVal;
         addOrUpdateOp.RecordDataLengthWords = storedValWords;

         err = DoAsyncFDSOp(addOrUpdateOp);
         SuccessOrExit(err);

         WeaveLogProgress(DeviceLayer, "FDS set: 0x%04" PRIX16 "/0x%04" PRIX16 " = (blob length %" PRId32 ")", GetFileId(key), GetRecordKey(key), dataLen);
     }

     else
     {
         err = ClearConfigValue(key);
         SuccessOrExit(err);
     }

 exit:
     if (storedVal != NULL)
     {
         nrf_free(storedVal);
     }
     return err;
 }

 WEAVE_ERROR NRF5Config::ClearConfigValue(Key key)
 {
     WEAVE_ERROR err;

     FDSAsyncOp delOp(FDSAsyncOp::kDeleteRecordByKey);
     delOp.FileId = GetFileId(key);
     delOp.RecordKey = GetRecordKey(key);

     err = DoAsyncFDSOp(delOp);
     SuccessOrExit(err);

     WeaveLogProgress(DeviceLayer, "FDS delete: 0x%04" PRIX16 "/0x%04" PRIX16, GetFileId(key), GetRecordKey(key));

 exit:
     return err;
 }

 bool NRF5Config::ConfigValueExists(Key key)
 {
     ret_code_t fdsRes;
     fds_record_desc_t recDesc;
     fds_find_token_t findToken;

     // Search for the requested record.
     memset(&findToken, 0, sizeof(findToken));
     fdsRes = fds_record_find(GetFileId(key), GetRecordKey(key), &recDesc, &findToken);

     // Return true iff the record was found.
     return fdsRes == FDS_SUCCESS;
 }

 WEAVE_ERROR NRF5Config::FactoryResetConfig(void)
 {
     WEAVE_ERROR err;

     // Delete the WeaveConfig file and all records its contains.
     {
         FDSAsyncOp delOp(FDSAsyncOp::kDeleteFile);
         delOp.FileId = kFileId_WeaveConfig;
         err = DoAsyncFDSOp(delOp);
         SuccessOrExit(err);
         WeaveLogProgress(DeviceLayer, "FDS delete file: 0x%04" PRIX16, kFileId_WeaveConfig);
     }

     // Force a GC
     {
         FDSAsyncOp gcOp(FDSAsyncOp::kGC);
         err = DoAsyncFDSOp(gcOp);
         SuccessOrExit(err);
     }

 exit:
     return err;
 }

 WEAVE_ERROR NRF5Config::MapFDSError(ret_code_t fdsRes)
 {
     return (fdsRes == FDS_SUCCESS) ? WEAVE_NO_ERROR : WEAVE_DEVICE_CONFIG_NRF5_FDS_ERROR_MIN + fdsRes;
 }

 WEAVE_ERROR NRF5Config::OpenRecord(NRF5Config::Key key, fds_record_desc_t & recDesc, fds_flash_record_t & rec)
 {
     WEAVE_ERROR err;
     ret_code_t fdsRes;
     fds_find_token_t findToken;

     // Search for the requested record.  Return "CONFIG_NOT_FOUND" if it doesn't exist.
     memset(&findToken, 0, sizeof(findToken));
     fdsRes = fds_record_find(NRF5Config::GetFileId(key), NRF5Config::GetRecordKey(key), &recDesc, &findToken);
     err = (fdsRes == FDS_ERR_NOT_FOUND) ? WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND : MapFDSError(fdsRes);
     SuccessOrExit(err);

     // Open the record for reading.
     fdsRes = fds_record_open(&recDesc, &rec);
     err = MapFDSError(fdsRes);
     SuccessOrExit(err);

 exit:
     return err;
 }

 WEAVE_ERROR NRF5Config::ForEachRecord(uint16_t fileId, uint16_t recordKey, ForEachRecordFunct funct)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;;
     ret_code_t fdsRes;
     fds_find_token_t findToken;
     fds_record_desc_t recDesc;
     fds_flash_record_t rec;
     bool needClose = false;

     memset(&findToken, 0, sizeof(findToken));

     while (true)
     {
         // Search for an occurrence of the requested record.  If there are no more records, break the loop.
         fdsRes = fds_record_find(fileId, recordKey, &recDesc, &findToken);
         if (fdsRes == FDS_ERR_NOT_FOUND)
         {
             break;
         }
         err = MapFDSError(fdsRes);
         SuccessOrExit(err);

         // Open the record for reading.
         fdsRes = fds_record_open(&recDesc, &rec);
         err = MapFDSError(fdsRes);
         SuccessOrExit(err);
         needClose = true;

         bool deleteRec = false;

         // Invoke the caller's function.
         err = funct(rec, deleteRec);
         SuccessOrExit(err);

         // Close the record.
         needClose = false;
         fdsRes = fds_record_close(&recDesc);
         err = MapFDSError(fdsRes);
         SuccessOrExit(err);

         // Delete the record if requested.
         if (deleteRec)
         {
             FDSAsyncOp delOp(FDSAsyncOp::kDeleteRecord);
             delOp.FileId = fileId;
             delOp.RecordKey = recordKey;
             delOp.RecordDesc = recDesc;
             err = DoAsyncFDSOp(delOp);
             SuccessOrExit(err);
         }
     }

 exit:
     if (needClose)
     {
         fds_record_close(&recDesc);
     }
     return err;
 }

 WEAVE_ERROR NRF5Config::DoAsyncFDSOp(FDSAsyncOp & asyncOp)
 {
     WEAVE_ERROR err;
     ret_code_t fdsRes;
     fds_record_t rec;
     bool gcPerformed = false;

     // Keep trying to perform the requested op until there's a definitive success or failure...
     while (true)
     {
         bool existingRecFound = false;

         // If performing an AddOrUpdateRecord or DeleteRecordByKey, search for an existing record with the given key.
         if (asyncOp.OpType == FDSAsyncOp::kAddOrUpdateRecord || asyncOp.OpType == FDSAsyncOp::kDeleteRecordByKey)
         {
             fds_find_token_t findToken;
             memset(&findToken, 0, sizeof(findToken));
             fdsRes = fds_record_find(asyncOp.FileId, asyncOp.RecordKey, &asyncOp.RecordDesc, &findToken);
             VerifyOrExit(fdsRes == FDS_SUCCESS || fdsRes == FDS_ERR_NOT_FOUND, err = MapFDSError(fdsRes));

             // Remember if we found an existing record.
             existingRecFound = (fdsRes == FDS_SUCCESS);
         }

         // If adding or updating a record, prepare the FDS record structure with the record data.
         if (asyncOp.OpType == FDSAsyncOp::kAddRecord ||
             asyncOp.OpType == FDSAsyncOp::kUpdateRecord ||
             asyncOp.OpType == FDSAsyncOp::kAddOrUpdateRecord)
         {
             memset(&rec, 0, sizeof(rec));
             rec.file_id = asyncOp.FileId;
             rec.key = asyncOp.RecordKey;
             rec.data.p_data = asyncOp.RecordData;
             rec.data.length_words = asyncOp.RecordDataLengthWords;
         }

         // Make the requested op the active op.
         sActiveAsyncOp = &asyncOp;

         // Initiate the requested FDS operation.
         switch (asyncOp.OpType)
         {
         case FDSAsyncOp::kInit:
             fdsRes = fds_init();
             break;
         case FDSAsyncOp::kAddOrUpdateRecord:
             // Depending on whether an existing record was found, call fds_record_write or fds_record_update.
             if (!existingRecFound)
             {
         case FDSAsyncOp::kAddRecord:
                 fdsRes = fds_record_write(NULL, &rec);
                 break;
             }
             else
             {
         case FDSAsyncOp::kUpdateRecord:
                 fdsRes = fds_record_update(&asyncOp.RecordDesc, &rec);
                 break;
             }
         case FDSAsyncOp::kDeleteRecordByKey:
             // If performing a kDeleteRecordByKey and no matching record was found, simply return success.
             if (!existingRecFound)
             {
                 ExitNow(err = WEAVE_NO_ERROR);
             }
             // fall through...
         case FDSAsyncOp::kDeleteRecord:
             fdsRes = fds_record_delete(&asyncOp.RecordDesc);
             break;
         case FDSAsyncOp::kDeleteFile:
             fdsRes = fds_file_delete(asyncOp.FileId);
             break;
         case FDSAsyncOp::kGC:
             fdsRes = fds_gc();
             break;
         case FDSAsyncOp::kWaitQueueSpaceAvailable:
             // In this case, arrange to wait for any operation to complete, which coincides with
             // space on the operation queue being available.
             fdsRes = FDS_SUCCESS;
             break;
         default:
             WeaveDie();
         }

         // If the operation was queued successfully, wait for it to complete and retrieve the result.
         // If the FreeRTOS scheduler is not running, poll the completion semaphore; otherwise wait
         // indefinitely.
         //
         if (fdsRes == FDS_SUCCESS)
         {
             if (xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED)
             {
                 while (xSemaphoreTake(sAsyncOpCompletionSem, 0) == pdFALSE)
                     ;
             }
             else
             {
                 xSemaphoreTake(sAsyncOpCompletionSem, portMAX_DELAY);
             }

             fdsRes = asyncOp.Result;
         }

         // Clear the active operation in case it wasn't done by the event handler.
         sActiveAsyncOp = NULL;

         // Return immediately if the operation completed successfully.
         if (fdsRes == FDS_SUCCESS)
         {
             ExitNow(err = WEAVE_NO_ERROR);
         }

         // If the operation failed for lack of flash space...
         if (fdsRes == FDS_ERR_NO_SPACE_IN_FLASH)
         {
             // If we've already performed a garbage collection, fail immediately.
             if (gcPerformed)
             {
                 ExitNow(err = MapFDSError(fdsRes));
             }

             WeaveLogProgress(DeviceLayer, "Initiating FDS GC to recover space");

             // Request a garbage collection cycle and wait for it to complete.
             FDSAsyncOp gcOp(FDSAsyncOp::kGC);
             err = DoAsyncFDSOp(gcOp);
             SuccessOrExit(err);

             // Repeat the requested operation.
             continue;
         }

         // If the write/update failed because the operation queue is full, wait for
         // space to become available and then repeat the requested operation.
         if (fdsRes == FDS_ERR_NO_SPACE_IN_QUEUES)
         {
             FDSAsyncOp waitOp(FDSAsyncOp::kWaitQueueSpaceAvailable);
             err = DoAsyncFDSOp(waitOp);
             SuccessOrExit(err);
             continue;
         }

         // If the operation timed out, simply try it again.
         if (fdsRes == FDS_ERR_OPERATION_TIMEOUT)
         {
             continue;
         }

         // Otherwise fail with an unrecoverable error.
         ExitNow(err = MapFDSError(fdsRes));
     }

 exit:
     return err;
 }

 void NRF5Config::HandleFDSEvent(const fds_evt_t * fdsEvent)
 {
     // Do nothing if there's no async operation active.
     if (sActiveAsyncOp == NULL)
     {
         return;
     }

     // Check if the event applies to the active async operation.
     switch (sActiveAsyncOp->OpType)
     {
     case FDSAsyncOp::kInit:
         if (fdsEvent->id != FDS_EVT_INIT)
         {
             return;
         }
         break;
     case FDSAsyncOp::kAddOrUpdateRecord:
     case FDSAsyncOp::kAddRecord:
     case FDSAsyncOp::kUpdateRecord:
         // Ignore the event if its not a WRITE or UPDATE, or if its for a different file/record.
         if ((fdsEvent->id != FDS_EVT_WRITE && fdsEvent->id != FDS_EVT_UPDATE) ||
             fdsEvent->write.file_id != sActiveAsyncOp->FileId ||
             fdsEvent->write.record_key != sActiveAsyncOp->RecordKey)
         {
             return;
         }
         break;
     case FDSAsyncOp::kDeleteRecord:
     case FDSAsyncOp::kDeleteRecordByKey:
         // Ignore the event if its not a DEL_RECORD, or if its for a different file/record.
         if (fdsEvent->id != FDS_EVT_DEL_RECORD ||
             fdsEvent->del.record_id != sActiveAsyncOp->RecordDesc.record_id)
         {
             return;
         }
         break;
     case FDSAsyncOp::kDeleteFile:
         // Ignore the event if its not a DEL_FILE or its for a different file.
         if (fdsEvent->id != FDS_EVT_DEL_FILE || fdsEvent->del.file_id != sActiveAsyncOp->FileId)
         {
             return;
         }
         break;
     case FDSAsyncOp::kGC:
         // Ignore the event if its not a GC.
         if (fdsEvent->id != FDS_EVT_GC)
         {
             return;
         }
         break;
     case FDSAsyncOp::kWaitQueueSpaceAvailable:
         break;
     }

     // Capture the result.
     sActiveAsyncOp->Result = fdsEvent->result;

     // Mark the operation as complete.
     sActiveAsyncOp = NULL;

     // Signal the Weave thread that the operation has completed.
 #if defined(SOFTDEVICE_PRESENT) && SOFTDEVICE_PRESENT

     // When using the Nodic SoftDevice, HandleFDSEvent() is called in a SoftDevice interrupt
     // context.  Therefore, we must use xSemaphoreGiveFromISR() to signal completion.
     BaseType_t yieldRequired = xSemaphoreGiveFromISR(sAsyncOpCompletionSem, &yieldRequired);

     // Yield to the next runnable task, but only if the FreeRTOS scheduler has been started.
     if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED && yieldRequired == pdTRUE)
     {
         portYIELD_FROM_ISR(yieldRequired);
     }

 #else // defined(SOFTDEVICE_PRESENT) || !SOFTDEVICE_PRESENT

     // When NOT using the Nodic SoftDevice, HandleFDSEvent() is called in a non-interrupt
     // context. Therefore, use xSemaphoreGive() to signal completion.
     xSemaphoreGive(sAsyncOpCompletionSem);

 #endif // !(defined(SOFTDEVICE_PRESENT) || !SOFTDEVICE_PRESENT)
 }

 void NRF5Config::RunConfigUnitTest()
 {
     WEAVE_ERROR err;

     // Run common unit test
     ::nl::Weave::DeviceLayer::Internal::RunConfigUnitTest<NRF5Config>();

     // NRF Config Test 1 -- Force GC
     {
         const static uint8_t kTestData[] =
         {
             0xD5, 0x00, 0x00, 0x04, 0x00, 0x01, 0x00, 0x30, 0x01, 0x08, 0x79, 0x55, 0x9F, 0x15, 0x1F, 0x66,
             0x3D, 0x8F, 0x24, 0x02, 0x05, 0x37, 0x03, 0x27, 0x13, 0x02, 0x00, 0x00, 0xEE, 0xEE, 0x30, 0xB4,
             0x18, 0x18, 0x26, 0x04, 0x80, 0x41, 0x1B, 0x23, 0x26, 0x05, 0x7F, 0xFF, 0xFF, 0x52, 0x37, 0x06,
             0x27, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xB4, 0x18, 0x18, 0x24, 0x07, 0x02, 0x26, 0x08,
             0x25, 0x00, 0x5A, 0x23, 0x30, 0x0A, 0x39, 0x04, 0x9E, 0xC7, 0x77, 0xC5, 0xA4, 0x13, 0x31, 0xF7,
             0x72, 0x2E, 0x27, 0xC2, 0x86, 0x3D, 0xC5, 0x2E, 0xD5, 0xD2, 0x3C, 0xCF, 0x7E, 0x06, 0xE3, 0x48,
             0x53, 0x87, 0xE8, 0x4D, 0xB0, 0x27, 0x07, 0x58, 0x4A, 0x38, 0xB4, 0xF3, 0xB2, 0x47, 0x94, 0x45,
             0x58, 0x65, 0x80, 0x08, 0x17, 0x6B, 0x8E, 0x4F, 0x07, 0x41, 0xA3, 0x3D, 0x5D, 0xCE, 0x76, 0x86,
             0x35, 0x83, 0x29, 0x01, 0x18, 0x35, 0x82, 0x29, 0x01, 0x24, 0x02, 0x05, 0x18, 0x35, 0x84, 0x29,
             0x01, 0x36, 0x02, 0x04, 0x02, 0x04, 0x01, 0x18, 0x18, 0x35, 0x81, 0x30, 0x02, 0x08, 0x42, 0xBD,
             0x2C, 0x6B, 0x5B, 0x3A, 0x18, 0x16, 0x18, 0x35, 0x80, 0x30, 0x02, 0x08, 0x44, 0xE3, 0x40, 0x38,
             0xA9, 0xD4, 0xB5, 0xA7, 0x18, 0x35, 0x0C, 0x30, 0x01, 0x19, 0x00, 0xA6, 0x5D, 0x54, 0xF5, 0xAE,
             0x5D, 0x63, 0xEB, 0x69, 0xD8, 0xDB, 0xCB, 0xE2, 0x20, 0x0C, 0xD5, 0x6F, 0x43, 0x5E, 0x96, 0xA8,
             0x54, 0xB2, 0x74, 0x30, 0x02, 0x19, 0x00, 0xE0, 0x37, 0x02, 0x8B, 0xB3, 0x04, 0x06, 0xDD, 0xBD,
             0x28, 0xAA, 0xC4, 0xF1, 0xFF, 0xFB, 0xB1, 0xD4, 0x1C, 0x78, 0x40, 0xDA, 0x2C, 0xD8, 0x40, 0x18,
             0x18,
         };
         uint8_t buf[512];
         size_t dataLen;

         for (int i = 0; i < 100; i++)
         {
             err = WriteConfigValueBin(kConfigKey_ManufAttestDeviceCert, kTestData, sizeof(kTestData));
             VerifyOrDie(err == WEAVE_NO_ERROR);

             vTaskDelay(pdMS_TO_TICKS(50));
         }

         err = ReadConfigValueBin(kConfigKey_ManufAttestDeviceCert, buf, sizeof(buf), dataLen);
         VerifyOrDie(err == WEAVE_NO_ERROR);

         VerifyOrDie(dataLen == sizeof(kTestData));
         VerifyOrDie(memcmp(buf, kTestData, dataLen) == 0);
     }
 }


 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace Weave
 } // namespace nl
	/*
	*
	* Copyright (c) 2018 Nest Labs, Inc.
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @file
	* Utilities for accessing persisted device configuration on
	* platforms based on the Nordic nRF5 SDK.
	*/

	#include <atomic>

	#include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
	#include <Weave/DeviceLayer/nRF5/nRF5Config.h>
	#include <Weave/Core/WeaveEncoding.h>
	#include <Weave/DeviceLayer/internal/testing/ConfigUnitTest.h>

	#include "FreeRTOS.h"
	#include "semphr.h"

	#include "fds.h"
	#include "mem_manager.h"

	namespace nl {
	namespace Weave {
	namespace DeviceLayer {
	namespace Internal {

	NRF5Config::FDSAsyncOp * volatile NRF5Config::sActiveAsyncOp;
	SemaphoreHandle_t NRF5Config::sAsyncOpCompletionSem;

	WEAVE_ERROR NRF5Config::Init()
	{
	WEAVE_ERROR err;
	ret_code_t fdsRes;

	// Create a semaphore to signal the completion of async FDS operations.
	sAsyncOpCompletionSem = xSemaphoreCreateBinary();
	VerifyOrExit(sAsyncOpCompletionSem != NULL, err = WEAVE_ERROR_NO_MEMORY);

	// Register an FDS event handler.
	fdsRes = fds_register(HandleFDSEvent);
	SuccessOrExit(err = MapFDSError(fdsRes));

	// Initialize the FDS module.
	{
	FDSAsyncOp initOp(FDSAsyncOp::kInit);
	err = DoAsyncFDSOp(initOp);
	SuccessOrExit(err);
	}

	exit:
	return err;
	}

	WEAVE_ERROR NRF5Config::ReadConfigValue(Key key, bool & val)
	{
	WEAVE_ERROR err;
	fds_record_desc_t recDesc;
	fds_flash_record_t rec;
	uint32_t wordVal;
	bool needClose = false;

	err = OpenRecord(key, recDesc, rec);
	SuccessOrExit(err);
	needClose = true;

	VerifyOrExit(rec.p_header->length_words == 1, err = WEAVE_ERROR_INVALID_ARGUMENT);

	wordVal = Encoding::LittleEndian::Get32((const uint8_t *)rec.p_data);
	val = (wordVal != 0);

	exit:
	if (needClose)
	{
	fds_record_close(&recDesc);
	}
	return err;
	}

	WEAVE_ERROR NRF5Config::ReadConfigValue(Key key, uint32_t & val)
	{
	WEAVE_ERROR err;
	fds_record_desc_t recDesc;
	fds_flash_record_t rec;
	bool needClose = false;

	err = OpenRecord(key, recDesc, rec);
	SuccessOrExit(err);
	needClose = true;

	VerifyOrExit(rec.p_header->length_words == 1, err = WEAVE_ERROR_INVALID_ARGUMENT);

	val = Encoding::LittleEndian::Get32((const uint8_t *)rec.p_data);

	exit:
	if (needClose)
	{
	fds_record_close(&recDesc);
	}
	return err;
	}

	WEAVE_ERROR NRF5Config::ReadConfigValue(Key key, uint64_t & val)
	{
	WEAVE_ERROR err;
	fds_record_desc_t recDesc;
	fds_flash_record_t rec;
	bool needClose = false;

	err = OpenRecord(key, recDesc, rec);
	SuccessOrExit(err);
	needClose = true;

	VerifyOrExit(rec.p_header->length_words == 2, err = WEAVE_ERROR_INVALID_ARGUMENT);

	val = Encoding::LittleEndian::Get64((const uint8_t *)rec.p_data);

	exit:
	if (needClose)
	{
	fds_record_close(&recDesc);
	}
	return err;
	}

	WEAVE_ERROR NRF5Config::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen)
	{
	WEAVE_ERROR err;
	fds_flash_record_t rec;
	fds_record_desc_t recDesc;
	bool needClose = false;
	const uint8_t * strEnd;

	err = OpenRecord(key, recDesc, rec);
	SuccessOrExit(err);
	needClose = true;

	strEnd = (const uint8_t )memchr(rec.p_data, 0, rec.p_header->length_words kFDSWordSize);
	VerifyOrExit(strEnd != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

	outLen = strEnd - (const uint8_t *)rec.p_data;

	// NOTE: the caller is allowed to pass NULL for buf to query the length of the stored
	// value.

	if (buf != NULL)
	{
	VerifyOrExit(bufSize > outLen, err = WEAVE_ERROR_BUFFER_TOO_SMALL);

	memcpy(buf, rec.p_data, outLen + 1);
	}

	exit:
	if (needClose)
	{
	fds_record_close(&recDesc);
	}
	return err;
	}

	WEAVE_ERROR NRF5Config::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen)
	{
	WEAVE_ERROR err;
	fds_flash_record_t rec;
	fds_record_desc_t recDesc;
	bool needClose = false;

	err = OpenRecord(key, recDesc, rec);
	SuccessOrExit(err);
	needClose = true;

	VerifyOrExit(rec.p_header->length_words >= 1, err = WEAVE_ERROR_INVALID_ARGUMENT);

	// First two bytes are length.
	outLen = Encoding::LittleEndian::Get16((const uint8_t *)rec.p_data);

	VerifyOrExit((rec.p_header->length_words * kFDSWordSize) >= (outLen + 2), err = WEAVE_ERROR_INVALID_ARGUMENT);

	// NOTE: the caller is allowed to pass NULL for buf to query the length of the stored
	// value.

	if (buf != NULL)
	{
	VerifyOrExit(bufSize >= outLen, err = WEAVE_ERROR_BUFFER_TOO_SMALL);

	memcpy(buf, ((const uint8_t *)rec.p_data) + 2, outLen);
	}

	exit:
	if (needClose)
	{
	fds_record_close(&recDesc);
	}
	return err;
	}

	WEAVE_ERROR NRF5Config::WriteConfigValue(Key key, bool val)
	{
	WEAVE_ERROR err;
	uint32_t storedVal = (val) ? 1 : 0;

	FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
	addOrUpdateOp.FileId = GetFileId(key);
	addOrUpdateOp.RecordKey = GetRecordKey(key);
	addOrUpdateOp.RecordData = (const uint8_t *)&storedVal;
	addOrUpdateOp.RecordDataLengthWords = 1;

	err = DoAsyncFDSOp(addOrUpdateOp);
	SuccessOrExit(err);

	WeaveLogProgress(DeviceLayer, "FDS set: %04" PRIX16 "/%04" PRIX16 " = %s", GetFileId(key), GetRecordKey(key), val ? "true" : "false");

	exit:
	return err;
	}

	WEAVE_ERROR NRF5Config::WriteConfigValue(Key key, uint32_t val)
	{
	WEAVE_ERROR err;

	FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
	addOrUpdateOp.FileId = GetFileId(key);
	addOrUpdateOp.RecordKey = GetRecordKey(key);
	addOrUpdateOp.RecordData = (const uint8_t *)&val;
	addOrUpdateOp.RecordDataLengthWords = 1;

	err = DoAsyncFDSOp(addOrUpdateOp);
	SuccessOrExit(err);

	WeaveLogProgress(DeviceLayer, "FDS set: 0x%04" PRIX16 "/0x%04" PRIX16 " = %" PRIu32 " (0x%" PRIX32 ")", GetFileId(key), GetRecordKey(key), val, val);

	exit:
	return err;
	}

	WEAVE_ERROR NRF5Config::WriteConfigValue(Key key, uint64_t val)
	{
	WEAVE_ERROR err;

	FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
	addOrUpdateOp.FileId = GetFileId(key);
	addOrUpdateOp.RecordKey = GetRecordKey(key);
	addOrUpdateOp.RecordData = (const uint8_t *)&val;
	addOrUpdateOp.RecordDataLengthWords = 2;

	err = DoAsyncFDSOp(addOrUpdateOp);
	SuccessOrExit(err);

	WeaveLogProgress(DeviceLayer, "FDS set: 0x%04" PRIX16 "/0x%04" PRIX16 " = %" PRIu64 " (0x%" PRIX64 ")", GetFileId(key), GetRecordKey(key), val, val);

	exit:
	return err;
	}

	WEAVE_ERROR NRF5Config::WriteConfigValueStr(Key key, const char * str)
	{
	return WriteConfigValueStr(key, str, (str != NULL) ? strlen(str) : 0);
	}

	WEAVE_ERROR NRF5Config::WriteConfigValueStr(Key key, const char * str, size_t strLen)
	{
	WEAVE_ERROR err;
	uint8_t * storedVal = NULL;

	if (str != NULL)
	{
	uint32_t storedValWords = FDSWords(strLen + 1);

	storedVal = (uint8_t )nrf_malloc(storedValWords kFDSWordSize);
	VerifyOrExit(storedVal != NULL, err = WEAVE_ERROR_NO_MEMORY);

	memcpy(storedVal, str, strLen);
	storedVal[strLen] = 0;

	FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
	addOrUpdateOp.FileId = GetFileId(key);
	addOrUpdateOp.RecordKey = GetRecordKey(key);
	addOrUpdateOp.RecordData = storedVal;
	addOrUpdateOp.RecordDataLengthWords = storedValWords;

	err = DoAsyncFDSOp(addOrUpdateOp);
	SuccessOrExit(err);

	WeaveLogProgress(DeviceLayer, "FDS set: 0x%04" PRIX16 "/0x%04" PRIX16 " = \"%s\"", GetFileId(key), GetRecordKey(key), (const char *)storedVal);
	}

	else
	{
	err = ClearConfigValue(key);
	SuccessOrExit(err);
	}

	exit:
	if (storedVal != NULL)
	{
	nrf_free(storedVal);
	}
	return err;
	}

	WEAVE_ERROR NRF5Config::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen)
	{
	WEAVE_ERROR err;
	uint8_t * storedVal = NULL;

	if (data != NULL)
	{
	uint32_t storedValWords = FDSWords(dataLen + 2);

	storedVal = (uint8_t )nrf_malloc(storedValWords kFDSWordSize);
	VerifyOrExit(storedVal != NULL, err = WEAVE_ERROR_NO_MEMORY);

	// First two bytes encode the length.
	Encoding::LittleEndian::Put16(storedVal, (uint16_t)dataLen);

	memcpy(storedVal + 2, data, dataLen);

	FDSAsyncOp addOrUpdateOp(FDSAsyncOp::kAddOrUpdateRecord);
	addOrUpdateOp.FileId = GetFileId(key);
	addOrUpdateOp.RecordKey = GetRecordKey(key);
	addOrUpdateOp.RecordData = storedVal;
	addOrUpdateOp.RecordDataLengthWords = storedValWords;

	err = DoAsyncFDSOp(addOrUpdateOp);
	SuccessOrExit(err);

	WeaveLogProgress(DeviceLayer, "FDS set: 0x%04" PRIX16 "/0x%04" PRIX16 " = (blob length %" PRId32 ")", GetFileId(key), GetRecordKey(key), dataLen);
	}

	else
	{
	err = ClearConfigValue(key);
	SuccessOrExit(err);
	}

	exit:
	if (storedVal != NULL)
	{
	nrf_free(storedVal);
	}
	return err;
	}

	WEAVE_ERROR NRF5Config::ClearConfigValue(Key key)
	{
	WEAVE_ERROR err;

	FDSAsyncOp delOp(FDSAsyncOp::kDeleteRecordByKey);
	delOp.FileId = GetFileId(key);
	delOp.RecordKey = GetRecordKey(key);

	err = DoAsyncFDSOp(delOp);
	SuccessOrExit(err);

	WeaveLogProgress(DeviceLayer, "FDS delete: 0x%04" PRIX16 "/0x%04" PRIX16, GetFileId(key), GetRecordKey(key));

	exit:
	return err;
	}

	bool NRF5Config::ConfigValueExists(Key key)
	{
	ret_code_t fdsRes;
	fds_record_desc_t recDesc;
	fds_find_token_t findToken;

	// Search for the requested record.
	memset(&findToken, 0, sizeof(findToken));
	fdsRes = fds_record_find(GetFileId(key), GetRecordKey(key), &recDesc, &findToken);

	// Return true iff the record was found.
	return fdsRes == FDS_SUCCESS;
	}

	WEAVE_ERROR NRF5Config::FactoryResetConfig(void)
	{
	WEAVE_ERROR err;

	// Delete the WeaveConfig file and all records its contains.
	{
	FDSAsyncOp delOp(FDSAsyncOp::kDeleteFile);
	delOp.FileId = kFileId_WeaveConfig;
	err = DoAsyncFDSOp(delOp);
	SuccessOrExit(err);
	WeaveLogProgress(DeviceLayer, "FDS delete file: 0x%04" PRIX16, kFileId_WeaveConfig);
	}

	// Force a GC
	{
	FDSAsyncOp gcOp(FDSAsyncOp::kGC);
	err = DoAsyncFDSOp(gcOp);
	SuccessOrExit(err);
	}

	exit:
	return err;
	}

	WEAVE_ERROR NRF5Config::MapFDSError(ret_code_t fdsRes)
	{
	return (fdsRes == FDS_SUCCESS) ? WEAVE_NO_ERROR : WEAVE_DEVICE_CONFIG_NRF5_FDS_ERROR_MIN + fdsRes;
	}

	WEAVE_ERROR NRF5Config::OpenRecord(NRF5Config::Key key, fds_record_desc_t & recDesc, fds_flash_record_t & rec)
	{
	WEAVE_ERROR err;
	ret_code_t fdsRes;
	fds_find_token_t findToken;

	// Search for the requested record. Return "CONFIG_NOT_FOUND" if it doesn't exist.
	memset(&findToken, 0, sizeof(findToken));
	fdsRes = fds_record_find(NRF5Config::GetFileId(key), NRF5Config::GetRecordKey(key), &recDesc, &findToken);
	err = (fdsRes == FDS_ERR_NOT_FOUND) ? WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND : MapFDSError(fdsRes);
	SuccessOrExit(err);

	// Open the record for reading.
	fdsRes = fds_record_open(&recDesc, &rec);
	err = MapFDSError(fdsRes);
	SuccessOrExit(err);

	exit:
	return err;
	}

	WEAVE_ERROR NRF5Config::ForEachRecord(uint16_t fileId, uint16_t recordKey, ForEachRecordFunct funct)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;;
	ret_code_t fdsRes;
	fds_find_token_t findToken;
	fds_record_desc_t recDesc;
	fds_flash_record_t rec;
	bool needClose = false;

	memset(&findToken, 0, sizeof(findToken));

	while (true)
	{
	// Search for an occurrence of the requested record. If there are no more records, break the loop.
	fdsRes = fds_record_find(fileId, recordKey, &recDesc, &findToken);
	if (fdsRes == FDS_ERR_NOT_FOUND)
	{
	break;
	}
	err = MapFDSError(fdsRes);
	SuccessOrExit(err);

	// Open the record for reading.
	fdsRes = fds_record_open(&recDesc, &rec);
	err = MapFDSError(fdsRes);
	SuccessOrExit(err);
	needClose = true;

	bool deleteRec = false;

	// Invoke the caller's function.
	err = funct(rec, deleteRec);
	SuccessOrExit(err);

	// Close the record.
	needClose = false;
	fdsRes = fds_record_close(&recDesc);
	err = MapFDSError(fdsRes);
	SuccessOrExit(err);

	// Delete the record if requested.
	if (deleteRec)
	{
	FDSAsyncOp delOp(FDSAsyncOp::kDeleteRecord);
	delOp.FileId = fileId;
	delOp.RecordKey = recordKey;
	delOp.RecordDesc = recDesc;
	err = DoAsyncFDSOp(delOp);
	SuccessOrExit(err);
	}
	}

	exit:
	if (needClose)
	{
	fds_record_close(&recDesc);
	}
	return err;
	}

	WEAVE_ERROR NRF5Config::DoAsyncFDSOp(FDSAsyncOp & asyncOp)
	{
	WEAVE_ERROR err;
	ret_code_t fdsRes;
	fds_record_t rec;
	bool gcPerformed = false;

	// Keep trying to perform the requested op until there's a definitive success or failure...
	while (true)
	{
	bool existingRecFound = false;

	// If performing an AddOrUpdateRecord or DeleteRecordByKey, search for an existing record with the given key.
	if (asyncOp.OpType == FDSAsyncOp::kAddOrUpdateRecord \|\| asyncOp.OpType == FDSAsyncOp::kDeleteRecordByKey)
	{
	fds_find_token_t findToken;
	memset(&findToken, 0, sizeof(findToken));
	fdsRes = fds_record_find(asyncOp.FileId, asyncOp.RecordKey, &asyncOp.RecordDesc, &findToken);
	VerifyOrExit(fdsRes == FDS_SUCCESS \|\| fdsRes == FDS_ERR_NOT_FOUND, err = MapFDSError(fdsRes));

	// Remember if we found an existing record.
	existingRecFound = (fdsRes == FDS_SUCCESS);
	}

	// If adding or updating a record, prepare the FDS record structure with the record data.
	if (asyncOp.OpType == FDSAsyncOp::kAddRecord \|\|
	asyncOp.OpType == FDSAsyncOp::kUpdateRecord \|\|
	asyncOp.OpType == FDSAsyncOp::kAddOrUpdateRecord)
	{
	memset(&rec, 0, sizeof(rec));
	rec.file_id = asyncOp.FileId;
	rec.key = asyncOp.RecordKey;
	rec.data.p_data = asyncOp.RecordData;
	rec.data.length_words = asyncOp.RecordDataLengthWords;
	}

	// Make the requested op the active op.
	sActiveAsyncOp = &asyncOp;

	// Initiate the requested FDS operation.
	switch (asyncOp.OpType)
	{
	case FDSAsyncOp::kInit:
	fdsRes = fds_init();
	break;
	case FDSAsyncOp::kAddOrUpdateRecord:
	// Depending on whether an existing record was found, call fds_record_write or fds_record_update.
	if (!existingRecFound)
	{
	case FDSAsyncOp::kAddRecord:
	fdsRes = fds_record_write(NULL, &rec);
	break;
	}
	else
	{
	case FDSAsyncOp::kUpdateRecord:
	fdsRes = fds_record_update(&asyncOp.RecordDesc, &rec);
	break;
	}
	case FDSAsyncOp::kDeleteRecordByKey:
	// If performing a kDeleteRecordByKey and no matching record was found, simply return success.
	if (!existingRecFound)
	{
	ExitNow(err = WEAVE_NO_ERROR);
	}
	// fall through...
	case FDSAsyncOp::kDeleteRecord:
	fdsRes = fds_record_delete(&asyncOp.RecordDesc);
	break;
	case FDSAsyncOp::kDeleteFile:
	fdsRes = fds_file_delete(asyncOp.FileId);
	break;
	case FDSAsyncOp::kGC:
	fdsRes = fds_gc();
	break;
	case FDSAsyncOp::kWaitQueueSpaceAvailable:
	// In this case, arrange to wait for any operation to complete, which coincides with
	// space on the operation queue being available.
	fdsRes = FDS_SUCCESS;
	break;
	default:
	WeaveDie();
	}

	// If the operation was queued successfully, wait for it to complete and retrieve the result.
	// If the FreeRTOS scheduler is not running, poll the completion semaphore; otherwise wait
	// indefinitely.
	//
	if (fdsRes == FDS_SUCCESS)
	{
	if (xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED)
	{
	while (xSemaphoreTake(sAsyncOpCompletionSem, 0) == pdFALSE)
	;
	}
	else
	{
	xSemaphoreTake(sAsyncOpCompletionSem, portMAX_DELAY);
	}

	fdsRes = asyncOp.Result;
	}

	// Clear the active operation in case it wasn't done by the event handler.
	sActiveAsyncOp = NULL;

	// Return immediately if the operation completed successfully.
	if (fdsRes == FDS_SUCCESS)
	{
	ExitNow(err = WEAVE_NO_ERROR);
	}

	// If the operation failed for lack of flash space...
	if (fdsRes == FDS_ERR_NO_SPACE_IN_FLASH)
	{
	// If we've already performed a garbage collection, fail immediately.
	if (gcPerformed)
	{
	ExitNow(err = MapFDSError(fdsRes));
	}

	WeaveLogProgress(DeviceLayer, "Initiating FDS GC to recover space");

	// Request a garbage collection cycle and wait for it to complete.
	FDSAsyncOp gcOp(FDSAsyncOp::kGC);
	err = DoAsyncFDSOp(gcOp);
	SuccessOrExit(err);

	// Repeat the requested operation.
	continue;
	}

	// If the write/update failed because the operation queue is full, wait for
	// space to become available and then repeat the requested operation.
	if (fdsRes == FDS_ERR_NO_SPACE_IN_QUEUES)
	{
	FDSAsyncOp waitOp(FDSAsyncOp::kWaitQueueSpaceAvailable);
	err = DoAsyncFDSOp(waitOp);
	SuccessOrExit(err);
	continue;
	}

	// If the operation timed out, simply try it again.
	if (fdsRes == FDS_ERR_OPERATION_TIMEOUT)
	{
	continue;
	}

	// Otherwise fail with an unrecoverable error.
	ExitNow(err = MapFDSError(fdsRes));
	}

	exit:
	return err;
	}

	void NRF5Config::HandleFDSEvent(const fds_evt_t * fdsEvent)
	{
	// Do nothing if there's no async operation active.
	if (sActiveAsyncOp == NULL)
	{
	return;
	}

	// Check if the event applies to the active async operation.
	switch (sActiveAsyncOp->OpType)
	{
	case FDSAsyncOp::kInit:
	if (fdsEvent->id != FDS_EVT_INIT)
	{
	return;
	}
	break;
	case FDSAsyncOp::kAddOrUpdateRecord:
	case FDSAsyncOp::kAddRecord:
	case FDSAsyncOp::kUpdateRecord:
	// Ignore the event if its not a WRITE or UPDATE, or if its for a different file/record.
	if ((fdsEvent->id != FDS_EVT_WRITE && fdsEvent->id != FDS_EVT_UPDATE) \|\|
	fdsEvent->write.file_id != sActiveAsyncOp->FileId \|\|
	fdsEvent->write.record_key != sActiveAsyncOp->RecordKey)
	{
	return;
	}
	break;
	case FDSAsyncOp::kDeleteRecord:
	case FDSAsyncOp::kDeleteRecordByKey:
	// Ignore the event if its not a DEL_RECORD, or if its for a different file/record.
	if (fdsEvent->id != FDS_EVT_DEL_RECORD \|\|
	fdsEvent->del.record_id != sActiveAsyncOp->RecordDesc.record_id)
	{
	return;
	}
	break;
	case FDSAsyncOp::kDeleteFile:
	// Ignore the event if its not a DEL_FILE or its for a different file.
	if (fdsEvent->id != FDS_EVT_DEL_FILE \|\| fdsEvent->del.file_id != sActiveAsyncOp->FileId)
	{
	return;
	}
	break;
	case FDSAsyncOp::kGC:
	// Ignore the event if its not a GC.
	if (fdsEvent->id != FDS_EVT_GC)
	{
	return;
	}
	break;
	case FDSAsyncOp::kWaitQueueSpaceAvailable:
	break;
	}

	// Capture the result.
	sActiveAsyncOp->Result = fdsEvent->result;

	// Mark the operation as complete.
	sActiveAsyncOp = NULL;

	// Signal the Weave thread that the operation has completed.
	#if defined(SOFTDEVICE_PRESENT) && SOFTDEVICE_PRESENT

	// When using the Nodic SoftDevice, HandleFDSEvent() is called in a SoftDevice interrupt
	// context. Therefore, we must use xSemaphoreGiveFromISR() to signal completion.
	BaseType_t yieldRequired = xSemaphoreGiveFromISR(sAsyncOpCompletionSem, &yieldRequired);

	// Yield to the next runnable task, but only if the FreeRTOS scheduler has been started.
	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED && yieldRequired == pdTRUE)
	{
	portYIELD_FROM_ISR(yieldRequired);
	}

	#else // defined(SOFTDEVICE_PRESENT) \|\| !SOFTDEVICE_PRESENT

	// When NOT using the Nodic SoftDevice, HandleFDSEvent() is called in a non-interrupt
	// context. Therefore, use xSemaphoreGive() to signal completion.
	xSemaphoreGive(sAsyncOpCompletionSem);

	#endif // !(defined(SOFTDEVICE_PRESENT) \|\| !SOFTDEVICE_PRESENT)
	}

	void NRF5Config::RunConfigUnitTest()
	{
	WEAVE_ERROR err;

	// Run common unit test
	::nl::Weave::DeviceLayer::Internal::RunConfigUnitTest<NRF5Config>();

	// NRF Config Test 1 -- Force GC
	{
	const static uint8_t kTestData[] =
	{
	0xD5, 0x00, 0x00, 0x04, 0x00, 0x01, 0x00, 0x30, 0x01, 0x08, 0x79, 0x55, 0x9F, 0x15, 0x1F, 0x66,
	0x3D, 0x8F, 0x24, 0x02, 0x05, 0x37, 0x03, 0x27, 0x13, 0x02, 0x00, 0x00, 0xEE, 0xEE, 0x30, 0xB4,
	0x18, 0x18, 0x26, 0x04, 0x80, 0x41, 0x1B, 0x23, 0x26, 0x05, 0x7F, 0xFF, 0xFF, 0x52, 0x37, 0x06,
	0x27, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xB4, 0x18, 0x18, 0x24, 0x07, 0x02, 0x26, 0x08,
	0x25, 0x00, 0x5A, 0x23, 0x30, 0x0A, 0x39, 0x04, 0x9E, 0xC7, 0x77, 0xC5, 0xA4, 0x13, 0x31, 0xF7,
	0x72, 0x2E, 0x27, 0xC2, 0x86, 0x3D, 0xC5, 0x2E, 0xD5, 0xD2, 0x3C, 0xCF, 0x7E, 0x06, 0xE3, 0x48,
	0x53, 0x87, 0xE8, 0x4D, 0xB0, 0x27, 0x07, 0x58, 0x4A, 0x38, 0xB4, 0xF3, 0xB2, 0x47, 0x94, 0x45,
	0x58, 0x65, 0x80, 0x08, 0x17, 0x6B, 0x8E, 0x4F, 0x07, 0x41, 0xA3, 0x3D, 0x5D, 0xCE, 0x76, 0x86,
	0x35, 0x83, 0x29, 0x01, 0x18, 0x35, 0x82, 0x29, 0x01, 0x24, 0x02, 0x05, 0x18, 0x35, 0x84, 0x29,
	0x01, 0x36, 0x02, 0x04, 0x02, 0x04, 0x01, 0x18, 0x18, 0x35, 0x81, 0x30, 0x02, 0x08, 0x42, 0xBD,
	0x2C, 0x6B, 0x5B, 0x3A, 0x18, 0x16, 0x18, 0x35, 0x80, 0x30, 0x02, 0x08, 0x44, 0xE3, 0x40, 0x38,
	0xA9, 0xD4, 0xB5, 0xA7, 0x18, 0x35, 0x0C, 0x30, 0x01, 0x19, 0x00, 0xA6, 0x5D, 0x54, 0xF5, 0xAE,
	0x5D, 0x63, 0xEB, 0x69, 0xD8, 0xDB, 0xCB, 0xE2, 0x20, 0x0C, 0xD5, 0x6F, 0x43, 0x5E, 0x96, 0xA8,
	0x54, 0xB2, 0x74, 0x30, 0x02, 0x19, 0x00, 0xE0, 0x37, 0x02, 0x8B, 0xB3, 0x04, 0x06, 0xDD, 0xBD,
	0x28, 0xAA, 0xC4, 0xF1, 0xFF, 0xFB, 0xB1, 0xD4, 0x1C, 0x78, 0x40, 0xDA, 0x2C, 0xD8, 0x40, 0x18,
	0x18,
	};
	uint8_t buf[512];
	size_t dataLen;

	for (int i = 0; i < 100; i++)
	{
	err = WriteConfigValueBin(kConfigKey_ManufAttestDeviceCert, kTestData, sizeof(kTestData));
	VerifyOrDie(err == WEAVE_NO_ERROR);

	vTaskDelay(pdMS_TO_TICKS(50));
	}

	err = ReadConfigValueBin(kConfigKey_ManufAttestDeviceCert, buf, sizeof(buf), dataLen);
	VerifyOrDie(err == WEAVE_NO_ERROR);

	VerifyOrDie(dataLen == sizeof(kTestData));
	VerifyOrDie(memcmp(buf, kTestData, dataLen) == 0);
	}
	}



	} // namespace Internal
	} // namespace DeviceLayer
	} // namespace Weave
	} // namespace nl