1. Fix some bugs when do update after non-destructive installation.

2. Call chkdsk to fix the volume before shrink.

diff --git a/INSTALL/Ventoy2Disk.exe b/INSTALL/Ventoy2Disk.exe
index 92a77d70cedc4af10620320f35524ad54db39857..59f86dc85e95882bbd5e403b2d02b7ad37d778bc 100644 (file)
Binary files a/INSTALL/Ventoy2Disk.exe and b/INSTALL/Ventoy2Disk.exe differ

diff --git a/INSTALL/Ventoy2Disk_ARM.exe b/INSTALL/Ventoy2Disk_ARM.exe
index d1398f64a7e2b2d04c1977870a6f6e951ec3944f..24865c6fda68a12194c28cac346ee36507cc5533 100644 (file)
Binary files a/INSTALL/Ventoy2Disk_ARM.exe and b/INSTALL/Ventoy2Disk_ARM.exe differ

diff --git a/INSTALL/Ventoy2Disk_ARM64.exe b/INSTALL/Ventoy2Disk_ARM64.exe
index 18a02ae70a69a9527c4a939b0943ff70b2247836..ff2a384c183a919169a00c62afd5279ca1b5f59d 100644 (file)
Binary files a/INSTALL/Ventoy2Disk_ARM64.exe and b/INSTALL/Ventoy2Disk_ARM64.exe differ

diff --git a/INSTALL/Ventoy2Disk_X64.exe b/INSTALL/Ventoy2Disk_X64.exe
index c6cf57cc447d65f7eadec77b860e09d653505e1e..e1be78a6dd68dbec09742c57e6583582940faf39 100644 (file)
Binary files a/INSTALL/Ventoy2Disk_X64.exe and b/INSTALL/Ventoy2Disk_X64.exe differ

diff --git a/INSTALL/grub/localboot.cfg b/INSTALL/grub/localboot.cfg
index c1106af769ade95afa164e905b5fa8557d5e0b1a..9366b68c7767572ca91b5afb2951dff9365348e2 100644 (file)
--- a/INSTALL/grub/localboot.cfg
+++ b/INSTALL/grub/localboot.cfg
@@ -76,6 +76,11 @@ else
                     terminal_output  console
                     chainloader /EFI/Microsoft/Boot/bootmgfw.efi
                     boot
                     terminal_output  console
                     chainloader /EFI/Microsoft/Boot/bootmgfw.efi
                     boot

+                elif [ -f ($vtoydev,$partid)/efi/Microsoft/Boot/bootmgfw.efi ]; then
+                    set root=($vtoydev,$partid)
+                    terminal_output  console
+                    chainloader /efi/Microsoft/Boot/bootmgfw.efi
+                    boot

                 fi
             else
                 break
                 fi
             else
                 break


@@ -87,6 +92,10 @@ else
             terminal_output  console
             chainloader /EFI/Microsoft/Boot/bootmgfw.efi
             boot
             terminal_output  console
             chainloader /EFI/Microsoft/Boot/bootmgfw.efi
             boot

+        elif search -n -s -f /efi/Microsoft/Boot/bootmgfw.efi; then
+            terminal_output  console
+            chainloader /efi/Microsoft/Boot/bootmgfw.efi
+            boot

         else
             echo "Windows NOT found ..."
         fi        
         else
             echo "Windows NOT found ..."
         fi        

diff --git a/Ventoy2Disk/Ventoy2Disk/DiskService.c b/Ventoy2Disk/Ventoy2Disk/DiskService.c
new file mode 100644 (file)
index 0000000..4272d6f
--- /dev/null
+++ b/Ventoy2Disk/Ventoy2Disk/DiskService.c
@@ -0,0 +1,111 @@
+/******************************************************************************\r
+* DiskService.c\r
+*\r
+* Copyright (c) 2021, longpanda <admin@ventoy.net>\r
+*\r
+* This program is free software; you can redistribute it and/or\r
+* modify it under the terms of the GNU General Public License as\r
+* published by the Free Software Foundation; either version 3 of the\r
+* License, or (at your option) any later version.\r
+*\r
+* This program is distributed in the hope that it will be useful, but\r
+* WITHOUT ANY WARRANTY; without even the implied warranty of\r
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
+* General Public License for more details.\r
+*\r
+* You should have received a copy of the GNU General Public License\r
+* along with this program; if not, see <http://www.gnu.org/licenses/>.\r
+*\r
+*/\r
+\r
+#include <Windows.h>\r
+#include <winternl.h>\r
+#include <commctrl.h>\r
+#include <initguid.h>\r
+#include <vds.h>\r
+#include "Ventoy2Disk.h"\r
+#include "DiskService.h"\r
+\r
+BOOL DISK_CleanDisk(int DriveIndex)\r
+{\r
+       BOOL ret;\r
+\r
+       ret = VDS_CleanDisk(DriveIndex);\r
+       if (!ret)\r
+       {\r
+               ret = PSHELL_CleanDisk(DriveIndex);\r
+       }\r
+\r
+       return ret;\r
+}\r
+\r
+\r
+BOOL DISK_DeleteVtoyEFIPartition(int DriveIndex, UINT64 EfiPartOffset)\r
+{\r
+       BOOL ret;\r
+\r
+       ret = VDS_DeleteVtoyEFIPartition(DriveIndex, EfiPartOffset);\r
+       if (!ret)\r
+       {\r
+               ret = PSHELL_DeleteVtoyEFIPartition(DriveIndex, EfiPartOffset);\r
+       }\r
+\r
+       return ret;\r
+}\r
+\r
+BOOL DISK_ChangeVtoyEFI2ESP(int DriveIndex, UINT64 Offset)\r
+{\r
+       BOOL ret;\r
+\r
+       ret = VDS_ChangeVtoyEFI2ESP(DriveIndex, Offset);\r
+       if (!ret)\r
+       {\r
+               ret = PSHELL_ChangeVtoyEFI2ESP(DriveIndex, Offset);\r
+       }\r
+\r
+       return ret;\r
+}\r
+\r
+\r
+BOOL DISK_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset)\r
+{\r
+       BOOL ret;\r
+\r
+       ret = VDS_ChangeVtoyEFI2Basic(DriveIndex, Offset);\r
+       if (!ret)\r
+       {\r
+               ret = PSHELL_ChangeVtoyEFI2Basic(DriveIndex, Offset);\r
+       }\r
+\r
+       return ret;\r
+}\r
+\r
+BOOL DISK_ChangeVtoyEFIAttr(int DriveIndex, UINT64 Offset, UINT64 Attr)\r
+{\r
+       BOOL ret;\r
+\r
+       ret = VDS_ChangeVtoyEFIAttr(DriveIndex, Offset, Attr);\r
+       \r
+       return ret;\r
+}\r
+\r
+BOOL DISK_ShrinkVolume(int DriveIndex, const char* VolumeGuid, CHAR DriveLetter, UINT64 OldBytes, UINT64 ReduceBytes)\r
+{\r
+       BOOL ret;\r
+\r
+       ret = VDS_ShrinkVolume(DriveIndex, VolumeGuid, DriveLetter, OldBytes, ReduceBytes);\r
+       if (!ret)\r
+       {\r
+               if (LASTERR == VDS_E_SHRINK_DIRTY_VOLUME)\r
+               {\r
+                       Log("VDS shrink return dirty, no need to run powershell.");\r
+               }\r
+               else\r
+               {\r
+                       ret = PSHELL_ShrinkVolume(DriveIndex, VolumeGuid, DriveLetter, OldBytes, ReduceBytes);\r
+               }\r
+       }\r
+\r
+       return ret;\r
+}\r
+\r

diff --git a/Ventoy2Disk/Ventoy2Disk/DiskService.h b/Ventoy2Disk/Ventoy2Disk/DiskService.h
index 3ccbc99925598f6a2f580ab64e5622b98a24e36b..78d6ec176ebb0a4c8a558a9a5c71b9ab4658d960 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/DiskService.h
+++ b/Ventoy2Disk/Ventoy2Disk/DiskService.h
@@ -29,24 +29,39 @@ typedef struct VDS_PARA
     WCHAR Name[36];\r
        ULONG NameLen;\r
     ULONGLONG Offset;\r
     WCHAR Name[36];\r
        ULONG NameLen;\r
     ULONGLONG Offset;\r

+       CHAR DriveLetter;\r

 }VDS_PARA;\r
 \r
 }VDS_PARA;\r
 \r

+//DISK API\r
+BOOL DISK_CleanDisk(int DriveIndex);\r
+BOOL DISK_DeleteVtoyEFIPartition(int DriveIndex, UINT64 EfiPartOffset);\r
+BOOL DISK_ChangeVtoyEFIAttr(int DriveIndex, UINT64 Offset, UINT64 Attr);\r
+BOOL DISK_ChangeVtoyEFI2ESP(int DriveIndex, UINT64 Offset);\r
+BOOL DISK_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset);\r
+BOOL DISK_ShrinkVolume(int DriveIndex, const char* VolumeGuid, CHAR DriveLetter, UINT64 OldBytes, UINT64 ReduceBytes);\r
+\r
+\r

 \r
 //VDS com\r
 \r
 //VDS com\r

-int  VDS_Init(void);\r

 BOOL VDS_CleanDisk(int DriveIndex);\r
 BOOL VDS_DeleteAllPartitions(int DriveIndex);\r
 BOOL VDS_CleanDisk(int DriveIndex);\r
 BOOL VDS_DeleteAllPartitions(int DriveIndex);\r

-BOOL VDS_DeleteVtoyEFIPartition(int DriveIndex);\r
-BOOL VDS_ChangeVtoyEFIAttr(int DriveIndex, UINT64 Attr);\r
-BOOL VDS_CreateVtoyEFIPart(int DriveIndex, UINT64 Offset);\r
+BOOL VDS_DeleteVtoyEFIPartition(int DriveIndex, UINT64 EfiPartOffset);\r
+BOOL VDS_ChangeVtoyEFIAttr(int DriveIndex, UINT64 Offset, UINT64 Attr);\r

 BOOL VDS_ChangeVtoyEFI2ESP(int DriveIndex, UINT64 Offset);\r
 BOOL VDS_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset);\r
 BOOL VDS_ChangeVtoyEFI2ESP(int DriveIndex, UINT64 Offset);\r
 BOOL VDS_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset);\r

