[EGD-4135] FREERTOS vfat ff_fflush implementation (#878)

ff_fflush implementation is needed for sqlite3 when
unexcepted power failure.

Co-authored-by: Lucjan Bryndza <[email protected]>

Author: Lucjan Bryndza

module-vfs/CMakeLists.txt

@@ -34,8 +34,14 @@ set(PROJECT_INCLUDES
         ${CMAKE_CURRENT_SOURCE_DIR}/board/free_rtos_custom/include
         )
 
+set(FREERTOS_FAT_EXTSOURCES
+	${CMAKE_CURRENT_SOURCE_DIR}/freertos-fat-custom/ff_stdio_flush.c
+	${CMAKE_CURRENT_SOURCE_DIR}/freertos-fat-custom/ff_file_flush.c
+)
+
 set(SOURCES ""
         ${FREERTOS_FAT_SOURCES}
+        ${FREERTOS_FAT_EXTSOURCES}
         vfs-utils.cpp
         vfs.cpp
 )

module-vfs/freertos-fat-custom/ff_file_flush.c

@@ -0,0 +1,100 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "ff_headers.h"
+#include "ff_file_flush.h"
+
+#if (ffconfigUNICODE_UTF16_SUPPORT != 0)
+#include <wchar.h>
+#endif
+
+FF_Error_t FF_Flush(FF_FILE *pxFile)
+{
+
+    FF_FILE *pxFileChain;
+    FF_DirEnt_t xOriginalEntry;
+    FF_Error_t xError;
+
+    /* Opening a do {} while( 0 )
+     * loop to allow the use of the break statement. */
+    do {
+        if (pxFile == NULL) {
+            xError = (FF_Error_t)(FF_ERR_NULL_POINTER | FF_CLOSE);
+            break;
+        }
+        /* It is important to check that user doesn't supply invalid
+           handle or a handle invalid because of "media removed" */
+        xError = FF_CheckValid(pxFile);
+#if (ffconfigREMOVABLE_MEDIA != 0)
+        if (FF_GETERROR(xError) == FF_ERR_FILE_MEDIA_REMOVED) {
+            FF_PendSemaphore(pxFile->pxIOManager->pvSemaphore);
+            pxFileChain = (FF_FILE *)pxFile->pxIOManager->FirstFile;
+            if (pxFileChain == pxFile) {
+                pxFile->pxIOManager->FirstFile = pxFile->pxNext;
+            }
+            else {
+                while (pxFileChain) {
+                    if (pxFileChain->pxNext == pxFile) {
+                        pxFileChain->pxNext = pxFile->pxNext;
+                        break;
+                    }
+                    pxFileChain = pxFileChain->pxNext; /* Forgot this one */
+                }
+            }
+            FF_ReleaseSemaphore(pxFile->pxIOManager->pvSemaphore);
+#if (ffconfigOPTIMISE_UNALIGNED_ACCESS != 0)
+            ffconfigFREE(pxFile->pucBuffer);
+#endif                            /* ffconfigOPTIMISE_UNALIGNED_ACCESS */
+            ffconfigFREE(pxFile); /* So at least we have freed the pointer. */
+            xError = FF_ERR_NONE;
+            break;
+        }
+#endif /* ffconfigREMOVABLE_MEDIA */
+
+        if (FF_isERR(xError)) {
+            /* FF_ERR_FILE_BAD_HANDLE or FF_ERR_NULL_POINTER */
+            break;
+        }
+
+        /* So here we have a normal valid file handle. */
+        if (((pxFile->ulValidFlags & FF_VALID_FLAG_DELETED) == 0) &&
+            ((pxFile->ucMode & (FF_MODE_WRITE | FF_MODE_APPEND | FF_MODE_CREATE)) != 0)) {
+            /* Get the directory entry and update it to show the new file size */
+            if (FF_isERR(xError) == pdFALSE) {
+                xError = FF_GetEntry(pxFile->pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry);
+
+                /* Now update the directory entry */
+                if ((FF_isERR(xError) == pdFALSE) &&
+                    ((pxFile->ulFileSize != xOriginalEntry.ulFileSize) || (pxFile->ulFileSize == 0UL))) {
+                    if (pxFile->ulFileSize == 0UL) {
+                        xOriginalEntry.ulObjectCluster = 0;
+                    }
+
+                    xOriginalEntry.ulFileSize = pxFile->ulFileSize;
+                    xError                    = FF_PutEntry(
+                        pxFile->pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry, NULL);
+                }
+            }
+        }
+#if (ffconfigOPTIMISE_UNALIGNED_ACCESS != 0)
+        {
+            if (pxFile->pucBuffer != NULL) {
+                /* Ensure any unaligned points are pushed to the disk! */
+                if (pxFile->ucState & FF_BUFSTATE_WRITTEN) {
+                    FF_Error_t xTempError;
+
+                    xTempError = FF_BlockWrite(pxFile->pxIOManager, FF_FileLBA(pxFile), 1, pxFile->pucBuffer, pdFALSE);
+                    if (FF_isERR(xError) == pdFALSE) {
+                        xError = xTempError;
+                    }
+                }
+                pxFile->ucState = FF_BUFSTATE_INVALID;
+            }
+        }
+#endif
+        if (FF_isERR(xError) == pdFALSE) {
+            xError = FF_FlushCache(pxFile->pxIOManager); /* Ensure all modified blocks are flushed to disk! */
+        }
+    } while (pdFALSE);
+    return xError;
+}

module-vfs/freertos-fat-custom/ff_file_flush.h

@@ -0,0 +1,7 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+#include "ff_file.h"
+
+FF_Error_t FF_Flush(FF_FILE *pxFile);

module-vfs/freertos-fat-custom/ff_stdio_flush.c

@@ -0,0 +1,52 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+/* FreeRTOS includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "portable.h"
+
+/* FreeRTOS+FAT includes. */
+#include "ff_headers.h"
+#include "ff_stdio.h"
+
+#if (ffconfigTIME_SUPPORT != 0)
+#include <time.h>
+#endif
+
+#include "ff_file_flush.h"
+
+int prvFFErrorToErrno(FF_Error_t xError);
+
+int ff_fflush(FF_FILE *pxStream)
+{
+    FF_Error_t xError;
+    int iReturn, ff_errno;
+
+#if (ffconfigDEV_SUPPORT != 0)
+    {
+        /* Currently device support is in an experimental state.  It will allow
+            to create virtual files. The I/O data to those files will be redirected
+            to their connected "drivers". */
+        if (pxStream != NULL) {
+            FF_Device_Flush(pxStream);
+        }
+    }
+#endif
+
+    xError   = FF_Flush(pxStream);
+    ff_errno = prvFFErrorToErrno(xError);
+
+    if (ff_errno == 0) {
+        iReturn = 0;
+    }
+    else {
+        /* Return -1 for error as per normal fclose() semantics. */
+        iReturn = -1;
+    }
+
+    /* Store the errno to thread local storage. */
+    stdioSET_ERRNO(ff_errno);
+
+    return iReturn;
+}