Add implementation of Sys.IO.DriveInfo (nanoframework#2912)

Author: josesimoes

CMake/Modules/FindSystem.IO.FileSystem.cmake

@@ -24,6 +24,7 @@ set(System.IO.FileSystem_SRCS
 
     nf_sys_io_filesystem_nanoFramework_System_IO_FileSystem_SDCard.cpp
     nf_sys_io_filesystem_System_IO_Directory.cpp
+    nf_sys_io_filesystem_System_IO_DriveInfo.cpp
     nf_sys_io_filesystem_System_IO_File.cpp
     nf_sys_io_filesystem_System_IO_FileStream.cpp
 

src/System.IO.FileSystem/nf_sys_io_filesystem.cpp

@@ -72,6 +72,17 @@ static const CLR_RT_MethodHandler method_lookup[] =
     NULL,
     NULL,
     NULL,
+    Library_nf_sys_io_filesystem_System_IO_DriveInfo::DriveInfoNative___VOID__STRING,
+    NULL,
+    Library_nf_sys_io_filesystem_System_IO_DriveInfo::Format___STATIC__VOID__STRING,
+    Library_nf_sys_io_filesystem_System_IO_DriveInfo::GetDrivesNative___STATIC__SZARRAY_SystemIODriveInfo,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
     NULL,
     NULL,
     NULL,
@@ -133,14 +144,16 @@ static const CLR_RT_MethodHandler method_lookup[] =
     NULL,
     NULL,
     NULL,
+    NULL,
+    NULL,
 };
 
 const CLR_RT_NativeAssemblyData g_CLR_AssemblyNative_System_IO_FileSystem =
 {
     "System.IO.FileSystem",
-    0x545A6C79,
+    0x62EBC911,
     method_lookup,
-    { 1, 0, 0, 2 }
+    { 1, 1, 0, 0 }
 };
 
 // clang-format on

src/System.IO.FileSystem/nf_sys_io_filesystem.h

@@ -38,6 +38,15 @@ typedef enum __nfpack StorageEventManager_StorageEventType
     StorageEventManager_StorageEventType_RemovableDeviceRemoval = 2,
 } StorageEventManager_StorageEventType;
 
+typedef enum __nfpack DriveType
+{
+    DriveType_Unknown = 0,
+    DriveType_NoRootDirectory = 1,
+    DriveType_Removable = 2,
+    DriveType_Fixed = 3,
+    DriveType_Ram = 4,
+} DriveType;
+
 typedef enum __nfpack FileAccess
 {
     FileAccess_Read = 1,
@@ -150,6 +159,19 @@ struct Library_nf_sys_io_filesystem_System_IO_Directory
     //--//
 };
 
+struct Library_nf_sys_io_filesystem_System_IO_DriveInfo
+{
+    static const int FIELD___driveType = 1;
+    static const int FIELD___name = 2;
+    static const int FIELD___totalSize = 3;
+
+    NANOCLR_NATIVE_DECLARE(DriveInfoNative___VOID__STRING);
+    NANOCLR_NATIVE_DECLARE(Format___STATIC__VOID__STRING);
+    NANOCLR_NATIVE_DECLARE(GetDrivesNative___STATIC__SZARRAY_SystemIODriveInfo);
+
+    //--//
+};
+
 struct Library_nf_sys_io_filesystem_System_IO_FileStream
 {
     static const int FIELD___canRead = 1;

targets/ChibiOS/_nanoCLR/System.IO.FileSystem/nf_sys_io_filesystem_System_IO_DriveInfo.cpp

@@ -0,0 +1,34 @@
+//
+// Copyright (c) .NET Foundation and Contributors
+// See LICENSE file in the project root for full license information.
+//
+
+#include <nf_sys_io_filesystem.h>
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::DriveInfoNative___VOID__STRING(CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    NANOCLR_SET_AND_LEAVE(stack.NotImplementedStub());
+
+    NANOCLR_NOCLEANUP();
+}
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::Format___STATIC__VOID__STRING(CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    NANOCLR_SET_AND_LEAVE(stack.NotImplementedStub());
+
+    NANOCLR_NOCLEANUP();
+}
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::GetDrivesNative___STATIC__SZARRAY_SystemIODriveInfo(
+    CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    NANOCLR_SET_AND_LEAVE(stack.NotImplementedStub());
+
+    NANOCLR_NOCLEANUP();
+}

targets/ESP32/_common/Target_Windows_Storage.c

@@ -43,6 +43,8 @@
 
 static const char *TAG = "SDCard";
 
+sdmmc_card_t *card;
+
 //
 //  Unmount SD card ( MMC/SDIO or SPI)
 //
@@ -52,6 +54,9 @@ bool Storage_UnMountSDCard()
     {
         return false;
     }
+
+    card = NULL;
+
     return true;
 }
 