-BOOL VDS_FormatVtoyEFIPart(int DriveIndex, UINT64 Offset);\r
-BOOL VDS_ShrinkVolume(const char* VolumeGuid, UINT64 ReduceBytes);\r
+BOOL VDS_ShrinkVolume(int DriveIndex, const char* VolumeGuid, CHAR DriveLetter, UINT64 OldBytes, UINT64 ReduceBytes);\r
+BOOL VDS_IsLastAvaliable(void);\r
+\r

 \r
 //diskpart.exe\r
 BOOL DSPT_CleanDisk(int DriveIndex);\r
 \r
 \r
 //diskpart.exe\r
 BOOL DSPT_CleanDisk(int DriveIndex);\r
 \r

+//powershell.exe\r
+BOOL PSHELL_CleanDisk(int DriveIndex);\r
+BOOL PSHELL_DeleteVtoyEFIPartition(int DriveIndex, UINT64 EfiPartOffset);\r
+BOOL PSHELL_ChangeVtoyEFI2ESP(int DriveIndex, UINT64 Offset);\r
+BOOL PSHELL_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset);\r
+BOOL PSHELL_ShrinkVolume(int DriveIndex, const char* VolumeGuid, CHAR DriveLetter, UINT64 OldBytes, UINT64 ReduceBytes);\r

 \r
 //\r
 // Internel define\r
 \r
 //\r
 // Internel define\r

diff --git a/Ventoy2Disk/Ventoy2Disk/DiskService_diskpart.c b/Ventoy2Disk/Ventoy2Disk/DiskService_diskpart.c
index e7c1dafb2740e169d26ecb1d0742526c6b06f421..ca1aa815be3801517b8a3a420b935bcdfc65fea0 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/DiskService_diskpart.c
+++ b/Ventoy2Disk/Ventoy2Disk/DiskService_diskpart.c
@@ -64,6 +64,9 @@ STATIC BOOL DSPT_CommProc(const char *Cmd)
     WaitForSingleObject(Pi.hProcess, INFINITE);\r
     Log("Process finished...");\r
 \r
     WaitForSingleObject(Pi.hProcess, INFINITE);\r
     Log("Process finished...");\r
 \r

+    CHECK_CLOSE_HANDLE(Pi.hProcess);\r
+    CHECK_CLOSE_HANDLE(Pi.hThread);\r
+\r

     DeleteFileA(CmdFile);\r
     return TRUE;\r
 }\r
     DeleteFileA(CmdFile);\r
     return TRUE;\r
 }\r

diff --git a/Ventoy2Disk/Ventoy2Disk/DiskService_vds.c b/Ventoy2Disk/Ventoy2Disk/DiskService_vds.c
index c53cc44aff952fa135382cd46d45d34b28661968..f930559e20ddacc06b6ba4ec5aa5df00a076f000 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/DiskService_vds.c
+++ b/Ventoy2Disk/Ventoy2Disk/DiskService_vds.c
@@ -390,6 +390,10 @@ static const char *GetVdsError(DWORD error_code)
                return "The offline operation failed.";\r
        case 0x80042598:        // VDS_E_BAD_REVISION_NUMBER\r
                return "The operation could not be completed because the specified revision number is not supported.";\r
                return "The offline operation failed.";\r
        case 0x80042598:        // VDS_E_BAD_REVISION_NUMBER\r
                return "The operation could not be completed because the specified revision number is not supported.";\r

+       case 0x80042599:    // VDS_E_SHRINK_USER_CANCELLED\r
+               return "The shrink operation was cancelled by the user.";\r
+       case 0x8004259a:    // VDS_E_SHRINK_DIRTY_VOLUME\r
+               return "The volume you have selected to shrink may be corrupted. Use Chkdsk to fix the corruption problem, and then try again.";\r

        case 0x00042700:        // VDS_S_NAME_TRUNCATED\r
                return "The name was set successfully but had to be truncated.";\r
        case 0x80042701:        // VDS_E_NAME_NOT_UNIQUE\r
        case 0x00042700:        // VDS_S_NAME_TRUNCATED\r
                return "The name was set successfully but had to be truncated.";\r
        case 0x80042701:        // VDS_E_NAME_NOT_UNIQUE\r


@@ -601,6 +605,13 @@ const char *WindowsErrorString(DWORD error_code)
 \r
 typedef BOOL(*VDS_Callback_PF)(void *pInterface, VDS_DISK_PROP *pDiskProp, UINT64 data);\r
 \r
 \r
 typedef BOOL(*VDS_Callback_PF)(void *pInterface, VDS_DISK_PROP *pDiskProp, UINT64 data);\r
 \r

+static BOOL g_vds_available = TRUE;\r
+\r
+BOOL VDS_IsLastAvaliable(void)\r
+{\r
+       return g_vds_available;\r
+}\r
+\r

 STATIC IVdsService * VDS_InitService(void)\r
 {\r
     HRESULT hr;\r
 STATIC IVdsService * VDS_InitService(void)\r
 {\r
     HRESULT hr;\r


@@ -627,6 +638,7 @@ STATIC IVdsService * VDS_InitService(void)
     {\r
         VDS_SET_ERROR(hr);\r
         Log("Could not load VDS Service: 0x%x", LASTERR);\r
     {\r
         VDS_SET_ERROR(hr);\r
         Log("Could not load VDS Service: 0x%x", LASTERR);\r

+               g_vds_available = FALSE;\r

         return NULL;\r
     }\r
 \r
         return NULL;\r
     }\r
 \r


@@ -640,6 +652,7 @@ STATIC IVdsService * VDS_InitService(void)
     }\r
 \r
     Log("VDS init OK, service %p", pService);\r
     }\r
 \r
     Log("VDS init OK, service %p", pService);\r

+       g_vds_available = TRUE;\r

     return pService;\r
 }\r
 \r
     return pService;\r
 }\r
 \r


