Merge branch 'main' of https://github.com/nanoframework/nf-interpreter into develop

Author: josesimoes

src/CLR/Core/Execution.cpp

@@ -640,9 +640,7 @@ HRESULT CLR_RT_ExecutionEngine::Execute(wchar_t *entryPointArgs, int maxContextS
 
     NANOCLR_CHECK_HRESULT(WaitForDebugger());
 
-#if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
     CLR_EE_DBG_SET_MASK(StateProgramRunning, StateMask);
-#endif // #if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
 
     NANOCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Delegate::CreateInstance(ref, g_CLR_RT_TypeSystem.m_entryPoint, nullptr));
 

src/CLR/Startup/CLRStartup.cpp

@@ -425,8 +425,8 @@ void ClrStartup(CLR_SETTINGS params)
 
         if (CLR_EE_DBG_IS_NOT(RebootPending))
         {
-#if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
             CLR_EE_DBG_SET_MASK(StateProgramExited, StateMask);
+#if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
             CLR_EE_DBG_EVENT_BROADCAST(CLR_DBG_Commands_c_Monitor_ProgramExit, 0, nullptr, WP_Flags_c_NonCritical);
 #endif // #if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
 

src/HAL/nanoHAL_StorageOperation.cpp

@@ -53,6 +53,7 @@ uint32_t HAL_StorageOperation(uint8_t operation, uint32_t dataLength, uint32_t o
         char dirPath[FS_MAX_DIRECTORY_LENGTH];
         char *lastSeparator;
         int bytesWritten = 0;
+        HRESULT deleteResult;
 
         // extract parent directory from relative path and create it if needed
         snprintf(dirPath, sizeof(dirPath), "%s", relativePath);
@@ -74,6 +75,17 @@ uint32_t HAL_StorageOperation(uint8_t operation, uint32_t dataLength, uint32_t o
             }
         }
 
+        // Open() below doesn't truncate, so remove an existing file to start the write from an empty one
+        deleteResult = volume->Delete(relativePath, false);
+
+        // a missing file, or a volume without Delete, is the normal case; any other failure would leave
+        // the previous content in place and the write would produce a file with a stale tail
+        if (FAILED(deleteResult) && deleteResult != CLR_E_FILE_NOT_FOUND && deleteResult != CLR_E_NOT_SUPPORTED)
+        {
+            errorCode = StorageOperationErrorCode::WriteError;
+            goto done;
+        }
+
         // open the file (creates it, if it doesn't exist)
         if (FAILED(volume->Open(relativePath, fileHandle)))
         {

targets/ChibiOS/_FatFs/fatfs_FS_Driver.cpp

@@ -166,13 +166,11 @@ HRESULT FATFS_FS_Driver::Format(const VOLUME_ID *volume, const char *volumeLabel
 
 HRESULT FATFS_FS_Driver::GetSizeInfo(const VOLUME_ID *volume, int64_t *totalSize, int64_t *totalFreeSpace)
 {
-    (void)totalSize;
-
     // FATFS *fsPtr = &fs;
     // char buffer[3];
     // DWORD freeClusters, freeSectors, totalSectors;
 
-    // FATFS *fs = GetFatFsByVolumeId(volume, false);
+    FATFS *fs = GetFatFsByVolumeId(volume, false);
 
     FileSystemVolume *currentVolume = FileSystemVolumeList::FindVolume(volume->volumeId);
 
@@ -194,9 +192,22 @@ HRESULT FATFS_FS_Driver::GetSizeInfo(const VOLUME_ID *volume, int64_t *totalSize
     //     *totalFreeSpace = (int64_t)freeSectors * FF_MAX_SS;
     // #endif
 
+    // -1 means "unknown" to the caller
     *totalSize = -1;
+
+    // free space would need f_getfree(), see above
     *totalFreeSpace = -1;
 
+    if (fs != NULL)
+    {
+        // capacity of the file system, from the mounted FATFS object, without walking the FAT
+#if FF_MAX_SS != FF_MIN_SS
+        *totalSize = (int64_t)(fs->n_fatent - 2) * fs->csize * fs->ssize;
+#else
+        *totalSize = (int64_t)(fs->n_fatent - 2) * fs->csize * FF_MAX_SS;
+#endif
+    }
+
     return S_OK;
 }
 

targets/ESP32/_common/Target_System_IO_FileSystem.c

@@ -45,6 +45,9 @@ static const char *TAG = "SDCard";
 
 sdmmc_card_t *card;
 
+// drive letter the card above is mounted under, 0 when it is not mounted
+char cardDriveLetter;
+
 //
 //  Unmount SD card ( MMC/SDIO or SPI)
 //
@@ -62,6 +65,7 @@ bool Storage_UnMountSDCard(int driveIndex)
     }
 
     card = NULL;
+    cardDriveLetter = 0;
 
     return true;
 }
@@ -183,7 +187,15 @@ bool Storage_MountMMC(bool bit1Mode, int driveIndex)
         errCode = esp_vfs_fat_sdmmc_mount(mountPoint, &host, &slot_config, &mount_config, &card);
     }
 
-    return LogMountResult(errCode);
+    if (!LogMountResult(errCode))
+    {
+        return false;
+    }
+
+    // only stored on success, a failed mount leaves no card to bind the volume to
+    cardDriveLetter = INDEX0_DRIVE_LETTER[0] + driveIndex;
+
+    return true;
 }
 #endif
 
