修复ssd检测逻辑

Author: nahida-mono

src/Snap.Hutao.Remastered.Native.Packaging/Snap.Hutao.Remastered.Native.Packaging.csproj

@@ -5,7 +5,7 @@
 		<NoPackageAnalysis>true</NoPackageAnalysis>
 
 		<PackageId>Snap.Hutao.Remastered.Native</PackageId>
-		<Version>1.0.2</Version>
+		<Version>1.0.3</Version>
 		<Authors>SnapHutaoRemasteringProject</Authors>
 		<Description>Native x64 libraries for Snap.Hutao.Remastered</Description>
 		<PackageTags>native;snap;hutao</PackageTags>

src/Snap.Hutao.Remastered.Native/HutaoNativePhysicalDrive.cpp

@@ -1,5 +1,6 @@
 #include "pch.h"
 #include "HutaoNativePhysicalDrive.h"
+#include "HutaoString.h"
 #include <winioctl.h>
 
 HRESULT __stdcall HutaoNativePhysicalDrive::IsPathOnSolidStateDrive(PCWSTR root, BOOL* isSSD) noexcept
@@ -9,39 +10,36 @@ HRESULT __stdcall HutaoNativePhysicalDrive::IsPathOnSolidStateDrive(PCWSTR root,
         return E_POINTER;
     }
 
-    // Check if path is empty
     if (root[0] == L'\0')
     {
         return E_INVALIDARG;
     }
 
-    // Get drive letter (e.g., "C:\" -> "C:")
-    wchar_t drive[4] = { L'C', L':', L'\\', L'\0' };
-    if (root[1] == L':')
+    wchar_t driveLetter = L'\0';
+    size_t len = wcslen(root);
+    
+    if (len >= 2 && root[1] == L':')
     {
-        drive[0] = root[0];
+        driveLetter = root[0];
     }
     else
     {
-        // If not a valid drive path, return error
         return E_INVALIDARG;
     }
 
-    // Create drive path
     HutaoString drivePath = L"\\\\.\\";
-    // 创建一个包含单个字符的字符串
-    wchar_t driveChar[2] = { drive[0], L'\0' };
-    drivePath += driveChar;
+    wchar_t driveLetterStr[2] = { driveLetter, L'\0' };
+    drivePath += driveLetterStr;
     drivePath += L":";
 
-    // Open drive
+    // Open drive with read access
     HANDLE hDrive = CreateFileW(
         drivePath.Data(),
-        0,
+        GENERIC_READ,
         FILE_SHARE_READ | FILE_SHARE_WRITE,
         nullptr,
         OPEN_EXISTING,
-        0,
+        FILE_ATTRIBUTE_NORMAL,
         nullptr
     );
 
@@ -50,7 +48,7 @@ HRESULT __stdcall HutaoNativePhysicalDrive::IsPathOnSolidStateDrive(PCWSTR root,
         return HRESULT_FROM_WIN32(GetLastError());
     }
 
-    // Get disk properties
+    // Method 1: Check device type
     STORAGE_PROPERTY_QUERY query = {};
     query.PropertyId = StorageDeviceProperty;
     query.QueryType = PropertyStandardQuery;
@@ -76,11 +74,11 @@ HRESULT __stdcall HutaoNativePhysicalDrive::IsPathOnSolidStateDrive(PCWSTR root,
         return HRESULT_FROM_WIN32(GetLastError());
     }
 
-    // Allocate buffer large enough
+    // Allocate buffer
     DWORD bufferSize = header.Size;
     if (bufferSize == 0)
     {
-        bufferSize = sizeof(STORAGE_DEVICE_DESCRIPTOR) + 1024; // Default size
+        bufferSize = sizeof(STORAGE_DEVICE_DESCRIPTOR) + 1024;
     }
 
     BYTE* buffer = new BYTE[bufferSize];
@@ -102,29 +100,88 @@ HRESULT __stdcall HutaoNativePhysicalDrive::IsPathOnSolidStateDrive(PCWSTR root,
         nullptr
     );
 
-    CloseHandle(hDrive);
-
     if (!result)
     {
         delete[] buffer;
+        CloseHandle(hDrive);
         return HRESULT_FROM_WIN32(GetLastError());
     }
 
     // Parse device descriptor
     STORAGE_DEVICE_DESCRIPTOR* descriptor = reinterpret_cast<STORAGE_DEVICE_DESCRIPTOR*>(buffer);
 