@@ -120,7 +125,6 @@ bool Storage_MountMMC(bool bit1Mode, int driveIndex)
         .max_files = SDC_MAX_OPEN_FILES,
         .allocation_unit_size = 16 * 1024};
 
-    sdmmc_card_t *card;
     errCode = esp_vfs_fat_sdmmc_mount(mountPoint, &host, &slot_config, &mount_config, &card);
     if (errCode == ESP_ERR_INVALID_STATE)
     {
@@ -166,8 +170,6 @@ bool Storage_MountSpi(int spiBus, uint32_t csPin, int driveIndex)
         .max_files = 5,
         .allocation_unit_size = 16 * 1024};
 
-    sdmmc_card_t *card;
-
     // This initializes the slot without card detect (CD) and write protect (WP) signals.
     // Modify slot_config.gpio_cd and slot_config.gpio_wp if your board has these signals.
     sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();

targets/ESP32/_nanoCLR/System.IO.FileSystem/nf_sys_io_filesystem_System_IO_Directory.cpp

@@ -394,6 +394,7 @@ HRESULT Library_nf_sys_io_filesystem_System_IO_Directory::GetDirectoriesNative__
 // Enumerate drives in system
 // if array == null then only count drives
 // Return number of drives
+// TO BE REMOVED AFTER managed Directory.GetLogicalDrives() is removed
 static HRESULT EnumerateDrives(CLR_RT_HeapBlock *array, int &count)
 {
     NANOCLR_HEADER();

targets/ESP32/_nanoCLR/System.IO.FileSystem/nf_sys_io_filesystem_System_IO_DriveInfo.cpp

@@ -0,0 +1,200 @@
+//
+// Copyright (c) .NET Foundation and Contributors
+// See LICENSE file in the project root for full license information.
+//
+
+#include <nf_sys_io_filesystem.h>
+#include <esp_vfs_fat.h>
+#include <sdmmc_host.h>
+#include <diskio_impl.h>
+#include <targetHAL_FileOperation.h>
+#include <targetHAL_ConfigStorage.h>
+
+typedef Library_nf_sys_io_filesystem_System_IO_DriveInfo DriveInfo;
+static HRESULT EnumerateDrives(CLR_RT_HeapBlock *array, int &count);
+
+extern bool IsInternalFilePath(const char *filePath);
+extern "C" sdmmc_card_t *card;
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::DriveInfoNative___VOID__STRING(CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    char workingDrive[DRIVE_LETTER_LENGTH];
+
+#if (HAL_USE_SDC == TRUE)
+    char *vfsPath = NULL;
+    int operationResult;
+    struct stat fno;
+#endif
+
+    CLR_RT_TypeDef_Index driveInfoTypeDef;
+    CLR_RT_HeapBlock *driveInfo;
+
+    CLR_RT_HeapBlock &top = stack.PushValue();
+
+    const char *drivePath = stack.Arg1().RecoverString();
+    FAULT_ON_NULL_ARG(drivePath);
+
+    // copy the first 2 letters of the path for the drive
+    // path is 'D:\folder\file.txt', so we need 'D:'
+    memcpy(workingDrive, drivePath, DRIVE_LETTER_LENGTH);
+
+    // start composing the reply
+    // find <DriveInfo> type definition, don't bother checking the result as it exists for sure
+    g_CLR_RT_TypeSystem.FindTypeDef("DriveInfo", "System.IO", driveInfoTypeDef);
+
+    // create an instance of <DriveInfo>
+    NANOCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(top, driveInfoTypeDef));
+
+    // get a pointer to DriveInfo
+    driveInfo = (CLR_RT_HeapBlock *)top.Dereference();
+
+    if (IsInternalFilePath(workingDrive))
+    {
+        // get the drive info from SPIFFs
+        size_t total = 0, used = 0;
+        esp_spiffs_info(SPIFFS_PARTITION_LABEL, &total, &used);
+
+        // fill in the drive info namaged fields
+        driveInfo[FIELD___driveType].SetInteger(DriveType_Fixed);
+        CLR_RT_HeapBlock_String::CreateInstance(driveInfo[FIELD___name], drivePath);
+        driveInfo[FIELD___totalSize].SetInteger((CLR_UINT32)total);
+    }
+    else
+
+#if (HAL_USE_SDC == TRUE)
+
+    {
+        // assume "0:"" as we're always mounting 1 FATFS drive
+
+        operationResult = stat(vfsPath, &fno);
+        if (operationResult == 0)
+        {
+            // fill in the drive info namaged fields
+            driveInfo[FIELD___driveType].SetInteger(DriveType_Removable);
+            CLR_RT_HeapBlock_String::CreateInstance(driveInfo[FIELD___name], drivePath);
+            driveInfo[FIELD___totalSize].SetInteger((CLR_UINT32)fno.st_size);
+        }
+        else
+        {
+            // failed to get drive info
+            NANOCLR_SET_AND_LEAVE(CLR_E_FILE_IO);
+        }
+    }
+
+#endif // HAL_USE_SDC
+
+    {
+        // unsupported drive
+        NANOCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
+    }
+
+    NANOCLR_NOCLEANUP();
+}
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::Format___STATIC__VOID__STRING(CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    const char *drivePath = stack.Arg1().RecoverString();
+    FAULT_ON_NULL_ARG(drivePath);
+
+#if (HAL_USE_SDC == TRUE)
+
+    // check if SD card is mounted
+    if (card != NULL)
+    {
+        // format it
+        const size_t workbuf_size = 4096;
+
+        void *workbuf = NULL;
+        BYTE pdrv;
+        DWORD plist[] = {100, 0, 0, 0};
+
+        workbuf = ff_memalloc(workbuf_size);
+        if (workbuf == NULL)
+        {
+            return ESP_ERR_NO_MEM;
+        }
+
+        ff_diskio_get_drive(&pdrv);
+
+        f_fdisk(pdrv, plist, workbuf);
+    }
+    else
+    {
+        // SD card is not mounted
+        // return error
+        NANOCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
+    }
+#endif // HAL_USE_SDC
+
+    NANOCLR_NOCLEANUP();
+}
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::GetDrivesNative___STATIC__SZARRAY_SystemIODriveInfo(
+    CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    int count = 0;
+
+    CLR_RT_HeapBlock &top = stack.PushValueAndClear();
+
+    // 1st pass find number of drives
+    NANOCLR_CHECK_HRESULT(EnumerateDrives(NULL, count));
+
+    // create an array of files paths <String> for count drives
+    NANOCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance(top, count, g_CLR_RT_WellKnownTypes.m_String));
+
+    // 2nd pass fill array with drives
+    NANOCLR_CHECK_HRESULT(EnumerateDrives(&top, count));
+
+    NANOCLR_NOCLEANUP();
+}
+
+// Enumerate drives in system
+// if array == null then only count drives
+// Return number of drives
+static HRESULT EnumerateDrives(CLR_RT_HeapBlock *array, int &count)
+{
+    NANOCLR_HEADER();
+    {
+        CLR_RT_HeapBlock *storageFolder = NULL;
+        DIR *currentDirectory;
+        char outputDrive[] = INDEX0_DRIVE_PATH;
+        char workingDrive[] = "/D/";
+
+        if (array)
+        {
+            // get a pointer to the first object in the array (which is of type <String>)
+            storageFolder = (CLR_RT_HeapBlock *)array->DereferenceArray()->GetFirstElement();
+        }
+
+        count = 0;
+        for (char drive = INDEX0_DRIVE_LETTER[0]; drive <= INTERNAL_DRIVE0_LETTER[0]; drive++)
+        {
+            workingDrive[1] = drive;
+            currentDirectory = opendir(workingDrive);
+            if (currentDirectory != NULL)
+            {
+                count++;
+                closedir(currentDirectory);
+
+                if (array)
+                {
+                    // Add entry to array
+                    outputDrive[0] = drive;
+
+                    // set the drive letter in string array
+                    NANOCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance(*storageFolder, outputDrive));
+
+                    // Next element in array
+                    storageFolder++;
+                }
+            }
+        }
+    }
+    NANOCLR_NOCLEANUP();
+}

targets/FreeRTOS/NXP/_nanoCLR/System.IO.FileSystem/nf_sys_io_filesystem_System_IO_DriveInfo.cpp

@@ -0,0 +1,34 @@
+//
+// Copyright (c) .NET Foundation and Contributors
+// See LICENSE file in the project root for full license information.
+//
+
+#include <nf_sys_io_filesystem.h>
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::DriveInfoNative___VOID__STRING(CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    NANOCLR_SET_AND_LEAVE(stack.NotImplementedStub());
+
+    NANOCLR_NOCLEANUP();
+}
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::Format___STATIC__VOID__STRING(CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    NANOCLR_SET_AND_LEAVE(stack.NotImplementedStub());
+
+    NANOCLR_NOCLEANUP();
+}
+
+HRESULT Library_nf_sys_io_filesystem_System_IO_DriveInfo::GetDrivesNative___STATIC__SZARRAY_SystemIODriveInfo(
+    CLR_RT_StackFrame &stack)
+{
+    NANOCLR_HEADER();
+
+    NANOCLR_SET_AND_LEAVE(stack.NotImplementedStub());
+
+    NANOCLR_NOCLEANUP();
+}