@@ -237,7 +249,15 @@ bool Storage_MountSpi(int spiBus, uint32_t csPin, int driveIndex)
         errCode = esp_vfs_fat_sdspi_mount(mountPoint, &host, &slot_config, &mount_config, &card);
     }
 
-    return LogMountResult(errCode);
+    if (!LogMountResult(errCode))
+    {
+        return false;
+    }
+
+    // only stored on success, a failed mount leaves no card to bind the volume to
+    cardDriveLetter = INDEX0_DRIVE_LETTER[0] + driveIndex;
+
+    return true;
 }
 
 #endif

targets/ESP32/_common/WireProtocol_HAL_Interface.c

@@ -161,7 +161,7 @@ static uint8_t WP_TransmitMessageTinyUsb(WP_Message *message)
 
 #include "driver/usb_serial_jtag.h"
 
-#define USB_JTAG_BUFFER_SIZE 256
+#define USB_JTAG_BUFFER_SIZE (sizeof(WP_Packet) + WP_PACKET_SIZE)
 
 static size_t UsbSerialWrite(const uint8_t *data, size_t dataSize, TickType_t xTicksToWait);
 static size_t UsbSerialRead(uint8_t *data, size_t dataSize, TickType_t xTicksToWait);

targets/ESP32/_littlefs/littlefs_FS_Driver.cpp

@@ -7,6 +7,14 @@
 #include "littlefs_FS_Driver.h"
 #include <stdlib.h>
 
+#if (HAL_USE_SDC == TRUE)
+#include <sdmmc_cmd.h>
+
+// the mounted card and the volume it belongs to, from Target_System_IO_FileSystem.c
+extern "C" sdmmc_card_t *card;
+extern "C" char cardDriveLetter;
+#endif
+
 extern FileSystemVolume *g_FS_Volumes;
 
 static int32_t RemoveAllFiles(const char *path);