-    // Check media type
-    // SSD is usually DeviceType == 0x0C (SEMICONDUCTOR_DRIVE)
     BOOL isSolidState = FALSE;
 
-    // Check device type: SSD is usually 0x0C (SEMICONDUCTOR_DRIVE)
-    if (descriptor->DeviceType == 0x0C)
+    // Check 1: Device type - SSD is usually 0x0C (SEMICONDUCTOR_DRIVE)
+    // But some SSDs report as 0x00 (unknown) or 0x07 (FILE_DEVICE_DISK)
+    if (descriptor->DeviceType == 0x0C) // SEMICONDUCTOR_DRIVE
     {
         isSolidState = TRUE;
     }
-    // Could also check other flags, but DeviceType is most reliable
+    else if (descriptor->DeviceType == 0x00 || descriptor->DeviceType == 0x07)
+    {
+        // Could be SSD, need additional checks
+        // Method 2: Check for seek penalty property
+        STORAGE_PROPERTY_QUERY seekPenaltyQuery = {};
+        seekPenaltyQuery.PropertyId = StorageDeviceSeekPenaltyProperty;
+        seekPenaltyQuery.QueryType = PropertyStandardQuery;
+        
+        DEVICE_SEEK_PENALTY_DESCRIPTOR seekPenaltyDesc = {};
+        DWORD seekBytesReturned = 0;
+        
+        result = DeviceIoControl(
+            hDrive,
+            IOCTL_STORAGE_QUERY_PROPERTY,
+            &seekPenaltyQuery,
+            sizeof(seekPenaltyQuery),
+            &seekPenaltyDesc,
+            sizeof(seekPenaltyDesc),
+            &seekBytesReturned,
+            nullptr
+        );
+        
+        if (result)
+        {
+            // SSDs typically have no seek penalty (IncursSeekPenalty = FALSE)
+            // HDDs typically have seek penalty (IncursSeekPenalty = TRUE)
+            if (!seekPenaltyDesc.IncursSeekPenalty)
+            {
+                isSolidState = TRUE;
+            }
+        }
+        
+        // Method 3: Check for TRIM support (optional)
+        if (!isSolidState)
+        {
+            STORAGE_PROPERTY_QUERY trimQuery = {};
+            trimQuery.PropertyId = StorageDeviceTrimProperty;
+            trimQuery.QueryType = PropertyStandardQuery;
+            
+            DEVICE_TRIM_DESCRIPTOR trimDesc = {};
+            DWORD trimBytesReturned = 0;
+            
+            result = DeviceIoControl(
+                hDrive,
+                IOCTL_STORAGE_QUERY_PROPERTY,
+                &trimQuery,
+                sizeof(trimQuery),
+                &trimDesc,
+                sizeof(trimDesc),
+                &trimBytesReturned,
+                nullptr
+            );
+            
+            if (result && trimDesc.TrimEnabled)
+            {
+                // Device supports TRIM, likely an SSD
+                isSolidState = TRUE;
+            }
+        }
+    }
 
     delete[] buffer;
+    CloseHandle(hDrive);
+    
     *isSSD = isSolidState;
     return S_OK;
 }

src/Snap.Hutao.Remastered.Native/HutaoNativeProcess.cpp

@@ -142,7 +142,6 @@ HRESULT __stdcall HutaoNativeProcess::WaitForExit()
         return hr;
     }
 
-    // 获取退出码
     if (!::GetExitCodeProcess(m_processInfo.hProcess, &m_exitCode))
     {
         HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
@@ -169,10 +168,8 @@ HRESULT __stdcall HutaoNativeProcess::Kill()
         return hr;
     }
 
-    // 等待进程结束
     WaitForSingleObject(m_processInfo.hProcess, 5000);
 
-    // 获取退出码
     if (!::GetExitCodeProcess(m_processInfo.hProcess, &m_exitCode))
     {
         m_exitCode = 1;
@@ -296,7 +293,6 @@ HRESULT __stdcall HutaoNativeProcess::GetExitCodeProcess(BOOL* isRunning, uint*
         return S_OK;
     }
 
-    // 检查进程是否还在运行
     DWORD currentExitCode;
     if (!::GetExitCodeProcess(m_processInfo.hProcess, &currentExitCode))
     {