@@ -1061,16 +1074,16 @@ STATIC BOOL VDS_CallBack_DeletePartition(void *pInterface, VDS_DISK_PROP *pDiskP
     HRESULT hr;\r
     VDS_PARTITION_PROP* prop_array = NULL;\r
     LONG i, prop_array_size;\r
     HRESULT hr;\r
     VDS_PARTITION_PROP* prop_array = NULL;\r
     LONG i, prop_array_size;\r

-    ULONG PartNumber = (ULONG)data;\r
+    UINT64 PartOffset = data;\r

        IVdsAdvancedDisk *pAdvancedDisk = (IVdsAdvancedDisk *)pInterface;\r
 \r
        IVdsAdvancedDisk *pAdvancedDisk = (IVdsAdvancedDisk *)pInterface;\r
 \r

-    if (PartNumber == 0)\r
+       if (PartOffset == 0)\r

     {\r
         Log("Deleting ALL partitions from disk '%S':", pDiskProp->pwszName);\r
     }\r
     else\r
     {\r
     {\r
         Log("Deleting ALL partitions from disk '%S':", pDiskProp->pwszName);\r
     }\r
     else\r
     {\r

-               Log("Deleting partition(%ld) from disk '%S':", PartNumber, pDiskProp->pwszName);\r
+               Log("Deleting partition(offset=%llu) from disk '%S':", PartOffset, pDiskProp->pwszName);\r

     }\r
 \r
     // Query the partition data, so we can get the start offset, which we need for deletion\r
     }\r
 \r
     // Query the partition data, so we can get the start offset, which we need for deletion\r


@@ -1080,7 +1093,7 @@ STATIC BOOL VDS_CallBack_DeletePartition(void *pInterface, VDS_DISK_PROP *pDiskP
                r = TRUE;\r
         for (i = 0; i < prop_array_size; i++) \r
         {\r
                r = TRUE;\r
         for (i = 0; i < prop_array_size; i++) \r
         {\r

-            if (PartNumber == 0 || PartNumber == prop_array[i].ulPartitionNumber)\r
+                       if (PartOffset == 0 || PartOffset == prop_array[i].ullOffset)\r

             {\r
                 Log("* Partition %d (offset: %lld, size: %llu) delete it.",\r
                     prop_array[i].ulPartitionNumber, prop_array[i].ullOffset, (ULONGLONG)prop_array[i].ullSize);\r
             {\r
                 Log("* Partition %d (offset: %lld, size: %llu) delete it.",\r
                     prop_array[i].ulPartitionNumber, prop_array[i].ullOffset, (ULONGLONG)prop_array[i].ullSize);\r


@@ -1127,9 +1140,9 @@ BOOL VDS_DeleteAllPartitions(int DriveIndex)
     return ret;\r
 }\r
 \r
     return ret;\r
 }\r
 \r

-BOOL VDS_DeleteVtoyEFIPartition(int DriveIndex)\r
+BOOL VDS_DeleteVtoyEFIPartition(int DriveIndex, UINT64 EfiPartOffset)\r

 {\r
 {\r

-       BOOL ret = VDS_DiskCommProc(INTF_ADVANCEDDISK, DriveIndex, VDS_CallBack_DeletePartition, 2);\r
+       BOOL ret = VDS_DiskCommProc(INTF_ADVANCEDDISK, DriveIndex, VDS_CallBack_DeletePartition, EfiPartOffset);\r

        Log("VDS_DeleteVtoyEFIPartition %d ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
     return ret;\r
 }\r
        Log("VDS_DeleteVtoyEFIPartition %d ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
     return ret;\r
 }\r


@@ -1138,6 +1151,7 @@ STATIC BOOL VDS_CallBack_ChangeEFIAttr(void *pInterface, VDS_DISK_PROP *pDiskPro
 {\r
     BOOL r = FALSE;\r
     HRESULT hr;\r
 {\r
     BOOL r = FALSE;\r
     HRESULT hr;\r

+       VDS_PARA *VdsPara = (VDS_PARA *)data;\r

     VDS_PARTITION_PROP* prop_array = NULL;\r
     LONG i, prop_array_size;\r
     CHANGE_ATTRIBUTES_PARAMETERS AttrPara;\r
     VDS_PARTITION_PROP* prop_array = NULL;\r
     LONG i, prop_array_size;\r
     CHANGE_ATTRIBUTES_PARAMETERS AttrPara;\r


@@ -1151,12 +1165,13 @@ STATIC BOOL VDS_CallBack_ChangeEFIAttr(void *pInterface, VDS_DISK_PROP *pDiskPro
         {\r
             if (prop_array[i].ullSize == VENTOY_EFI_PART_SIZE &&\r
                 prop_array[i].PartitionStyle == VDS_PST_GPT &&\r
         {\r
             if (prop_array[i].ullSize == VENTOY_EFI_PART_SIZE &&\r
                 prop_array[i].PartitionStyle == VDS_PST_GPT &&\r

-                memcmp(prop_array[i].Gpt.name, L"VTOYEFI", 7 * 2) == 0)\r
+                memcmp(prop_array[i].Gpt.name, L"VTOYEFI", 7 * 2) == 0 &&\r
+                               VdsPara->Offset == prop_array[i].ullOffset)\r

             {\r
             {\r

-                Log("* Partition %d (offset: %lld, size: %llu, Attr:0x%llx)", prop_array[i].ulPartitionNumber,\r
+                Log("** Partition %d (offset: %lld, size: %llu, Attr:0x%llx)", prop_array[i].ulPartitionNumber,\r

                     prop_array[i].ullOffset, (ULONGLONG)prop_array[i].ullSize, prop_array[i].Gpt.attributes);\r
 \r
                     prop_array[i].ullOffset, (ULONGLONG)prop_array[i].ullSize, prop_array[i].Gpt.attributes);\r
 \r

-                if (prop_array[i].Gpt.attributes == data)\r
+                               if (prop_array[i].Gpt.attributes == VdsPara->Attr)\r

                 {\r
                     Log("Attribute match, No need to change.");\r
                     r = TRUE;\r
                 {\r
                     Log("Attribute match, No need to change.");\r
                     r = TRUE;\r


@@ -1164,7 +1179,7 @@ STATIC BOOL VDS_CallBack_ChangeEFIAttr(void *pInterface, VDS_DISK_PROP *pDiskPro
                 else\r
                 {\r
                     AttrPara.style = VDS_PST_GPT;\r
                 else\r
                 {\r
                     AttrPara.style = VDS_PST_GPT;\r

-                    AttrPara.GptPartInfo.attributes = data;\r
+                                       AttrPara.GptPartInfo.attributes = VdsPara->Attr;\r

                     hr = IVdsAdvancedDisk_ChangeAttributes(pAdvancedDisk, prop_array[i].ullOffset, &AttrPara);\r
                     if (hr == S_OK)\r
                     {\r
                     hr = IVdsAdvancedDisk_ChangeAttributes(pAdvancedDisk, prop_array[i].ullOffset, &AttrPara);\r
                     if (hr == S_OK)\r
                     {\r


@@ -1191,10 +1206,15 @@ STATIC BOOL VDS_CallBack_ChangeEFIAttr(void *pInterface, VDS_DISK_PROP *pDiskPro
     return r;\r
 }\r
 \r
     return r;\r
 }\r
 \r

-BOOL VDS_ChangeVtoyEFIAttr(int DriveIndex, UINT64 Attr)\r
+BOOL VDS_ChangeVtoyEFIAttr(int DriveIndex, UINT64 Offset, UINT64 Attr)\r

 {\r
 {\r

-       BOOL ret = VDS_DiskCommProc(INTF_ADVANCEDDISK, DriveIndex, VDS_CallBack_ChangeEFIAttr, Attr);    \r
-       Log("VDS_ChangeVtoyEFIAttr %d ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
+       VDS_PARA Para;\r
+\r
+       Para.Attr = Attr;\r
+       Para.Offset = Offset;\r
+\r
+       BOOL ret = VDS_DiskCommProc(INTF_ADVANCEDDISK, DriveIndex, VDS_CallBack_ChangeEFIAttr, (UINT64)&Para);\r
+       Log("VDS_ChangeVtoyEFIAttr %d (offset:%llu) ret:%d (%s)", DriveIndex, Offset, ret, ret ? "SUCCESS" : "FAIL");\r

     return ret;\r
 }\r
 \r
     return ret;\r
 }\r
 \r


@@ -1238,6 +1258,7 @@ BOOL VDS_ChangeVtoyEFI2ESP(int DriveIndex, UINT64 Offset)
        return ret;\r
 }\r
 \r
        return ret;\r
 }\r
 \r

+\r

 BOOL VDS_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset)\r
 {\r
        VDS_PARA Para;\r
 BOOL VDS_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset)\r
 {\r
        VDS_PARA Para;\r


@@ -1251,154 +1272,70 @@ BOOL VDS_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset)
        return ret;\r
 }\r
 \r
        return ret;\r
 }\r
 \r

-\r
-STATIC BOOL VDS_CallBack_CreateVtoyEFI(void *pInterface, VDS_DISK_PROP *pDiskProp, UINT64 data)\r
+STATIC BOOL CHKDSK_Volume(CHAR LogicalDrive)\r

 {\r
 {\r

-    HRESULT hr, hr2;\r
-    ULONG completed;\r
-    IVdsAsync* pAsync;\r
-       CREATE_PARTITION_PARAMETERS para;\r
-       IVdsCreatePartitionEx *pCreatePartitionEx = (IVdsCreatePartitionEx *)pInterface;\r
-    VDS_PARA *VdsPara = (VDS_PARA *)data;\r
-\r
-    (void)pDiskProp;\r
-\r
-    memset(&para, 0, sizeof(para));\r
-    para.style = VDS_PST_GPT;\r
-    memcpy(&(para.GptPartInfo.partitionType), &VdsPara->Type, sizeof(GUID));\r
-    memcpy(&(para.GptPartInfo.partitionId), &VdsPara->Id, sizeof(GUID));\r
-       para.GptPartInfo.attributes = VdsPara->Attr;\r
-       memcpy(para.GptPartInfo.name, VdsPara->Name, sizeof(WCHAR)* VdsPara->NameLen);\r
+       CHAR CmdBuf[1024];\r
+       STARTUPINFOA Si;\r
+       PROCESS_INFORMATION Pi;\r

 \r
 \r

-       hr = IVdsCreatePartitionEx_CreatePartitionEx(pCreatePartitionEx, VdsPara->Offset, VENTOY_EFI_PART_SIZE, 512, &para, &pAsync);\r
-    while (SUCCEEDED(hr))\r
-    {\r
-        hr = IVdsAsync_QueryStatus(pAsync, &hr2, &completed);\r
-        if (SUCCEEDED(hr))\r
-        {\r
-            hr = hr2;\r
-            if (hr == S_OK)\r
-            {\r
-                               Log("Disk create partition QueryStatus OK, %lu%%", completed);\r
-                break;\r
-            }\r
-            else if (hr == VDS_E_OPERATION_PENDING)\r
-            {\r
-                               Log("Disk partition finish: %lu%%", completed);\r
-                hr = S_OK;\r
-            }\r
-            else\r
-            {\r
-                Log("QueryStatus invalid status:0x%lx", hr);\r
-            }\r
-        }\r
-        Sleep(1000);\r
-    }\r
+       if ((!IsFileExist("C:\\Windows\\System32\\chkdsk.exe")) || (LogicalDrive == 0))\r
+       {\r
+               return FALSE;\r
+       }\r

 \r
 \r

-    if (hr != S_OK)\r
-    {\r
-        VDS_SET_ERROR(hr);\r
-               Log("Could not create partition, err:0x%lx(%s)", LASTERR, WindowsErrorString(hr));\r
-        return FALSE;\r
-    }\r
+       GetStartupInfoA(&Si);\r
+       Si.dwFlags |= STARTF_USESHOWWINDOW;\r
+       Si.wShowWindow = SW_HIDE;\r

 \r
 \r

-    return TRUE;\r
-}\r
+       sprintf_s(CmdBuf, sizeof(CmdBuf), "C:\\Windows\\System32\\chkdsk.exe %C: /f", LogicalDrive);\r

 \r
 \r

-BOOL VDS_CreateVtoyEFIPart(int DriveIndex, UINT64 Offset)\r
-{\r
-    VDS_PARA Para;\r
-    GUID WindowsDataPartType = { 0xebd0a0a2, 0xb9e5, 0x4433, { 0x87, 0xc0, 0x68, 0xb6, 0xb7, 0x26, 0x99, 0xc7 } };\r
-       GUID EspPartType = { 0xc12a7328, 0xf81f, 0x11d2, { 0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b } };\r
+       Log("CreateProcess <%s>", CmdBuf);\r
+       CreateProcessA(NULL, CmdBuf, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);\r

 \r
 \r

-       Log("VDS_CreateVtoyEFIPart %u Offset:%llu Sector:%llu", DriveIndex, Offset, Offset / 512);\r
+       Log("Wair process ...");\r
+       WaitForSingleObject(Pi.hProcess, INFINITE);\r
+       Log("Process finished...");\r

 \r
 \r

-    memset(&Para, 0, sizeof(Para));\r
-    Para.Attr = 0x8000000000000000ULL;\r
-    Para.Offset = Offset;\r
-    memcpy(Para.Name, L"VTOYEFI", 7 * 2);\r
-       Para.NameLen = 7;\r
-       memcpy(&(Para.Type), &EspPartType, sizeof(GUID));\r
-    CoCreateGuid(&(Para.Id));\r
+       CHECK_CLOSE_HANDLE(Pi.hProcess);\r
+       CHECK_CLOSE_HANDLE(Pi.hThread);\r

 \r
 \r

-       BOOL ret = VDS_DiskCommProc(INTF_CREATEPARTITIONEX, DriveIndex, VDS_CallBack_CreateVtoyEFI, (UINT64)&Para);\r
-       Log("VDS_CreateVtoyEFIPart %d ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
-    return ret; \r
+       return TRUE;\r

 }\r
 \r
 \r
 }\r
 \r
 \r

-STATIC BOOL VDS_CallBack_FormatVtoyEFI(void *pInterface, VDS_DISK_PROP *pDiskProp, UINT64 data)\r
+STATIC BOOL VDS_CallBack_ShrinkVolume(void* pInterface, VDS_DISK_PROP* pDiskProp, UINT64 data)\r

 {\r
 {\r

+       int i;\r

        HRESULT hr, hr2;\r
        HRESULT hr, hr2;\r

+       IVdsVolume* pVolume = (IVdsVolume*)pInterface;\r

        ULONG completed;\r
        ULONG completed;\r

-       IVdsAsync* pAsync;      \r
-       IVdsDiskPartitionMF *pPartitionMF = (IVdsDiskPartitionMF *)pInterface;\r
+       IVdsAsync* pAsync;\r

        VDS_PARA *VdsPara = (VDS_PARA *)data;\r
 \r
        (void)pDiskProp;\r
        VDS_PARA *VdsPara = (VDS_PARA *)data;\r
 \r
        (void)pDiskProp;\r

-       \r
-       hr = IVdsPartitionMF_FormatPartitionEx(pPartitionMF, VdsPara->Offset, L"FAT", 0x0100, 0, VdsPara->Name, TRUE, TRUE, FALSE, &pAsync);\r
-       while (SUCCEEDED(hr))\r
+\r
+       Log("VDS_CallBack_ShrinkVolume (%C:) (%llu) ...", VdsPara->DriveLetter, (ULONGLONG)VdsPara->Offset);\r
+\r
+       hr = IVdsVolume_Shrink(pVolume, (ULONGLONG)VdsPara->Offset, &pAsync);\r
+       if (hr == VDS_E_SHRINK_DIRTY_VOLUME)\r

        {\r
        {\r

-               hr = IVdsAsync_QueryStatus(pAsync, &hr2, &completed);\r
-               if (SUCCEEDED(hr))\r
+               Log("Volume %C: is dirty, run chkdsk and retry.", VdsPara->DriveLetter);\r
+               CHKDSK_Volume(VdsPara->DriveLetter);\r
+\r
+               hr = IVdsVolume_Shrink(pVolume, (ULONGLONG)VdsPara->Offset, &pAsync);\r
+               if (hr == VDS_E_SHRINK_DIRTY_VOLUME)\r

                {\r
                {\r

-                       hr = hr2;\r
-                       if (hr == S_OK)\r
-                       {\r
-                               Log("Disk format partition QueryStatus OK, %lu%%", completed);\r
-                               break;\r
-                       }\r
-                       else if (hr == VDS_E_OPERATION_PENDING)\r
+                       Log("################################################################");\r
+                       Log("################################################################");\r
+                       for (i = 0; i < 20; i++)\r

                        {\r
                        {\r

-                               Log("Disk format finish: %lu%%", completed);\r
-                               hr = S_OK;\r
-                       }\r
-                       else\r
-                       {\r
-                               Log("QueryStatus invalid status:0x%lx", hr);\r
+                               Log("###### Volume dirty, Please run \"chkdsk /f %C:\" and retry. ######", VdsPara->Name[0]);\r

                        }\r
                        }\r

+                       Log("################################################################");\r
+                       Log("################################################################");\r

                }\r
                }\r

-               Sleep(1000);\r
-       }\r
-\r
-       if (hr != S_OK)\r
-       {\r
-               VDS_SET_ERROR(hr);\r
-               Log("Could not format partition, err:0x%lx (%s)", LASTERR, WindowsErrorString(hr));\r
-               return FALSE;\r

        }\r
 \r
        }\r
 \r

-       return TRUE;\r
-}\r
-\r
-// Not supported for removable disk\r
-BOOL VDS_FormatVtoyEFIPart(int DriveIndex, UINT64 Offset)\r
-{\r
-       VDS_PARA Para;\r
-\r
-       memset(&Para, 0, sizeof(Para));\r
-       Para.Offset = Offset;\r
-       memcpy(Para.Name, L"VTOYEFI", 7 * 2);\r
-\r
-       BOOL ret = VDS_DiskCommProc(INTF_PARTITIONMF, DriveIndex, VDS_CallBack_FormatVtoyEFI, (UINT64)&Para);\r
-       Log("VDS_FormatVtoyEFIPart %d ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
-       return ret;\r
-}\r
-\r
-STATIC BOOL VDS_CallBack_ShrinkVolume(void* pInterface, VDS_DISK_PROP* pDiskProp, UINT64 data)\r
-{\r
-       HRESULT hr, hr2;\r
-       IVdsVolume* pVolume = (IVdsVolume*)pInterface;\r
-       ULONG completed;\r
-       IVdsAsync* pAsync;\r
-\r
-       (void)pDiskProp;\r
-\r
-       Log("VDS_CallBack_ShrinkVolume (%llu) ...", (ULONGLONG)data);\r
-\r
-       hr = IVdsVolume_Shrink(pVolume, (ULONGLONG)data, &pAsync);\r
-\r

        while (SUCCEEDED(hr))\r
        {\r
                hr = IVdsAsync_QueryStatus(pAsync, &hr2, &completed);\r
        while (SUCCEEDED(hr))\r
        {\r
                hr = IVdsAsync_QueryStatus(pAsync, &hr2, &completed);\r


@@ -1427,18 +1364,24 @@ STATIC BOOL VDS_CallBack_ShrinkVolume(void* pInterface, VDS_DISK_PROP* pDiskProp
        {\r
                VDS_SET_ERROR(hr);\r
                Log("Could not ShrinkVolume, 0x%x err:0x%lx (%s)", hr, LASTERR, WindowsErrorString(hr));\r
        {\r
                VDS_SET_ERROR(hr);\r
                Log("Could not ShrinkVolume, 0x%x err:0x%lx (%s)", hr, LASTERR, WindowsErrorString(hr));\r

+\r
+               VDS_SET_ERROR(hr);\r

                return FALSE;\r
        }\r
 \r
        return TRUE;\r
 }\r
 \r
                return FALSE;\r
        }\r
 \r
        return TRUE;\r
 }\r
 \r

-BOOL VDS_ShrinkVolume(const char* VolumeGuid, UINT64 ReduceBytes)\r
+BOOL VDS_ShrinkVolume(int DriveIndex, const char* VolumeGuid, CHAR DriveLetter, UINT64 OldBytes, UINT64 ReduceBytes)\r

 {\r
        int i;\r
        BOOL ret = FALSE;\r
        WCHAR wGuid[128] = { 0 };\r
        const char *guid = NULL;\r
 {\r
        int i;\r
        BOOL ret = FALSE;\r
        WCHAR wGuid[128] = { 0 };\r
        const char *guid = NULL;\r

+       VDS_PARA Para;\r
+\r
+       (VOID)DriveIndex;\r
+       (VOID)OldBytes;\r

 \r
        guid = strstr(VolumeGuid, "{");\r
        if (!guid)\r
 \r
        guid = strstr(VolumeGuid, "{");\r
        if (!guid)\r


@@ -1451,7 +1394,10 @@ BOOL VDS_ShrinkVolume(const char* VolumeGuid, UINT64 ReduceBytes)
                wGuid[i] = guid[i];\r
        }\r
 \r
                wGuid[i] = guid[i];\r
        }\r
 \r

-       ret = VDS_VolumeCommProc(INTF_VOLUME, wGuid, VDS_CallBack_ShrinkVolume, ReduceBytes);\r
-       Log("VDS_ShrinkVolume ret:%d (%s)", ret, ret ? "SUCCESS" : "FAIL");\r
+       Para.Offset = ReduceBytes;\r
+       Para.DriveLetter = DriveLetter;\r
+\r
+       ret = VDS_VolumeCommProc(INTF_VOLUME, wGuid, VDS_CallBack_ShrinkVolume, (UINT64)&Para);\r
+       Log("VDS_ShrinkVolume %C: ret:%d (%s)", DriveLetter, ret, ret ? "SUCCESS" : "FAIL");\r

        return ret;\r
 }
\ No newline at end of file
        return ret;\r
 }
\ No newline at end of file

diff --git a/Ventoy2Disk/Ventoy2Disk/DiskService_wmsa.c b/Ventoy2Disk/Ventoy2Disk/DiskService_wmsa.c
index c5af4ccc6fdf64043a3a5839df116a9f1df06594..d99e5ac10eb260407b7937ec1a8c11876eb58e00 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/DiskService_wmsa.c
+++ b/Ventoy2Disk/Ventoy2Disk/DiskService_wmsa.c
@@ -23,5 +23,235 @@
 #include <commctrl.h>\r
 #include <initguid.h>\r
 #include <vds.h>\r
 #include <commctrl.h>\r
 #include <initguid.h>\r
 #include <vds.h>\r

+#include <VersionHelpers.h>\r

 #include "Ventoy2Disk.h"\r
 #include "DiskService.h"\r
 #include "Ventoy2Disk.h"\r
 #include "DiskService.h"\r

+\r
+STATIC BOOL IsPowershellExist(void)\r
+{\r
+       BOOL ret;\r
+\r
+       if (!IsWindows8OrGreater())\r
+       {\r
+               Log("This is before Windows8 powershell disk not supported.");\r
+               return FALSE;\r
+       }\r
+\r
+       ret = IsFileExist("C:\\Windows\\system32\\WindowsPowerShell\\v1.0\\powershell.exe");\r
+       if (!ret)\r
+       {\r
+               Log("powershell.exe not exist");\r
+       }\r
+\r
+       return ret;\r
+}\r
+\r
+int PSHELL_GetPartitionNumber(int PhyDrive, UINT64 Offset)\r
+{\r
+       int partnum = -1;\r
+       DWORD i = 0;\r
+       DWORD BufLen = 0;\r
+       DWORD dwBytes = 0;\r
+       BOOL bRet;\r
+       HANDLE hDrive;\r
+       LONGLONG PartStart;\r
+       DRIVE_LAYOUT_INFORMATION_EX *pDriveLayout = NULL;\r
+\r
+       Log("PSHELL_GetPartitionNumber PhyDrive:%d Offset:%llu", PhyDrive, Offset);\r
+\r
+       hDrive = GetPhysicalHandle(PhyDrive, FALSE, FALSE, FALSE);\r
+       if (hDrive == INVALID_HANDLE_VALUE)\r
+       {\r
+               return -1;\r
+       }\r
+\r
+       BufLen = (DWORD)(sizeof(PARTITION_INFORMATION_EX)* 256);\r
+\r
+       pDriveLayout = malloc(BufLen);\r
+       if (!pDriveLayout)\r
+       {\r
+               goto out;\r
+       }\r
+       memset(pDriveLayout, 0, BufLen);\r
+\r
+       bRet = DeviceIoControl(hDrive,\r
+               IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL,\r
+               0,\r
+               pDriveLayout,\r
+               BufLen,\r
+               &dwBytes,\r
+               NULL);\r
+       if (!bRet)\r
+       {\r
+               Log("Failed to ioctrl get drive layout ex %u", LASTERR);\r
+               goto out;\r
+       }\r
+\r
+       Log("PhyDrive:%d  PartitionStyle=%s  PartitionCount=%u", PhyDrive,\r
+               (pDriveLayout->PartitionStyle == PARTITION_STYLE_MBR) ? "MBR" : "GPT", pDriveLayout->PartitionCount);\r
+\r
+       for (i = 0; i < pDriveLayout->PartitionCount; i++)\r
+       {\r
+               PartStart = pDriveLayout->PartitionEntry[i].StartingOffset.QuadPart;\r
+               if (PartStart == (LONGLONG)Offset)\r
+               {\r
+                       Log("[*] [%d] PartitionNumber=%u Offset=%lld Length=%lld ",\r
+                               i,\r
+                               pDriveLayout->PartitionEntry[i].PartitionNumber,\r
+                               pDriveLayout->PartitionEntry[i].StartingOffset.QuadPart,\r
+                               pDriveLayout->PartitionEntry[i].PartitionLength.QuadPart\r
+                               );\r
+                       partnum = (int)pDriveLayout->PartitionEntry[i].PartitionNumber;\r
+               }\r
+               else\r
+               {\r
+                       Log("[ ] [%d] PartitionNumber=%u Offset=%lld Length=%lld ",\r
+                               i,\r
+                               pDriveLayout->PartitionEntry[i].PartitionNumber,\r
+                               pDriveLayout->PartitionEntry[i].StartingOffset.QuadPart,\r
+                               pDriveLayout->PartitionEntry[i].PartitionLength.QuadPart\r
+                               );\r
+               }\r
+       }\r
+\r
+out:\r
+\r
+       CHECK_CLOSE_HANDLE(hDrive);\r
+       CHECK_FREE(pDriveLayout);\r
+\r
+       return partnum;\r
+}\r
+\r
+\r
+STATIC BOOL PSHELL_CommProc(const char *Cmd)\r
+{\r
+       CHAR CmdBuf[4096];\r
+       STARTUPINFOA Si;\r
+       PROCESS_INFORMATION Pi;\r
+\r
+       if (!IsPowershellExist())\r
+       {\r
+               return FALSE;\r
+       }\r
+\r
+       GetStartupInfoA(&Si);\r
+       Si.dwFlags |= STARTF_USESHOWWINDOW;\r
+       Si.wShowWindow = SW_HIDE;\r
+\r
+       sprintf_s(CmdBuf, sizeof(CmdBuf), "C:\\Windows\\system32\\WindowsPowerShell\\v1.0\\powershell.exe -Command \"&{ %s }\"", Cmd);\r
+\r
+       Log("CreateProcess <%s>", CmdBuf);\r
+       CreateProcessA(NULL, CmdBuf, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);\r
+\r
+       Log("Wair process ...");\r
+       WaitForSingleObject(Pi.hProcess, INFINITE);\r
+       Log("Process finished...");\r
+\r
+       CHECK_CLOSE_HANDLE(Pi.hProcess);\r
+       CHECK_CLOSE_HANDLE(Pi.hThread);\r
+\r
+       return TRUE;\r
+}\r
+\r
+\r
+BOOL PSHELL_CleanDisk(int DriveIndex)\r
+{\r
+       BOOL ret;\r
+       CHAR CmdBuf[512];\r
+\r
+       sprintf_s(CmdBuf, sizeof(CmdBuf), "Clear-Disk -Number %d -RemoveData -RemoveOEM -Confirm:$false", DriveIndex);\r
+       ret = PSHELL_CommProc(CmdBuf);\r
+       Log("CleanDiskByPowershell<%d> ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
+\r
+       return ret;\r
+}\r
+\r
+\r
+BOOL PSHELL_DeleteVtoyEFIPartition(int DriveIndex, UINT64 EfiPartOffset)\r
+{\r
+       int Part;\r
+       BOOL ret;\r
+       CHAR CmdBuf[512];\r
+\r
+       Part = PSHELL_GetPartitionNumber(DriveIndex, EfiPartOffset);\r
+       if (Part < 0)\r
+       {\r
+               ret = FALSE;\r
+       }\r
+       else\r
+       {\r
+               sprintf_s(CmdBuf, sizeof(CmdBuf), "Remove-Partition -DiskNumber %d -PartitionNumber %d -Confirm:$false", DriveIndex, Part);\r
+               ret = PSHELL_CommProc(CmdBuf);\r
+       }\r
+       \r
+       Log("PSHELL_DeleteVtoyEFIPartition<%d> ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
+       return ret;\r
+}\r
+\r
+\r
+BOOL PSHELL_ChangeVtoyEFI2ESP(int DriveIndex, UINT64 Offset)\r
+{\r
+       int Part;\r
+       BOOL ret;\r
+       CHAR CmdBuf[512];\r
+\r
+       Part = PSHELL_GetPartitionNumber(DriveIndex, Offset);\r
+       if (Part < 0)\r
+       {\r
+               ret = FALSE;\r
+       }\r
+       else\r
+       {\r
+               sprintf_s(CmdBuf, sizeof(CmdBuf), "Set-Partition -DiskNumber %d -PartitionNumber %d -gpttype '{C12A7328-F81F-11D2-BA4B-00A0C93EC93B}' -Confirm:$false", DriveIndex, Part);\r
+               ret = PSHELL_CommProc(CmdBuf);\r
+       }\r
+\r
+       Log("PSHELL_ChangeVtoyEFI2ESP<%d> ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
+       return ret;\r
+}\r
+\r
+\r
+BOOL PSHELL_ChangeVtoyEFI2Basic(int DriveIndex, UINT64 Offset)\r
+{\r
+       int Part;\r
+       BOOL ret;\r
+       CHAR CmdBuf[512];\r
+\r
+       Part = PSHELL_GetPartitionNumber(DriveIndex, Offset);\r
+       if (Part < 0)\r
+       {\r
+               ret = FALSE;\r
+       }\r
+       else\r
+       {\r
+               sprintf_s(CmdBuf, sizeof(CmdBuf), "Set-Partition -DiskNumber %d -PartitionNumber %d -gpttype '{ebd0a0a2-b9e5-4433-87c0-68b6b72699c7}' -Confirm:$false", DriveIndex, Part);\r
+               ret = PSHELL_CommProc(CmdBuf);\r
+       }\r
+       \r
+       Log("PSHELL_ChangeVtoyEFI2Basic<%d> ret:%d (%s)", DriveIndex, ret, ret ? "SUCCESS" : "FAIL");\r
+       return ret;\r
+}\r
+\r
+BOOL PSHELL_ShrinkVolume(int DriveIndex, const char* VolumeGuid, CHAR DriveLetter, UINT64 OldBytes, UINT64 ReduceBytes)\r
+{\r
+       int Part;\r
+       BOOL ret;\r
+       CHAR CmdBuf[512];\r
+\r
+       (void)VolumeGuid;\r
+\r
+       Part = PSHELL_GetPartitionNumber(DriveIndex, SIZE_1MB);\r
+       if (Part < 0)\r
+       {\r
+               ret = FALSE;\r
+       }\r
+       else\r
+       {\r
+               sprintf_s(CmdBuf, sizeof(CmdBuf), "Resize-Partition -DiskNumber %d -PartitionNumber %d -Size %llu -Confirm:$false", \r
+                       DriveIndex, Part, OldBytes - ReduceBytes);\r
+               ret = PSHELL_CommProc(CmdBuf);\r
+       }\r
+\r
+       Log("PSHELL_ShrinkVolume<%d> %C: ret:%d (%s)", DriveIndex, DriveLetter, ret, ret ? "SUCCESS" : "FAIL");\r
+       return ret;\r
+}\r

diff --git a/Ventoy2Disk/Ventoy2Disk/PhyDrive.c b/Ventoy2Disk/Ventoy2Disk/PhyDrive.c
index 182a718e5af1dfad45559ce4eac91ec8e53b5759..b079eb18ec60d827e000e3c2bc661f11164b39ca 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/PhyDrive.c
+++ b/Ventoy2Disk/Ventoy2Disk/PhyDrive.c
@@ -1127,9 +1127,17 @@ static int FormatPart1exFAT(UINT64 DiskSizeBytes)
 \r
     Log("Formatting Part1 exFAT ...");\r
 \r
 \r
     Log("Formatting Part1 exFAT ...");\r
 \r

+       disk_io_reset_write_error();\r
+\r

     Ret = f_mkfs(TEXT("0:"), &Option, 0, 8 * 1024 * 1024);\r
     if (FR_OK == Ret)\r
     {\r
     Ret = f_mkfs(TEXT("0:"), &Option, 0, 8 * 1024 * 1024);\r
     if (FR_OK == Ret)\r
     {\r

+               if (disk_io_is_write_error())\r
+               {\r
+                       Log("Formatting Part1 exFAT failed, write error.");\r
+                       return 1;\r
+               }\r
+\r

         Log("Formatting Part1 exFAT success");\r
         return 0;\r
     }\r
         Log("Formatting Part1 exFAT success");\r
         return 0;\r
     }\r


@@ -1851,7 +1859,18 @@ End:
     }\r
     else\r
     {\r
     }\r
     else\r
     {\r

+               PROGRESS_BAR_SET_POS(PT_LOCK_FOR_CLEAN);\r
+\r

         FindProcessOccupyDisk(hDrive, pPhyDrive);\r
         FindProcessOccupyDisk(hDrive, pPhyDrive);\r

+\r
+               if (!VDS_IsLastAvaliable())\r
+               {\r
+                       Log("###### [Error:] Virtual Disk Service (VDS) Unavailable ######");\r
+                       Log("###### [Error:] Virtual Disk Service (VDS) Unavailable ######");\r
+                       Log("###### [Error:] Virtual Disk Service (VDS) Unavailable ######");\r
+                       Log("###### [Error:] Virtual Disk Service (VDS) Unavailable ######");\r
+                       Log("###### [Error:] Virtual Disk Service (VDS) Unavailable ######");\r
+               }\r

     }\r
 \r
     if (pGptInfo)\r
     }\r
 \r
     if (pGptInfo)\r


@@ -1917,7 +1936,7 @@ int PartitionResizeForVentoy(PHY_DRIVE_INFO *pPhyDrive)
        if (pPhyDrive->ResizeNoShrink == FALSE)\r
        {\r
                Log("Need to shrink the volume");\r
        if (pPhyDrive->ResizeNoShrink == FALSE)\r
        {\r
                Log("Need to shrink the volume");\r

-               if (VDS_ShrinkVolume(pPhyDrive->ResizeVolumeGuid, RecudeBytes))\r
+               if (DISK_ShrinkVolume(pPhyDrive->PhyDrive, pPhyDrive->ResizeVolumeGuid, pPhyDrive->Part1DriveLetter, pPhyDrive->ResizeOldPart1Size, RecudeBytes))\r

                {\r
                        Log("Shrink volume success, now check again");\r
 \r
                {\r
                        Log("Shrink volume success, now check again");\r
 \r


@@ -2011,6 +2030,7 @@ int PartitionResizeForVentoy(PHY_DRIVE_INFO *pPhyDrive)
                        memcpy(pMBR->PartTbl + (j + 1), pMBR->PartTbl + j, sizeof(PART_TABLE));\r
                }\r
 \r
                        memcpy(pMBR->PartTbl + (j + 1), pMBR->PartTbl + j, sizeof(PART_TABLE));\r
                }\r
 \r

+        memset(pMBR->PartTbl + 1, 0, sizeof(PART_TABLE));\r

                VentoyFillMBRLocation(pPhyDrive->SizeInBytes, (UINT32)pPhyDrive->ResizePart2StartSector, VENTOY_EFI_PART_SIZE / 512, pMBR->PartTbl + 1);\r
                pMBR->PartTbl[0].Active = 0x80; // bootable\r
                pMBR->PartTbl[1].Active = 0x00;\r
                VentoyFillMBRLocation(pPhyDrive->SizeInBytes, (UINT32)pPhyDrive->ResizePart2StartSector, VENTOY_EFI_PART_SIZE / 512, pMBR->PartTbl + 1);\r
                pMBR->PartTbl[0].Active = 0x80; // bootable\r
                pMBR->PartTbl[1].Active = 0x00;\r


@@ -2048,6 +2068,7 @@ int PartitionResizeForVentoy(PHY_DRIVE_INFO *pPhyDrive)
                pMBR->BootCode[92] = 0x22;\r
 \r
                // to fix windows issue\r
                pMBR->BootCode[92] = 0x22;\r
 \r
                // to fix windows issue\r

+        memset(pGPT->PartTbl + 1, 0, sizeof(VTOY_GPT_PART_TBL));\r

                memcpy(&(pGPT->PartTbl[1].PartType), &WindowsDataPartType, sizeof(GUID));\r
                CoCreateGuid(&(pGPT->PartTbl[1].PartGuid));\r
 \r
                memcpy(&(pGPT->PartTbl[1].PartType), &WindowsDataPartType, sizeof(GUID));\r
                CoCreateGuid(&(pGPT->PartTbl[1].PartGuid));\r
 \r


@@ -2058,6 +2079,7 @@ int PartitionResizeForVentoy(PHY_DRIVE_INFO *pPhyDrive)
 \r
                //Update CRC\r
                pGPT->Head.PartTblCrc = VentoyCrc32(pGPT->PartTbl, sizeof(pGPT->PartTbl));\r
 \r
                //Update CRC\r
                pGPT->Head.PartTblCrc = VentoyCrc32(pGPT->PartTbl, sizeof(pGPT->PartTbl));\r

+        pGPT->Head.Crc = 0;\r

                pGPT->Head.Crc = VentoyCrc32(&(pGPT->Head), pGPT->Head.Length);\r
 \r
                Log("pGPT->Head.EfiStartLBA=%llu", (ULONGLONG)pGPT->Head.EfiStartLBA);\r
                pGPT->Head.Crc = VentoyCrc32(&(pGPT->Head), pGPT->Head.Length);\r
 \r
                Log("pGPT->Head.EfiStartLBA=%llu", (ULONGLONG)pGPT->Head.EfiStartLBA);\r


@@ -2320,6 +2342,7 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
        BOOL Esp2Basic = FALSE;\r
        BOOL ChangeAttr = FALSE;\r
        BOOL CleanDisk = FALSE;\r
        BOOL Esp2Basic = FALSE;\r
        BOOL ChangeAttr = FALSE;\r
        BOOL CleanDisk = FALSE;\r

+       BOOL DelEFI = FALSE;\r

        BOOL bWriteBack = TRUE;\r
        HANDLE hVolume;\r
        HANDLE hDrive;\r
        BOOL bWriteBack = TRUE;\r
        HANDLE hVolume;\r
        HANDLE hDrive;\r


@@ -2335,6 +2358,7 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
        MBR_HEAD MBR;\r
        BYTE *pBackup = NULL;\r
        VTOY_GPT_INFO *pGptInfo = NULL;\r
        MBR_HEAD MBR;\r
        BYTE *pBackup = NULL;\r
        VTOY_GPT_INFO *pGptInfo = NULL;\r

+       VTOY_GPT_INFO *pGptBkup = NULL;\r

        UINT8 ReservedData[4096];\r
 \r
        Log("#####################################################");\r
        UINT8 ReservedData[4096];\r
 \r
        Log("#####################################################");\r


@@ -2356,17 +2380,19 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
 \r
        if (pPhyDrive->PartStyle)\r
        {\r
 \r
        if (pPhyDrive->PartStyle)\r
        {\r

-               pGptInfo = malloc(sizeof(VTOY_GPT_INFO));\r
+               pGptInfo = malloc(2 * sizeof(VTOY_GPT_INFO));\r

                if (!pGptInfo)\r
                {\r
                        return 1;\r
                }\r
 \r
                if (!pGptInfo)\r
                {\r
                        return 1;\r
                }\r
 \r

-               memset(pGptInfo, 0, sizeof(VTOY_GPT_INFO));\r
+               memset(pGptInfo, 0, 2 * sizeof(VTOY_GPT_INFO));\r
+               pGptBkup = pGptInfo + 1;\r

 \r
                // Read GPT Info\r
                SetFilePointer(hDrive, 0, NULL, FILE_BEGIN);\r
                ReadFile(hDrive, pGptInfo, sizeof(VTOY_GPT_INFO), &dwSize, NULL);\r
 \r
                // Read GPT Info\r
                SetFilePointer(hDrive, 0, NULL, FILE_BEGIN);\r
                ReadFile(hDrive, pGptInfo, sizeof(VTOY_GPT_INFO), &dwSize, NULL);\r

+               memcpy(pGptBkup, pGptInfo, sizeof(VTOY_GPT_INFO));\r

 \r
                //MBR will be used to compare with local boot image\r
                memcpy(&MBR, &pGptInfo->MBR, sizeof(MBR_HEAD));\r
 \r
                //MBR will be used to compare with local boot image\r
                memcpy(&MBR, &pGptInfo->MBR, sizeof(MBR_HEAD));\r


@@ -2430,7 +2456,7 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
                if (TryId == 1)\r
                {\r
                        Log("Change GPT partition type to ESP");\r
                if (TryId == 1)\r
                {\r
                        Log("Change GPT partition type to ESP");\r

-                       if (VDS_ChangeVtoyEFI2ESP(pPhyDrive->PhyDrive, StartSector * 512))\r
+                       if (DISK_ChangeVtoyEFI2ESP(pPhyDrive->PhyDrive, StartSector * 512ULL))\r

                        {\r
                                Esp2Basic = TRUE;\r
                                Sleep(3000);\r
                        {\r
                                Esp2Basic = TRUE;\r
                                Sleep(3000);\r


@@ -2439,13 +2465,18 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
                else if (TryId == 2)\r
                {\r
                        Log("Change GPT partition attribute");\r
                else if (TryId == 2)\r
                {\r
                        Log("Change GPT partition attribute");\r

-                       if (VDS_ChangeVtoyEFIAttr(pPhyDrive->PhyDrive, 0x8000000000000001))\r
+                       if (DISK_ChangeVtoyEFIAttr(pPhyDrive->PhyDrive, StartSector * 512ULL, 0x8000000000000001))\r

                        {\r
                                ChangeAttr = TRUE;\r
                                Sleep(2000);\r
                        }\r
                }\r
                else if (TryId == 3)\r
                        {\r
                                ChangeAttr = TRUE;\r
                                Sleep(2000);\r
                        }\r
                }\r
                else if (TryId == 3)\r

+               {\r
+                       DISK_DeleteVtoyEFIPartition(pPhyDrive->PhyDrive, StartSector * 512ULL);\r
+                       DelEFI = TRUE;\r
+               }\r
+               else if (TryId == 4)\r

                {\r
                        Log("Clean disk GPT partition table");\r
                        if (BackupDataBeforeCleanDisk(pPhyDrive->PhyDrive, pPhyDrive->SizeInBytes, &pBackup))\r
                {\r
                        Log("Clean disk GPT partition table");\r
                        if (BackupDataBeforeCleanDisk(pPhyDrive->PhyDrive, pPhyDrive->SizeInBytes, &pBackup))\r


@@ -2457,11 +2488,7 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
 \r
                                Log("Success to backup data before clean");\r
                                CleanDisk = TRUE;\r
 \r
                                Log("Success to backup data before clean");\r
                                CleanDisk = TRUE;\r

-                               if (!VDS_CleanDisk(pPhyDrive->PhyDrive))\r
-                               {\r
-                                       Sleep(3000);\r
-                                       DSPT_CleanDisk(pPhyDrive->PhyDrive);\r
-                               }\r
+                               DISK_CleanDisk(pPhyDrive->PhyDrive);\r

                                Sleep(3000);\r
                        }\r
                        else\r
                                Sleep(3000);\r
                        }\r
                        else\r


@@ -2504,6 +2531,10 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
 \r
                Status = ERROR_NOT_FOUND;\r
        }\r
 \r
                Status = ERROR_NOT_FOUND;\r
        }\r

+       else if (DelEFI)\r
+       {\r
+               Status = ERROR_NOT_FOUND;\r
+       }\r

        else if (Esp2Basic)\r
        {\r
                Status = ERROR_NOT_FOUND;\r
        else if (Esp2Basic)\r
        {\r
                Status = ERROR_NOT_FOUND;\r


@@ -2595,7 +2626,7 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
                                CHECK_CLOSE_HANDLE(hDrive);\r
 \r
                                Log("Now delete partition 2...");\r
                                CHECK_CLOSE_HANDLE(hDrive);\r
 \r
                                Log("Now delete partition 2...");\r

-                               VDS_DeleteVtoyEFIPartition(pPhyDrive->PhyDrive);\r
+                               DISK_DeleteVtoyEFIPartition(pPhyDrive->PhyDrive, StartSector * 512ULL);\r

 \r
                                hDrive = GetPhysicalHandle(pPhyDrive->PhyDrive, TRUE, TRUE, FALSE);\r
                                if (hDrive == INVALID_HANDLE_VALUE)\r
 \r
                                hDrive = GetPhysicalHandle(pPhyDrive->PhyDrive, TRUE, TRUE, FALSE);\r
                                if (hDrive == INVALID_HANDLE_VALUE)\r


@@ -2707,6 +2738,37 @@ int UpdateVentoy2PhyDrive(PHY_DRIVE_INFO *pPhyDrive, int TryId)
 \r
                Sleep(1000);\r
        }\r
 \r
                Sleep(1000);\r
        }\r

+       else if (DelEFI)\r
+       {\r
+               VTOY_GPT_HDR BackupHdr;\r
+\r
+               VentoyFillBackupGptHead(pGptBkup, &BackupHdr);\r
+               if (!WriteBackupDataToDisk(hDrive, 512 * pGptBkup->Head.EfiBackupLBA, (BYTE*)(&BackupHdr), 512))\r
+               {\r
+                       bWriteBack = FALSE;\r
+               }\r
+\r
+               if (!WriteBackupDataToDisk(hDrive, 512 * (pGptBkup->Head.EfiBackupLBA - 32), (BYTE*)(pGptBkup->PartTbl), 32 * 512))\r
+               {\r
+                       bWriteBack = FALSE;\r
+               }\r
+\r
+               if (!WriteBackupDataToDisk(hDrive, 512, (BYTE*)pGptBkup + 512, 33 * 512))\r
+               {\r
+                       bWriteBack = FALSE;\r
+               }\r
+\r
+               if (bWriteBack)\r
+               {\r
+                       Log("Write backup partition table success");\r
+               }\r
+               else\r
+               {\r
+                       Log("Write backup partition table failed");\r
+               }\r
+\r
+               Sleep(1000);\r
+       }\r

 \r
     //Refresh Drive Layout\r
     DeviceIoControl(hDrive, IOCTL_DISK_UPDATE_PROPERTIES, NULL, 0, NULL, 0, &dwSize, NULL);\r
 \r
     //Refresh Drive Layout\r
     DeviceIoControl(hDrive, IOCTL_DISK_UPDATE_PROPERTIES, NULL, 0, NULL, 0, &dwSize, NULL);\r


@@ -2726,6 +2788,7 @@ End:
     }\r
     else\r
     {\r
     }\r
     else\r
     {\r

+               PROGRESS_BAR_SET_POS(PT_LOCK_FOR_CLEAN);\r

         FindProcessOccupyDisk(hDrive, pPhyDrive);\r
     }\r
 \r
         FindProcessOccupyDisk(hDrive, pPhyDrive);\r
     }\r
 \r


@@ -2734,7 +2797,7 @@ End:
     if (Esp2Basic)\r
     {\r
                Log("Recover GPT partition type to basic");\r
     if (Esp2Basic)\r
     {\r
                Log("Recover GPT partition type to basic");\r

-               VDS_ChangeVtoyEFI2Basic(pPhyDrive->PhyDrive, StartSector * 512);\r
+               DISK_ChangeVtoyEFI2Basic(pPhyDrive->PhyDrive, StartSector * 512);\r

     }\r
 \r
        if (pPhyDrive->PartStyle == 1)\r
     }\r
 \r
        if (pPhyDrive->PartStyle == 1)\r


@@ -2742,7 +2805,7 @@ End:
                if (ChangeAttr || ((pPhyDrive->Part2GPTAttr >> 56) != 0xC0))\r
                {\r
                        Log("Change EFI partition attr %u <0x%llx> to <0x%llx>", ChangeAttr, pPhyDrive->Part2GPTAttr, 0xC000000000000001ULL);\r
                if (ChangeAttr || ((pPhyDrive->Part2GPTAttr >> 56) != 0xC0))\r
                {\r
                        Log("Change EFI partition attr %u <0x%llx> to <0x%llx>", ChangeAttr, pPhyDrive->Part2GPTAttr, 0xC000000000000001ULL);\r

-                       if (VDS_ChangeVtoyEFIAttr(pPhyDrive->PhyDrive, 0xC000000000000001ULL))\r
+                       if (DISK_ChangeVtoyEFIAttr(pPhyDrive->PhyDrive, StartSector * 512ULL, 0xC000000000000001ULL))\r

                        {\r
                                Log("Change EFI partition attr success");\r
                                pPhyDrive->Part2GPTAttr = 0xC000000000000001ULL;\r
                        {\r
                                Log("Change EFI partition attr success");\r
                                pPhyDrive->Part2GPTAttr = 0xC000000000000001ULL;\r

diff --git a/Ventoy2Disk/Ventoy2Disk/Utility.c b/Ventoy2Disk/Ventoy2Disk/Utility.c
index d2d31887ef6b6d6f32e4cd8338306ac3c8acc21d..f217bfed45b77d996fc37c16b0f81821112c895d 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/Utility.c
+++ b/Ventoy2Disk/Ventoy2Disk/Utility.c
@@ -73,6 +73,17 @@ void Log(const char *Fmt, ...)
 \r
 }\r
 \r
 \r
 }\r
 \r

+const char* GUID2String(void *guid, char *buf, int len)\r
+{\r
+    GUID* pGUID = (GUID*)guid;\r
+    sprintf_s(buf, len, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",\r
+        pGUID->Data1, pGUID->Data2, pGUID->Data3,\r
+        pGUID->Data4[0], pGUID->Data4[1],\r
+        pGUID->Data4[2], pGUID->Data4[3], pGUID->Data4[4], pGUID->Data4[5], pGUID->Data4[6], pGUID->Data4[7]\r
+    );\r
+    return buf;\r
+}\r
+\r

 BOOL IsPathExist(BOOL Dir, const char *Fmt, ...)\r
 {\r
     va_list Arg;\r
 BOOL IsPathExist(BOOL Dir, const char *Fmt, ...)\r
 {\r
     va_list Arg;\r


@@ -231,6 +242,7 @@ BOOL IsWow64(void)
     typedef BOOL(WINAPI *LPFN_ISWOW64PROCESS)(HANDLE, PBOOL);\r
     LPFN_ISWOW64PROCESS fnIsWow64Process;\r
     BOOL bIsWow64 = FALSE;\r
     typedef BOOL(WINAPI *LPFN_ISWOW64PROCESS)(HANDLE, PBOOL);\r
     LPFN_ISWOW64PROCESS fnIsWow64Process;\r
     BOOL bIsWow64 = FALSE;\r

+       CHAR Wow64Dir[MAX_PATH];\r

 \r
     fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandleA("kernel32"), "IsWow64Process");\r
     if (NULL != fnIsWow64Process)\r
 \r
     fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandleA("kernel32"), "IsWow64Process");\r
     if (NULL != fnIsWow64Process)\r


@@ -238,6 +250,15 @@ BOOL IsWow64(void)
         fnIsWow64Process(GetCurrentProcess(), &bIsWow64);\r
     }\r
 \r
         fnIsWow64Process(GetCurrentProcess(), &bIsWow64);\r
     }\r
 \r

+       if (!bIsWow64)\r
+       {\r
+               if (GetSystemWow64DirectoryA(Wow64Dir, sizeof(Wow64Dir)))\r
+               {\r
+                       Log("GetSystemWow64DirectoryA=<%s>", Wow64Dir);\r
+                       bIsWow64 = TRUE;\r
+               }\r
+       }\r
+\r

     return bIsWow64;\r
 }\r
 \r
     return bIsWow64;\r
 }\r
 \r

diff --git a/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.c b/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.c
index 2f7d23346b3f89d6dff8cc69b1561cbde40e942b..4c6f6096d5726358e20cbb44bc353dbd0e18fa9b 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.c
+++ b/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.c
@@ -81,6 +81,8 @@ static BOOL IsVentoyPhyDrive(int PhyDrive, UINT64 SizeBytes, MBR_HEAD *pMBR, UIN
     UINT32 PartStartSector;\r
     UINT32 PartSectorCount;\r
     CHAR PhyDrivePath[128];\r
     UINT32 PartStartSector;\r
     UINT32 PartSectorCount;\r
     CHAR PhyDrivePath[128];\r

+    CHAR GUIDStr[128];\r
+    GUID ZeroGuid = { 0 };\r

        VTOY_GPT_INFO *pGpt = NULL;\r
 \r
     safe_sprintf(PhyDrivePath, "\\\\.\\PhysicalDrive%d", PhyDrive);\r
        VTOY_GPT_INFO *pGpt = NULL;\r
 \r
     safe_sprintf(PhyDrivePath, "\\\\.\\PhysicalDrive%d", PhyDrive);\r


@@ -108,20 +110,7 @@ static BOOL IsVentoyPhyDrive(int PhyDrive, UINT64 SizeBytes, MBR_HEAD *pMBR, UIN
         return FALSE;\r
     }\r
 \r
         return FALSE;\r
     }\r
 \r

-       for (i = 0; i < 4; i++)\r
-       {\r
-               Log("=========== Disk%d Partition Table %d ============", PhyDrive, i + 1);\r
-               Log("PartTbl.Active = 0x%x", MBR.PartTbl[i].Active);\r
-               Log("PartTbl.FsFlag = 0x%x", MBR.PartTbl[i].FsFlag);\r
-               Log("PartTbl.StartSectorId = %u", MBR.PartTbl[i].StartSectorId);\r
-               Log("PartTbl.SectorCount = %u", MBR.PartTbl[i].SectorCount);\r
-               Log("PartTbl.StartHead = %u", MBR.PartTbl[i].StartHead);\r
-               Log("PartTbl.StartSector = %u", MBR.PartTbl[i].StartSector);\r
-               Log("PartTbl.StartCylinder = %u", MBR.PartTbl[i].StartCylinder);\r
-               Log("PartTbl.EndHead = %u", MBR.PartTbl[i].EndHead);\r
-               Log("PartTbl.EndSector = %u", MBR.PartTbl[i].EndSector);\r
-               Log("PartTbl.EndCylinder = %u", MBR.PartTbl[i].EndCylinder);\r
-       }\r
+    \r

 \r
        if (MBR.PartTbl[0].FsFlag == 0xEE)\r
        {\r
 \r
        if (MBR.PartTbl[0].FsFlag == 0xEE)\r
        {\r


@@ -147,6 +136,23 @@ static BOOL IsVentoyPhyDrive(int PhyDrive, UINT64 SizeBytes, MBR_HEAD *pMBR, UIN
                        return FALSE;\r
                }\r
 \r
                        return FALSE;\r
                }\r
 \r

+        for (i = 0; i < 128; i++)\r
+        {\r
+            if (memcmp(&(pGpt->PartTbl[i].PartGuid), &ZeroGuid, sizeof(GUID)) == 0)\r
+            {\r
+                continue;\r
+            }\r
+\r
+            Log("=========== Disk%d GPT Partition %d ============", PhyDrive, i + 1);\r
+            \r
+            Log("PartTbl.PartType = %s", GUID2String(&pGpt->PartTbl[i].PartType, GUIDStr, sizeof(GUIDStr)));\r
+            Log("PartTbl.PartGuid = %s", GUID2String(&pGpt->PartTbl[i].PartGuid, GUIDStr, sizeof(GUIDStr)));\r
+            Log("PartTbl.StartLBA = %llu", (ULONGLONG)pGpt->PartTbl[i].StartLBA);\r
+            Log("PartTbl.LastLBA = %llu", (ULONGLONG)pGpt->PartTbl[i].LastLBA);\r
+            Log("PartTbl.Attribute = 0x%llx", pGpt->PartTbl[i].Attr);\r
+            Log("PartTbl.Name = %S", pGpt->PartTbl[i].Name);\r
+        }\r
+\r

                if (memcmp(pGpt->PartTbl[1].Name, L"VTOYEFI", 7 * 2))\r
                {\r
                        if (pGpt->PartTbl[1].Name[0])\r
                if (memcmp(pGpt->PartTbl[1].Name, L"VTOYEFI", 7 * 2))\r
                {\r
                        if (pGpt->PartTbl[1].Name[0])\r


@@ -187,6 +193,21 @@ static BOOL IsVentoyPhyDrive(int PhyDrive, UINT64 SizeBytes, MBR_HEAD *pMBR, UIN
        {\r
                CHECK_CLOSE_HANDLE(hDrive);\r
 \r
        {\r
                CHECK_CLOSE_HANDLE(hDrive);\r
 \r

+        for (i = 0; i < 4; i++)\r
+        {\r
+            Log("=========== Disk%d MBR Partition %d ============", PhyDrive, i + 1);\r
+            Log("PartTbl.Active = 0x%x", MBR.PartTbl[i].Active);\r
+            Log("PartTbl.FsFlag = 0x%x", MBR.PartTbl[i].FsFlag);\r
+            Log("PartTbl.StartSectorId = %u", MBR.PartTbl[i].StartSectorId);\r
+            Log("PartTbl.SectorCount = %u", MBR.PartTbl[i].SectorCount);\r
+            Log("PartTbl.StartHead = %u", MBR.PartTbl[i].StartHead);\r
+            Log("PartTbl.StartSector = %u", MBR.PartTbl[i].StartSector);\r
+            Log("PartTbl.StartCylinder = %u", MBR.PartTbl[i].StartCylinder);\r
+            Log("PartTbl.EndHead = %u", MBR.PartTbl[i].EndHead);\r
+            Log("PartTbl.EndSector = %u", MBR.PartTbl[i].EndSector);\r
+            Log("PartTbl.EndCylinder = %u", MBR.PartTbl[i].EndCylinder);\r
+        }\r
+\r

                if (MBR.PartTbl[0].StartSectorId != 2048)\r
                {\r
                        Log("Part1 not match %u", MBR.PartTbl[0].StartSectorId);\r
                if (MBR.PartTbl[0].StartSectorId != 2048)\r
                {\r
                        Log("Part1 not match %u", MBR.PartTbl[0].StartSectorId);\r

diff --git a/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.h b/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.h
index fedcd0bad21f683032d8f725828370ca253a2eb4..daf8c3c4dc2b7d610be84c0dc4cdc6abb6e00705 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.h
+++ b/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.h
@@ -167,6 +167,8 @@ typedef struct PHY_DRIVE_INFO
     UINT64 Part2GPTAttr;\r
 \r
        BOOL ResizeNoShrink;\r
     UINT64 Part2GPTAttr;\r
 \r
        BOOL ResizeNoShrink;\r

+       UINT64 ResizeOldPart1Size;\r
+       CHAR Part1DriveLetter;\r

     CHAR ResizeVolumeGuid[64];\r
        CHAR FsName[64];\r
        UINT64 ResizePart2StartSector;\r
     CHAR ResizeVolumeGuid[64];\r
        CHAR FsName[64];\r
        UINT64 ResizePart2StartSector;\r


@@ -319,6 +321,9 @@ void disk_io_reset_imghook(int *psegnum, UINT64 *pDataOffset);
 \r
 HANDLE GetPhysicalHandle(int Drive, BOOLEAN bLockDrive, BOOLEAN bWriteAccess, BOOLEAN bWriteShare);\r
 void InitComboxCtrl(HWND hWnd, int PhyDrive);\r
 \r
 HANDLE GetPhysicalHandle(int Drive, BOOLEAN bLockDrive, BOOLEAN bWriteAccess, BOOLEAN bWriteShare);\r
 void InitComboxCtrl(HWND hWnd, int PhyDrive);\r

+int disk_io_is_write_error(void);\r
+void disk_io_reset_write_error(void);\r
+const char* GUID2String(void* guid, char* buf, int len);\r

 \r
 #define VTSI_SUPPORT 1\r
 \r
 \r
 #define VTSI_SUPPORT 1\r
 \r

diff --git a/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj b/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj
index ee03fa5e52e78fcb90154c72aebfc91e1e882d17..45bb839e7611856c8cedfa3f6c15164fd733336a 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj
+++ b/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj
@@ -335,6 +335,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="crc32.c" />
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="crc32.c" />

+    <ClCompile Include="DiskService.c" />

     <ClCompile Include="DiskService_diskpart.c" />
     <ClCompile Include="DiskService_vds.c" />
     <ClCompile Include="DiskService_wmsa.c" />
     <ClCompile Include="DiskService_diskpart.c" />
     <ClCompile Include="DiskService_vds.c" />
     <ClCompile Include="DiskService_wmsa.c" />

diff --git a/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj.filters b/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj.filters
index 2be3bb285d475313c714be28660a629190a94458..410ec23facba6e596ac19b163c1ebf34443e3020 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj.filters
+++ b/Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj.filters
@@ -90,6 +90,9 @@
     <ClCompile Include="DiskService_wmsa.c">
       <Filter>源文件</Filter>
     </ClCompile>
     <ClCompile Include="DiskService_wmsa.c">
       <Filter>源文件</Filter>
     </ClCompile>

+    <ClCompile Include="DiskService.c">
+      <Filter>源文件</Filter>
+    </ClCompile>

   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Ventoy2Disk.h">
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Ventoy2Disk.h">

diff --git a/Ventoy2Disk/Ventoy2Disk/WinDialog.c b/Ventoy2Disk/Ventoy2Disk/WinDialog.c
index 9cebd76ccba0a5ca3c27cdd60921a563d2ae6644..86277baaa4e7db38233ace75ce10e6a96c80f41e 100644 (file)
Binary files a/Ventoy2Disk/Ventoy2Disk/WinDialog.c and b/Ventoy2Disk/Ventoy2Disk/WinDialog.c differ

diff --git a/Ventoy2Disk/Ventoy2Disk/ff14/source/diskio.c b/Ventoy2Disk/Ventoy2Disk/ff14/source/diskio.c
index 2a8c5b3844d70d33bd761e8471e9a7eaf59b6b15..d45df97d49e921c79afdaa2c053ccf2ad2d9bd8c 100644 (file)
--- a/Ventoy2Disk/Ventoy2Disk/ff14/source/diskio.c
+++ b/Ventoy2Disk/Ventoy2Disk/ff14/source/diskio.c
@@ -30,6 +30,20 @@ VTSI_SEGMENT *g_VentoySegment = NULL;
 int g_VentoyMaxSeg = 0;
 int g_VentoyCurSeg = -1;
 UINT64 g_VentoyDataOffset = 0;
 int g_VentoyMaxSeg = 0;
 int g_VentoyCurSeg = -1;
 UINT64 g_VentoyDataOffset = 0;

+int g_write_error = 0;
+int g_error_print_cnt = 0;
+
+void disk_io_reset_write_error(void)
+{
+       g_write_error = 0;
+       g_error_print_cnt = 0;
+}
+
+
+int disk_io_is_write_error(void)
+{
+       return g_write_error;
+}

 
 void disk_io_set_param(HANDLE Handle, UINT64 SectorCount)
 {
 
 void disk_io_set_param(HANDLE Handle, UINT64 SectorCount)
 {


@@ -248,9 +262,15 @@ DRESULT disk_write (
 
     bRet = WriteFile(g_hPhyDrive, buff, count * 512, &dwSize, NULL);
 
 
     bRet = WriteFile(g_hPhyDrive, buff, count * 512, &dwSize, NULL);
 

-    if (dwSize != count * 512)
+    if ((!bRet) || (dwSize != count * 512))

     {
     {

-        Log("WriteFile error bRet:%u WriteSize:%u dwSize:%u ErrCode:%u", bRet, count * 512, dwSize, GetLastError());
+               g_write_error = 1;
+               g_error_print_cnt++;
+
+               if (g_error_print_cnt <= 10)
+               {
+                       Log("WriteFile error bRet:%u WriteSize:%u dwSize:%u ErrCode:%u", bRet, count * 512, dwSize, GetLastError());
+               }

     }
 
     return RES_OK;
     }
 
     return RES_OK;