@@ -81,8 +89,6 @@ HRESULT LITTLEFS_FS_Driver::Format(const VOLUME_ID *volume, const char *volumeLa
 
 HRESULT LITTLEFS_FS_Driver::GetSizeInfo(const VOLUME_ID *volume, int64_t *totalSize, int64_t *totalFreeSpace)
 {
-    (void)totalSize;
-
     // FATFS *fsPtr = &fs;
     // char buffer[3];
     // DWORD freeClusters, freeSectors, totalSectors;
@@ -109,9 +115,30 @@ HRESULT LITTLEFS_FS_Driver::GetSizeInfo(const VOLUME_ID *volume, int64_t *totalS
     // //     *totalFreeSpace = (int64_t)freeSectors * FF_MAX_SS;
     // // #endif
 
+    // -1 means "unknown" to the caller
     *totalSize = -1;
+
+    // free space would need f_getfree(), which walks the FAT and trips the watchdog on large cards
     *totalFreeSpace = -1;
 
+#if (HAL_USE_SDC == TRUE)
+
+    // the driver also serves the internal flash, which has no card behind it
+    FileSystemVolume *currentVolume = FileSystemVolumeList::FindVolume(volume->volumeId);
+
+    if (currentVolume != NULL && card != NULL && cardDriveLetter != 0 &&
+        currentVolume->m_rootName[0] == cardDriveLetter)
+    {
+        // physical capacity of the card, not of the file system on it
+        *totalSize = (int64_t)card->csd.capacity * card->csd.sector_size;
+    }
+
+#else
+
+    (void)volume;
+
+#endif
+
     return S_OK;
 }
 
@@ -282,6 +309,13 @@ HRESULT LITTLEFS_FS_Driver::Read(void *handle, uint8_t *buffer, int size, int *b
 
     fileHandle = (LITTLEFS_FileHandle *)handle;
 
+    if (fileHandle->lastOp == LITTLEFS_LastOperation_Write && fseek(fileHandle->file, 0, SEEK_CUR) != 0)
+    {
+        NANOCLR_SET_AND_LEAVE(CLR_E_FILE_IO);
+    }
+
+    fileHandle->lastOp = LITTLEFS_LastOperation_Read;
+
     // read from the file
     readCount = fread(buffer, 1, size, fileHandle->file);
 
@@ -324,6 +358,13 @@ HRESULT LITTLEFS_FS_Driver::Write(void *handle, uint8_t *buffer, int size, int *
 
     fileHandle = (LITTLEFS_FileHandle *)handle;
 
+    if (fileHandle->lastOp == LITTLEFS_LastOperation_Read && fseek(fileHandle->file, 0, SEEK_CUR) != 0)
+    {
+        NANOCLR_SET_AND_LEAVE(CLR_E_FILE_IO);
+    }
+
+    fileHandle->lastOp = LITTLEFS_LastOperation_Write;
+
     // write to the file
     writeCount = fwrite(buffer, 1, size, fileHandle->file);
 
@@ -397,6 +438,8 @@ HRESULT LITTLEFS_FS_Driver::Seek(void *handle, int64_t offset, uint32_t origin,
         return CLR_E_FILE_IO;
     }
 
+    fileHandle->lastOp = LITTLEFS_LastOperation_None;
+
     // get the current position
     *position = ftell(fileHandle->file);
 
@@ -445,6 +488,8 @@ HRESULT LITTLEFS_FS_Driver::GetLength(void *handle, int64_t *length)
         return CLR_E_FILE_IO;
     }
 
+    fileHandle->lastOp = LITTLEFS_LastOperation_None;
+
     return S_OK;
 }
 
@@ -489,6 +534,8 @@ HRESULT LITTLEFS_FS_Driver::SetLength(void *handle, int64_t length)
         return CLR_E_FILE_IO;
     }
 
+    fileHandle->lastOp = LITTLEFS_LastOperation_None;
+
     // Synchronize the file state
     fflush(fileHandle->file);
 

targets/ESP32/_littlefs/littlefs_FS_Driver.h

@@ -16,9 +16,22 @@ extern "C"
 {
 #endif
 
+    // direction of the last operation on a file, files are opened in update mode and ANSI C
+    // requires a positioning call between a read and a write on such a stream
+    enum LITTLEFS_LastOperation
+    {
+        // no operation yet, or the file was just positioned: both directions are legal
+        LITTLEFS_LastOperation_None = 0,
+        // last operation was a read: a write needs a positioning call first
+        LITTLEFS_LastOperation_Read = 1,
+        // last operation was a write: a read needs a positioning call first
+        LITTLEFS_LastOperation_Write = 2,
+    };
+
     struct LITTLEFS_FileHandle
     {
         FILE *file;
+        LITTLEFS_LastOperation lastOp;
     };
 
     struct LITTLEFS_FindFileHandle