Ros-diffs August 2024

ros-diffs@reactos.org

26 participants
139 discussions

[reactos] 01/03: [COMPILER_APITEST] Add tests for float to int conversion

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6fd6e9c306e35bac02252… commit 6fd6e9c306e35bac0225292854fd4c481797f567 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Wed Aug 21 22:40:58 2024 +0300 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Tue Aug 27 21:34:50 2024 +0300 [COMPILER_APITEST] Add tests for float to int conversion These tests come with a VS solution, because that is the only way to test against a known good system, as the required runtime functions (like _ftol) are statically linked from the VS runtime library. --- modules/rostests/apitests/compiler/CMakeLists.txt | 1 + .../apitests/compiler/compiler_apitest.sln | 31 +++ .../apitests/compiler/compiler_apitest.vcxproj | 93 +++++++ modules/rostests/apitests/compiler/floatconv.c | 277 +++++++++++++++++++++ modules/rostests/apitests/compiler/testlist.c | 4 + 5 files changed, 406 insertions(+) diff --git a/modules/rostests/apitests/compiler/CMakeLists.txt b/modules/rostests/apitests/compiler/CMakeLists.txt index 163a0220c03..f43a47600a8 100644 --- a/modules/rostests/apitests/compiler/CMakeLists.txt +++ b/modules/rostests/apitests/compiler/CMakeLists.txt @@ -6,6 +6,7 @@ if (MSVC OR ARCH STREQUAL "i386") endif() list(APPEND SOURCE + floatconv.c pseh.c pseh_cpp.cpp psehtest2.c diff --git a/modules/rostests/apitests/compiler/compiler_apitest.sln b/modules/rostests/apitests/compiler/compiler_apitest.sln new file mode 100644 index 00000000000..819d3e90633 --- /dev/null +++ b/modules/rostests/apitests/compiler/compiler_apitest.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.11.35219.272 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "compiler_apitest", "compiler_apitest.vcxproj", "{CBB00980-3B4F-4006-973E-61B462D057B3}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {CBB00980-3B4F-4006-973E-61B462D057B3}.Debug|x64.ActiveCfg = Debug|x64 + {CBB00980-3B4F-4006-973E-61B462D057B3}.Debug|x64.Build.0 = Debug|x64 + {CBB00980-3B4F-4006-973E-61B462D057B3}.Debug|x86.ActiveCfg = Debug|Win32 + {CBB00980-3B4F-4006-973E-61B462D057B3}.Debug|x86.Build.0 = Debug|Win32 + {CBB00980-3B4F-4006-973E-61B462D057B3}.Release|x64.ActiveCfg = Release|x64 + {CBB00980-3B4F-4006-973E-61B462D057B3}.Release|x64.Build.0 = Release|x64 + {CBB00980-3B4F-4006-973E-61B462D057B3}.Release|x86.ActiveCfg = Release|Win32 + {CBB00980-3B4F-4006-973E-61B462D057B3}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {F64379E4-70F2-4E62-90BC-00B1308C96D4} + EndGlobalSection +EndGlobal diff --git a/modules/rostests/apitests/compiler/compiler_apitest.vcxproj b/modules/rostests/apitests/compiler/compiler_apitest.vcxproj new file mode 100644 index 00000000000..fa0fc6bd34f --- /dev/null +++ b/modules/rostests/apitests/compiler/compiler_apitest.vcxproj @@ -0,0 +1,93 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <ItemGroup Label="ProjectConfigurations"> + <ProjectConfiguration Include="Debug|Win32"> + <Configuration>Debug</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|Win32"> + <Configuration>Release</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Debug|x64"> + <Configuration>Debug</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|x64"> + <Configuration>Release</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + </ItemGroup> + <PropertyGroup Label="Globals"> + <VCProjectVersion>17.0</VCProjectVersion> + <Keyword>Win32Proj</Keyword> + <ProjectGuid>{cbb00980-3b4f-4006-973e-61b462d057b3}</ProjectGuid> + <RootNamespace>compilerapitest</RootNamespace> + <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> + <PropertyGroup> + <ConfigurationType>Application</ConfigurationType> + <CharacterSet>Unicode</CharacterSet> + <PlatformToolset>v142</PlatformToolset> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration"> + <UseDebugLibraries>true</UseDebugLibraries> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration"> + <UseDebugLibraries>false</UseDebugLibraries> + <WholeProgramOptimization>true</WholeProgramOptimization> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> + <ImportGroup Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <PropertyGroup Label="UserMacros" /> + <ItemDefinitionGroup> + <ClCompile> + <WarningLevel>Level3</WarningLevel> + <SDLCheck>true</SDLCheck> + <ConformanceMode>true</ConformanceMode> + <AdditionalIncludeDirectories>$(ProjectDir)..\include;$(ProjectDir)..\..\..\..\sdk\include\reactos;$(ProjectDir)..\..\..\..\sdk\lib\pseh\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>_CONSOLE;__VS_PROJECT__;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <DisableSpecificWarnings>4532;4996</DisableSpecificWarnings> + </ClCompile> + <Link> + <SubSystem>Console</SubSystem> + <GenerateDebugInformation>true</GenerateDebugInformation> + </Link> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'"> + <ClCompile> + <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'"> + <ClCompile> + <FunctionLevelLinking>true</FunctionLevelLinking> + <IntrinsicFunctions>true</IntrinsicFunctions> + <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + <Link> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <OptimizeReferences>true</OptimizeReferences> + </Link> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'"> + <ClCompile> + <PreprocessorDefinitions>_X86_;WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Platform)'=='x64'"> + <ClCompile> + <PreprocessorDefinitions>_AMD64_;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + </ItemDefinitionGroup> + <ItemGroup> + <ClCompile Include="floatconv.c" /> + <ClCompile Include="testlist.c" /> + </ItemGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> + <ImportGroup Label="ExtensionTargets"> + </ImportGroup> +</Project> \ No newline at end of file diff --git a/modules/rostests/apitests/compiler/floatconv.c b/modules/rostests/apitests/compiler/floatconv.c new file mode 100644 index 00000000000..195c587b60b --- /dev/null +++ b/modules/rostests/apitests/compiler/floatconv.c @@ -0,0 +1,277 @@ +/* + * PROJECT: ReactOS API tests + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: Test for floating point conversion + * COPYRIGHT: Copyright 2024 Timo Kreuzer <timo.kreuzer(a)reactos.org> + */ + +#include <apitest.h> + +/* Note: There are 2 behaviors for float to unsigned integer conversion: + * 1. The old behavior, which exists only on x86 and CL versions up to somewhere + * between 19.40.33811 and 19.41.33923: + * - If a negative float is cast to an unsigned integer, the result is ULONG_MAX + * for uint32 and ULLONG_MAX for uint64. + * - If a float is cast to an unsigned long and the value is larger than ULONG_MAX, + * the result is ULONG_MAX. + * 2. The new behavior (all x64 and x86 versions after the ones mentioned above): + * - If a negative float is cast to an unsigned integer, the result is the same as + first casting to the signed type, then casting to the unsigned type. + * - If a float is cast to an unsigned integer and the value is too large for the type, + * the result is 0 for uint32 and 0x8000000000000000 for uint64. + * In the old version, the float to unsigned conversion was inlined and used _ftoul2 and + * a comparison against 0x43e0000000000000 (9223372036854775808.0) to check for overflow. + * In the new version, the float to unsigned conversion is done by a call to _ftoul2_legacy, + * which checks for overflow by comparing against 0x5f800000 (18446744073709551616.0) and + * then forwards the call to either _ftol2 or _ftoul2. + */ + +#if defined(_M_IX86) && defined(__VS_PROJECT__) && (_MSC_FULL_VER < 194133923) +#define OLD_BEHAVIOR +#endif + +#ifdef OLD_BEHAVIOR +#define ULONG_OVERFLOW ULONG_MAX +#define ULONGLONG_OVERFLOW ULLONG_MAX +#else +#define ULONG_OVERFLOW 0ul +#define ULONGLONG_OVERFLOW 0x8000000000000000ull +#endif + +#ifdef __GNUC__ +#define todo_gcc todo_ros +#else +#define todo_gcc +#endif + +__declspec(noinline) +long cast_float_to_long(float f) +{ + return (long)f; +} + +__declspec(noinline) +unsigned long cast_float_to_ulong(float f) +{ + return (unsigned long)f; +} + +__declspec(noinline) +long cast_double_to_long(double d) +{ + return (long)d; +} + +__declspec(noinline) +unsigned long cast_double_to_ulong(double d) +{ + return (unsigned long)d; +} + +__declspec(noinline) +long long cast_float_to_longlong(float f) +{ + return (long long)f; +} + +__declspec(noinline) +unsigned long long cast_float_to_ulonglong(float f) +{ + return (unsigned long long)f; +} + +__declspec(noinline) +long long cast_double_to_longlong(double d) +{ + return (long long)d; +} + +__declspec(noinline) +unsigned long long cast_double_to_ulonglong(double d) +{ + return (unsigned long long)d; +} + +void Test_float(void) +{ + // float to long cast + ok_eq_long(cast_float_to_long(0.0f), 0l); + ok_eq_long(cast_float_to_long(1.0f), 1l); + ok_eq_long(cast_float_to_long(-1.0f), -1l); + ok_eq_long(cast_float_to_long(0.5f), 0l); + ok_eq_long(cast_float_to_long(-0.5f), 0l); + ok_eq_long(cast_float_to_long(0.999999f), 0l); + ok_eq_long(cast_float_to_long(-0.999999f), 0l); + ok_eq_long(cast_float_to_long(2147483500.0f), 2147483520l); + ok_eq_long(cast_float_to_long(2147483583.999f), 2147483520l); + ok_eq_long(cast_float_to_long(-2147483583.999f), -2147483520l); + ok_eq_long(cast_float_to_long(2147483584.0f), LONG_MIN); // -2147483648 + ok_eq_long(cast_float_to_long(2147483648.0f), LONG_MIN); // -2147483648 + ok_eq_long(cast_float_to_long(-2147483648.0f), LONG_MIN); // -2147483648 + ok_eq_long(cast_float_to_long(10000000000.0f), LONG_MIN); + ok_eq_long(cast_float_to_long(-10000000000.0f), LONG_MIN); + + // float to unsigned long cast (positive values) + ok_eq_ulong(cast_float_to_ulong(0.0f), 0ul); + ok_eq_ulong(cast_float_to_ulong(1.0f), 1ul); + ok_eq_ulong(cast_float_to_ulong(0.5f), 0ul); + ok_eq_ulong(cast_float_to_ulong(0.999999f), 0ul); + ok_eq_ulong(cast_float_to_ulong(2147483648.0f), 2147483648ul); // 0x80000000 + ok_eq_ulong(cast_float_to_ulong(4294967150.0f), 4294967040ul); // 0xFFFFFF00 + ok_eq_ulong(cast_float_to_ulong(4294967294.0f), ULONG_OVERFLOW); + + // float to unsigned long cast (negative values) + ok_eq_ulong(cast_float_to_ulong(-0.0f), 0ul); + ok_eq_ulong(cast_float_to_ulong(-0.5f), 0ul); + ok_eq_ulong(cast_float_to_ulong(-1.0f), ULONG_MAX); +#ifdef OLD_BEHAVIOR + ok_eq_ulong(cast_float_to_ulong(-10.0f), ULONG_MAX); + ok_eq_ulong(cast_float_to_ulong(-1147483648.0f), ULONG_MAX); + ok_eq_ulong(cast_float_to_ulong(-2147483648.0f), ULONG_MAX); +#else + ok_eq_ulong(cast_float_to_ulong(-10.0f), (unsigned long)-10); + ok_eq_ulong(cast_float_to_ulong(-1147483648.0f), (unsigned long)-1147483648ll); + ok_eq_ulong(cast_float_to_ulong(-2147483648.0f), (unsigned long)-2147483648ll); +#endif + + // float to long long cast + ok_eq_longlong(cast_float_to_longlong(0.0f), 0ll); + ok_eq_longlong(cast_float_to_longlong(1.0f), 1ll); + ok_eq_longlong(cast_float_to_longlong(-1.0f), -1ll); + ok_eq_longlong(cast_float_to_longlong(0.5f), 0ll); + ok_eq_longlong(cast_float_to_longlong(-0.5f), 0ll); + ok_eq_longlong(cast_float_to_longlong(0.999999f), 0ll); + ok_eq_longlong(cast_float_to_longlong(-0.999999f), 0ll); + ok_eq_longlong(cast_float_to_longlong(9223371761976868863.9999f), 9223371487098961920ll); + ok_eq_longlong(cast_float_to_longlong(9223371761976868864.0f), LLONG_MIN); + ok_eq_longlong(cast_float_to_longlong(-9223371761976868863.9999f), -9223371487098961920ll); + ok_eq_longlong(cast_float_to_longlong(-9223371761976868864.0f), LLONG_MIN); + ok_eq_longlong(cast_float_to_longlong(100000000000000000000.0f), LLONG_MIN); + ok_eq_longlong(cast_float_to_longlong(-100000000000000000000.0f), LLONG_MIN); + + // float to unsigned long long cast (positive values) + ok_eq_ulonglong(cast_float_to_ulonglong(0.0f), 0ull); + ok_eq_ulonglong(cast_float_to_ulonglong(1.0f), 1ull); + ok_eq_ulonglong(cast_float_to_ulonglong(0.5f), 0ull); + ok_eq_ulonglong(cast_float_to_ulonglong(0.999999f), 0ull); + ok_eq_ulonglong(cast_float_to_ulonglong(9223371487098961920.0f), 9223371487098961920ull); // 0x7FFFFF8000000000 + ok_eq_ulonglong(cast_float_to_ulonglong(9223372036854775808.0f), 9223372036854775808ull); // 0x8000000000000000 + ok_eq_ulonglong(cast_float_to_ulonglong(18446743523953737727.9f), 18446742974197923840ull); // 0xFFFFFF0000000000 + todo_gcc ok_eq_ulonglong(cast_float_to_ulonglong(18446743523953737728.0f), ULONGLONG_OVERFLOW); // 0x8000000000000000 / 0xFFFFFFFFFFFFFFFF + todo_gcc ok_eq_ulonglong(cast_float_to_ulonglong(20000000000000000000.0f), ULONGLONG_OVERFLOW); // 0x8000000000000000 / 0xFFFFFFFFFFFFFFFF + + // float to unsigned long long cast (negative values) + ok_eq_ulonglong(cast_float_to_ulonglong(-0.0f), 0ull); + ok_eq_ulonglong(cast_float_to_ulonglong(-0.5f), 0ull); + ok_eq_ulonglong(cast_float_to_ulonglong(-1.0f), 18446744073709551615ull); +#ifdef OLD_BEHAVIOR + ok_eq_ulonglong(cast_float_to_ulonglong(-10.0f), ULLONG_MAX); + ok_eq_ulonglong(cast_float_to_ulonglong(-1147483648.0f), ULLONG_MAX); + ok_eq_ulonglong(cast_float_to_ulonglong(-2147483648.0f), ULLONG_MAX); + ok_eq_ulonglong(cast_float_to_ulonglong(-9223371761976868863.9f), ULLONG_MAX); + ok_eq_ulonglong(cast_float_to_ulonglong(-9223371761976868864.0f), ULLONG_MAX); + ok_eq_ulonglong(cast_float_to_ulonglong(-9223372036854775808.0f), ULLONG_MAX); +#else + ok_eq_ulonglong(cast_float_to_ulonglong(-10.0f), (unsigned long long)-10); + ok_eq_ulonglong(cast_float_to_ulonglong(-1147483648.0f), (unsigned long long)-1147483648ll); + ok_eq_ulonglong(cast_float_to_ulonglong(-2147483648.0f), (unsigned long long)-2147483648ll); + ok_eq_ulonglong(cast_float_to_ulonglong(-9223371761976868863.9f), (unsigned long long)-9223371487098961920); + ok_eq_ulonglong(cast_float_to_ulonglong(-9223371761976868864.0f), (unsigned long long)(-9223372036854775807ll - 1)); // 0x8000000000000000 / ULONGLONG_OVERFLOW + ok_eq_ulonglong(cast_float_to_ulonglong(-9223372036854775808.0f), (unsigned long long)(-9223372036854775807ll - 1)); // 0x8000000000000000 / ULONGLONG_OVERFLOW +#endif + ok_eq_ulonglong(cast_float_to_ulonglong(-100000000000000000000.0f), ULONGLONG_OVERFLOW); +} + +void Test_double(void) +{ + // double to long cast + ok_eq_long(cast_double_to_long(0.0), 0l); + ok_eq_long(cast_double_to_long(1.0), 1l); + ok_eq_long(cast_double_to_long(-1.0), -1l); + ok_eq_long(cast_double_to_long(0.5), 0l); + ok_eq_long(cast_double_to_long(-0.5), 0l); + ok_eq_long(cast_double_to_long(0.999999999), 0l); + ok_eq_long(cast_double_to_long(-0.999999999), 0l); + ok_eq_long(cast_double_to_long(2147483647.99999), 2147483647l); + ok_eq_long(cast_double_to_long(-2147483647.99999), -2147483647l); + ok_eq_long(cast_double_to_long(2147483648.0), LONG_MIN); // -2147483648 + ok_eq_long(cast_double_to_long(-2147483648.0), LONG_MIN); // -2147483648 + ok_eq_long(cast_double_to_long(10000000000.0), LONG_MIN); + ok_eq_long(cast_double_to_long(-10000000000.0), LONG_MIN); + + // double to unsigned long cast (positive values) + ok_eq_ulong(cast_double_to_ulong(0.0), 0ul); + ok_eq_ulong(cast_double_to_ulong(1.0), 1ul); + ok_eq_ulong(cast_double_to_ulong(0.5), 0ul); + ok_eq_ulong(cast_double_to_ulong(0.999999999), 0ul); + ok_eq_ulong(cast_double_to_ulong(2147483648.0), 2147483648ul); // 0x80000000 + ok_eq_ulong(cast_double_to_ulong(4294967295.0), 4294967295ul); // 0xFFFFFFFF + ok_eq_ulong(cast_double_to_ulong(4294967296.0), ULONG_OVERFLOW); + + // double to unsigned long cast (negative values) + ok_eq_ulong(cast_double_to_ulong(-0.0), 0ul); + ok_eq_ulong(cast_double_to_ulong(-0.5), 0ul); + ok_eq_ulong(cast_double_to_ulong(-1.0), ULONG_MAX); +#ifdef OLD_BEHAVIOR + ok_eq_ulong(cast_double_to_ulong(-10.0), ULONG_MAX); + ok_eq_ulong(cast_double_to_ulong(-1147483648.0), ULONG_MAX); + ok_eq_ulong(cast_double_to_ulong(-2147483648.0), ULONG_MAX); +#else + ok_eq_ulong(cast_double_to_ulong(-10.0), (unsigned long)-10); + ok_eq_ulong(cast_double_to_ulong(-1147483648.0), (unsigned long)-1147483648ll); + ok_eq_ulong(cast_double_to_ulong(-2147483648.0), (unsigned long)-2147483648ll); +#endif + + // double to long long cast + ok_eq_longlong(cast_double_to_longlong(0.0), 0ll); + ok_eq_longlong(cast_double_to_longlong(1.0), 1ll); + ok_eq_longlong(cast_double_to_longlong(-1.0), -1ll); + ok_eq_longlong(cast_double_to_longlong(0.5), 0ll); + ok_eq_longlong(cast_double_to_longlong(-0.5), 0ll); + ok_eq_longlong(cast_double_to_longlong(0.999999), 0ll); + ok_eq_longlong(cast_double_to_longlong(-0.999999), 0ll); + ok_eq_longlong(cast_double_to_longlong(9223372036854775295.9), 9223372036854774784ll); + ok_eq_longlong(cast_double_to_longlong(9223372036854775296.0), LLONG_MIN); + ok_eq_longlong(cast_double_to_longlong(-9223372036854775295.9), -9223372036854774784ll); + ok_eq_longlong(cast_double_to_longlong(-9223372036854775296.0), LLONG_MIN); + ok_eq_longlong(cast_double_to_longlong(100000000000000000000.0), LLONG_MIN); + ok_eq_longlong(cast_double_to_longlong(-100000000000000000000.0), LLONG_MIN); + + // double to unsigned long long cast (positive values) + ok_eq_ulonglong(cast_double_to_ulonglong(0.0), 0ull); + ok_eq_ulonglong(cast_double_to_ulonglong(1.0), 1ull); + ok_eq_ulonglong(cast_double_to_ulonglong(0.5), 0ull); + ok_eq_ulonglong(cast_double_to_ulonglong(0.999999), 0ull); + ok_eq_ulonglong(cast_double_to_ulonglong(9223372036854774784.0), 9223372036854774784ull); // 0x7FFFFFFFFFFFFC00 + ok_eq_ulonglong(cast_double_to_ulonglong(9223372036854775808.0), 9223372036854775808ull); // 0x8000000000000000 + ok_eq_ulonglong(cast_double_to_ulonglong(18446744073709550591.9), 18446744073709549568ull); // 0xFFFFFFFFFFFFF800 + todo_gcc ok_eq_ulonglong(cast_double_to_ulonglong(18446744073709550592.0), ULONGLONG_OVERFLOW); // 0x8000000000000000 / 0xFFFFFFFFFFFFFFFF + todo_gcc ok_eq_ulonglong(cast_double_to_ulonglong(18446744073709551616.0), ULONGLONG_OVERFLOW); // 0x8000000000000000 / 0xFFFFFFFFFFFFFFFF + todo_gcc ok_eq_ulonglong(cast_double_to_ulonglong(20000000000000000000.0), ULONGLONG_OVERFLOW); // 0x8000000000000000 / 0xFFFFFFFFFFFFFFFF + + // float to unsigned long long cast (negative values) + ok_eq_ulonglong(cast_double_to_ulonglong(-0.0), 0ull); + ok_eq_ulonglong(cast_double_to_ulonglong(-0.5), 0ull); + ok_eq_ulonglong(cast_double_to_ulonglong(-1.0), 18446744073709551615ull); +#ifdef OLD_BEHAVIOR + ok_eq_ulonglong(cast_double_to_ulonglong(-10.0), ULLONG_MAX); + ok_eq_ulonglong(cast_double_to_ulonglong(-1147483648.0), ULLONG_MAX); + ok_eq_ulonglong(cast_double_to_ulonglong(-2147483648.0), ULLONG_MAX); + ok_eq_ulonglong(cast_double_to_ulonglong(-9223371761976868863.9), ULLONG_MAX); + ok_eq_ulonglong(cast_double_to_ulonglong(-9223371761976868864.0), ULLONG_MAX); + ok_eq_ulonglong(cast_double_to_ulonglong(-9223372036854775808.0), ULLONG_MAX); +#else + ok_eq_ulonglong(cast_double_to_ulonglong(-10.0), (unsigned long long)-10); + ok_eq_ulonglong(cast_double_to_ulonglong(-1147483648.0), (unsigned long long)-1147483648ll); + ok_eq_ulonglong(cast_double_to_ulonglong(-2147483648.0), (unsigned long long)-2147483648ll); + ok_eq_ulonglong(cast_double_to_ulonglong(-9223372036854775000.0), (unsigned long long)-9223372036854774784ll); + ok_eq_ulonglong(cast_double_to_ulonglong(-9223372036854775808.0), (unsigned long long)(-9223372036854775807ll - 1)); +#endif + ok_eq_ulonglong(cast_double_to_ulonglong(-100000000000000000000.0), ULONGLONG_OVERFLOW); +} + +START_TEST(floatconv) +{ + Test_float(); + Test_double(); +} diff --git a/modules/rostests/apitests/compiler/testlist.c b/modules/rostests/apitests/compiler/testlist.c index d73f7fd70bb..fe4b55adc21 100644 --- a/modules/rostests/apitests/compiler/testlist.c +++ b/modules/rostests/apitests/compiler/testlist.c @@ -1,16 +1,20 @@ #define STANDALONE #include <apitest.h> +extern void func_floatconv(void); extern void func_ms_seh(void); extern void func_pseh(void); extern void func_pseh_cpp(void); const struct test winetest_testlist[] = { + { "floatconv", func_floatconv }, +#ifndef __VS_PROJECT__ #if !(defined(__GNUC__) && defined(_M_AMD64)) { "ms-seh", func_ms_seh }, #endif { "pseh", func_pseh }, { "pseh_cpp", func_pseh_cpp }, +#endif /* __VS_PROJECT__ */ { 0, 0 } };

11 months

[reactos] 01/01: [USER32_APITEST] Add scrollbar showing/hiding testcase (#7254)

by Marek Benc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=a9b77d89fb660802f9e8e… commit a9b77d89fb660802f9e8ee4497e56f5d576ecb42 Author: Marek Benc <benc.marek.elektro98(a)proton.me> AuthorDate: Tue Aug 27 20:25:02 2024 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Tue Aug 27 13:25:02 2024 -0500 [USER32_APITEST] Add scrollbar showing/hiding testcase (#7254) Checks CORE-19669, making sure that CS_HREDRAW and CS_VREDRAW are respected when the client area changes due to the scrollbar disappearing or re-appearing. ROSTESTS-397 Co-authored-by: Stanislav Motylkov <x86corez(a)gmail.com> --- modules/rostests/apitests/user32/CMakeLists.txt | 1 + modules/rostests/apitests/user32/ScrollBarRedraw.c | 727 +++++++++++++++++++++ modules/rostests/apitests/user32/testlist.c | 2 + 3 files changed, 730 insertions(+) diff --git a/modules/rostests/apitests/user32/CMakeLists.txt b/modules/rostests/apitests/user32/CMakeLists.txt index 3e696def280..1a3c829dcea 100644 --- a/modules/rostests/apitests/user32/CMakeLists.txt +++ b/modules/rostests/apitests/user32/CMakeLists.txt @@ -41,6 +41,7 @@ list(APPEND SOURCE RedrawWindow.c RegisterClassEx.c RegisterHotKey.c + ScrollBarRedraw.c ScrollBarWndExtra.c ScrollDC.c ScrollWindowEx.c diff --git a/modules/rostests/apitests/user32/ScrollBarRedraw.c b/modules/rostests/apitests/user32/ScrollBarRedraw.c new file mode 100644 index 00000000000..6cecaf50dbb --- /dev/null +++ b/modules/rostests/apitests/user32/ScrollBarRedraw.c @@ -0,0 +1,727 @@ +/* + * PROJECT: ReactOS API tests + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: Tests window redrawing when scrollbars appear or disappear + * COPYRIGHT: Copyright 2024 Marek Benc <benc.marek.elektro98(a)proton.me> + */ + +#include "precomp.h" + +#define TEST_CLASS_NAME L"ScrollBarRedraw" +#define TEST_WINDOW_TITLE L"ScrollBarRedraw" + +static LRESULT CALLBACK WindowProc(HWND Window, UINT Message, WPARAM wParam, LPARAM lParam); + +#define TEST_COLOR_COUNT 16 + +/* Standard Windows 16-Color VGA Color palette. */ +static COLORREF Colors[] = +{ + RGB(0x00, 0x00, 0x00), /* Black */ + RGB(0x00, 0x00, 0x80), /* Dark Blue */ + RGB(0x00, 0x80, 0x00), /* Dark Green */ + RGB(0x00, 0x80, 0x80), /* Dark Cyan */ + RGB(0x80, 0x00, 0x00), /* Dark Red */ + RGB(0x80, 0x00, 0x80), /* Dark Magenta */ + RGB(0x80, 0x80, 0x00), /* Dark Yellow */ + RGB(0xC0, 0xC0, 0xC0), /* Light Gray */ + RGB(0x80, 0x80, 0x80), /* Dark Gray */ + RGB(0x00, 0x00, 0xFF), /* Blue */ + RGB(0x00, 0xFF, 0x00), /* Green */ + RGB(0x00, 0xFF, 0xFF), /* Cyan */ + RGB(0xFF, 0x00, 0x00), /* Red */ + RGB(0xFF, 0x00, 0xFF), /* Magenta */ + RGB(0xFF, 0xFF, 0x00), /* Yellow */ + RGB(0xFF, 0xFF, 0xFF) /* White */ +}; +static HBRUSH ColorBrushes[TEST_COLOR_COUNT] = { 0 }; + +static BOOL HaveHRedraw = FALSE; +static BOOL HaveVRedraw = FALSE; +static BOOL WindowCreatedOk = FALSE; + +typedef enum _FSM_STATE +{ + FSM_STATE_START, + FSM_STATE_VSCR_SHOWN, + FSM_STATE_VSCR_HIDDEN, + FSM_STATE_HSCR_SHOWN, + FSM_STATE_HSCR_HIDDEN, + FSM_STATE_BSCR_SHOWN, + FSM_STATE_BSCR_HIDDEN, + FSM_STATE_WIDTH_SHRUNK, + FSM_STATE_WIDTH_EXPANDED, + FSM_STATE_HEIGHT_SHRUNK, + FSM_STATE_HEIGHT_EXPANDED, + FSM_STATE_BOTH_SHRUNK, + FSM_STATE_BOTH_EXPANDED, + FSM_STATE_END +} FSM_STATE; + +#define FSM_STEP_PERIOD_MS 250 + +static UINT_PTR FsmTimer = 0; +static UINT CurrentColor = 0; +static FSM_STATE FsmState = FSM_STATE_START; + +static int ClientWidth = 0; +static int ClientHeight = 0; + +static int OrigWidth = 0; +static int OrigHeight = 0; +static int SmallWidth = 0; +static int SmallHeight = 0; + +static void ColorsCleanup(void) +{ + UINT Iter; + + for (Iter = 0; Iter < _countof(ColorBrushes); Iter++) + { + if (ColorBrushes[Iter] != NULL) + { + DeleteObject(ColorBrushes[Iter]); + ColorBrushes[Iter] = NULL; + } + } +} + +static BOOL ColorsInit(void) +{ + UINT Iter; + + assert(_countof(Colors) == _countof(ColorBrushes)); + + for (Iter = 0; Iter < _countof(ColorBrushes); Iter++) + { + ColorBrushes[Iter] = CreateSolidBrush(Colors[Iter]); + if (ColorBrushes[Iter] == NULL) + { + ColorsCleanup(); + return FALSE; + } + } + + return TRUE; +} + +static void RunTestWindow(PCWSTR ClassName, PCWSTR WindowTitle, UINT ClassStyle) +{ + WNDCLASSW Class = { 0 }; + HWND Window; + MSG Message; + HINSTANCE hInst; + + CurrentColor = 0; + hInst = GetModuleHandleW(NULL); + + Class.style = ClassStyle; + Class.lpfnWndProc = WindowProc; + Class.cbClsExtra = 0; + Class.cbWndExtra = 0; + Class.hInstance = hInst; + Class.hIcon = LoadIcon(NULL, IDI_APPLICATION); + Class.hCursor = LoadCursor(NULL, IDC_ARROW); + Class.hbrBackground = ColorBrushes[CurrentColor]; + Class.lpszMenuName = NULL; + Class.lpszClassName = ClassName; + + if (!RegisterClassW(&Class)) + { + skip("Failed to register window class '%ls', code: %ld\n", + ClassName, GetLastError()); + return; + } + + Window = CreateWindowW(ClassName, + WindowTitle, + WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + NULL, + NULL, + hInst, + NULL); + if (Window == NULL) + { + skip("Failed to create window of class '%ls', code: %ld\n", + ClassName, GetLastError()); + return; + } + + ShowWindow(Window, SW_SHOWNORMAL); + UpdateWindow(Window); + + while (GetMessageW(&Message, NULL, 0, 0)) + { + TranslateMessage(&Message); + DispatchMessageW(&Message); + } +} + +START_TEST(ScrollBarRedraw) +{ + if (!ColorsInit()) + { + skip("Failed to initialize colors and solid color brushes\n"); + return; + } + + trace("Running test without specifying either CS_HREDRAW or CS_HREDRAW\n"); + HaveHRedraw = FALSE; + HaveVRedraw = FALSE; + RunTestWindow(TEST_CLASS_NAME L"NoRedraw", + TEST_WINDOW_TITLE L" (No Redraw Flags)", + 0); + + trace("Running test with CS_HREDRAW\n"); + HaveHRedraw = TRUE; + HaveVRedraw = FALSE; + RunTestWindow(TEST_CLASS_NAME L"HRedraw", + TEST_WINDOW_TITLE L" (CS_HREDRAW)", + CS_HREDRAW); + + trace("Running test with CS_VREDRAW\n"); + HaveHRedraw = FALSE; + HaveVRedraw = TRUE; + RunTestWindow(TEST_CLASS_NAME L"VRedraw", + TEST_WINDOW_TITLE L" (CS_VREDRAW)", + CS_VREDRAW); + + trace("Running test with both CS_HREDRAW and CS_VREDRAW\n"); + HaveHRedraw = TRUE; + HaveVRedraw = TRUE; + RunTestWindow(TEST_CLASS_NAME L"HRedrawVRedraw", + TEST_WINDOW_TITLE L" (CS_HREDRAW | CS_VREDRAW)", + CS_HREDRAW | CS_VREDRAW); + + trace("Test complete\n"); + ColorsCleanup(); +} + +static void HideVertScrollBar(HWND Window) +{ + SCROLLINFO ScrollInfo; + + ScrollInfo.cbSize = sizeof(ScrollInfo); + ScrollInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS; + ScrollInfo.nPage = ClientHeight; + + ScrollInfo.nMin = 0; + ScrollInfo.nMax = ClientHeight - 1; + ScrollInfo.nPos = 0; + + SetScrollInfo(Window, SB_VERT, &ScrollInfo, TRUE); +} + +static void ShowVertScrollBar(HWND Window) +{ + SCROLLINFO ScrollInfo; + + ScrollInfo.cbSize = sizeof(ScrollInfo); + ScrollInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS; + ScrollInfo.nPage = ClientHeight; + + ScrollInfo.nMin = 0; + ScrollInfo.nMax = (3 * ClientHeight) - 1; + ScrollInfo.nPos = 0; + + SetScrollInfo(Window, SB_VERT, &ScrollInfo, TRUE); +} + +static void HideHorzScrollBar(HWND Window) +{ + SCROLLINFO ScrollInfo; + + ScrollInfo.cbSize = sizeof(ScrollInfo); + ScrollInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS; + ScrollInfo.nPage = ClientWidth; + + ScrollInfo.nMin = 0; + ScrollInfo.nMax = ClientWidth - 1; + ScrollInfo.nPos = 0; + + SetScrollInfo(Window, SB_HORZ, &ScrollInfo, TRUE); +} + +static void ShowHorzScrollBar(HWND Window) +{ + SCROLLINFO ScrollInfo; + + ScrollInfo.cbSize = sizeof(ScrollInfo); + ScrollInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS; + ScrollInfo.nPage = ClientWidth; + + ScrollInfo.nMin = 0; + ScrollInfo.nMax = (3 * ClientWidth) - 1; + ScrollInfo.nPos = 0; + + SetScrollInfo(Window, SB_HORZ, &ScrollInfo, TRUE); +} + +static int FsmStep(HWND Window) +{ + static COLORREF PrevColor = CLR_INVALID; + COLORREF Color = CLR_INVALID; + HDC hdc = NULL; + + if (FsmState != FSM_STATE_END) + { + hdc = GetDC(Window); + if (hdc == NULL) + { + skip("Failed to get device context\n"); + + FsmState = FSM_STATE_END; + DestroyWindow(Window); + + return 0; + } + Color = GetPixel(hdc, ClientWidth / 4, ClientHeight / 4); + + ReleaseDC(Window, hdc); + hdc = NULL; + + if (Color == CLR_INVALID) + { + skip("Failed to get window color\n"); + + FsmState = FSM_STATE_END; + DestroyWindow(Window); + + return 0; + } + } + + trace("FsmState: %d, Color: 0x%.8lX\n", FsmState, Color); + + switch (FsmState) + { + case FSM_STATE_START: + ShowVertScrollBar(Window); + FsmState = FSM_STATE_VSCR_SHOWN; + break; + + case FSM_STATE_VSCR_SHOWN: + if (HaveHRedraw) + { + ok(Color != PrevColor, + "CS_HREDRAW specified, but appearence of vertical scroll bar" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "CS_HREDRAW not specified, but appearence of vertical scroll bar" + " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + HideVertScrollBar(Window); + FsmState = FSM_STATE_VSCR_HIDDEN; + break; + + case FSM_STATE_VSCR_HIDDEN: + if (HaveHRedraw) + { + ok(Color != PrevColor, + "CS_HREDRAW specified, but disappearence of vertical scroll bar" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "CS_HREDRAW not specified, but disappearence of vertical scroll bar" + " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + ShowHorzScrollBar(Window); + FsmState = FSM_STATE_HSCR_SHOWN; + break; + + case FSM_STATE_HSCR_SHOWN: + if (HaveVRedraw) + { + ok(Color != PrevColor, + "CS_VREDRAW specified, but appearence of horizontal scroll bar" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "CS_VREDRAW not specified, but appearence of horizontal scroll bar" + " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + HideHorzScrollBar(Window); + FsmState = FSM_STATE_HSCR_HIDDEN; + break; + + case FSM_STATE_HSCR_HIDDEN: + if (HaveVRedraw) + { + ok(Color != PrevColor, + "CS_VREDRAW specified, but disappearence of horizontal scroll bar" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "CS_VREDRAW not specified, but disappearence of horizontal scroll bar" + " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + ShowVertScrollBar(Window); + ShowHorzScrollBar(Window); + + FsmState = FSM_STATE_BSCR_SHOWN; + break; + + case FSM_STATE_BSCR_SHOWN: + if (HaveHRedraw || HaveVRedraw) + { + ok(Color != PrevColor, + "CS_HREDRAW or CS_VREDRAW specified, but appearence of both scroll bars" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "Neither CS_HREDRAW nor CS_VREDRAW specified, but appearence" + " of both scroll bars triggered unneccessary redraw," + " PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + HideVertScrollBar(Window); + HideHorzScrollBar(Window); + + FsmState = FSM_STATE_BSCR_HIDDEN; + break; + + case FSM_STATE_BSCR_HIDDEN: + if (HaveHRedraw || HaveVRedraw) + { + ok(Color != PrevColor, + "CS_HREDRAW or CS_VREDRAW specified, but disappearence of both scroll bars" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "Neither CS_HREDRAW nor CS_VREDRAW specified, but disappearence" + " of both scroll bars triggered unneccessary redraw," + " PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + SetWindowPos(Window, HWND_TOPMOST, 0, 0, SmallWidth, OrigHeight, SWP_NOMOVE); + FsmState = FSM_STATE_WIDTH_SHRUNK; + break; + + case FSM_STATE_WIDTH_SHRUNK: + if (HaveHRedraw) + { + ok(Color != PrevColor, + "CS_HREDRAW specified, but horizontal window shrinkage" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "CS_HREDRAW not specified, but horizontal window shrinkage" + " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + SetWindowPos(Window, HWND_TOPMOST, 0, 0, OrigWidth, OrigHeight, SWP_NOMOVE); + FsmState = FSM_STATE_WIDTH_EXPANDED; + break; + + case FSM_STATE_WIDTH_EXPANDED: + if (HaveHRedraw) + { + ok(Color != PrevColor, + "CS_HREDRAW specified, but horizontal window expansion" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "CS_HREDRAW not specified, but horizontal window expansion" + " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + SetWindowPos(Window, HWND_TOPMOST, 0, 0, OrigWidth, SmallHeight, SWP_NOMOVE); + FsmState = FSM_STATE_HEIGHT_SHRUNK; + break; + + case FSM_STATE_HEIGHT_SHRUNK: + if (HaveVRedraw) + { + ok(Color != PrevColor, + "CS_VREDRAW specified, but vertical window shrinkage" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "CS_VREDRAW not specified, but vertical window shrinkage" + " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + SetWindowPos(Window, HWND_TOPMOST, 0, 0, OrigWidth, OrigHeight, SWP_NOMOVE); + FsmState = FSM_STATE_HEIGHT_EXPANDED; + break; + + case FSM_STATE_HEIGHT_EXPANDED: + if (HaveVRedraw) + { + ok(Color != PrevColor, + "CS_VREDRAW specified, but vertical window expansion" + " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "CS_VREDRAW not specified, but vertical window expansion" + " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + SetWindowPos(Window, HWND_TOPMOST, 0, 0, SmallWidth, SmallHeight, SWP_NOMOVE); + + FsmState = FSM_STATE_BOTH_SHRUNK; + break; + + case FSM_STATE_BOTH_SHRUNK: + if (HaveHRedraw || HaveVRedraw) + { + ok(Color != PrevColor, + "CS_HREDRAW or CS_VREDRAW specified, but combined" + " vertical/horizontal shrinkage didn't trigger redraw," + " PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "Neither CS_HREDRAW nor CS_VREDRAW specified, but combined" + " vertical/horizontal shrinkage triggered unneccessary redraw," + " PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + SetWindowPos(Window, HWND_TOPMOST, 0, 0, OrigWidth, OrigHeight, SWP_NOMOVE); + + FsmState = FSM_STATE_BOTH_EXPANDED; + break; + + case FSM_STATE_BOTH_EXPANDED: + if (HaveHRedraw || HaveVRedraw) + { + ok(Color != PrevColor, + "CS_HREDRAW or CS_VREDRAW specified, but combined" + " vertical/horizontal expansion didn't trigger redraw," + " PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + else + { + ok(Color == PrevColor, + "Neither CS_HREDRAW nor CS_VREDRAW specified, but combined" + " vertical/horizontal expansion triggered unneccessary redraw," + " PrevColor: 0x%.8lX, Color: 0x%.8lX\n", + PrevColor, Color); + } + + FsmState = FSM_STATE_END; + DestroyWindow(Window); + break; + + case FSM_STATE_END: + break; + } + + PrevColor = Color; + return 0; +} + +static int OnPaint(HWND Window) +{ + HRGN Region; + HDC hdc; + PAINTSTRUCT ps; + + hdc = BeginPaint(Window, &ps); + if (hdc == NULL) + { + skip("Failed to get device context\n"); + DestroyWindow(Window); + return 0; + } + + Region = CreateRectRgn(ps.rcPaint.left, + ps.rcPaint.top, + ps.rcPaint.right, + ps.rcPaint.bottom); + if (Region == NULL) + { + skip("Failed to create drawing region\n"); + EndPaint(Window, &ps); + DestroyWindow(Window); + return 0; + } + + if (!FillRgn(hdc, Region, ColorBrushes[CurrentColor])) + { + skip("Failed to paint the window\n"); + DeleteObject(Region); + EndPaint(Window, &ps); + DestroyWindow(Window); + return 0; + } + + DeleteObject(Region); + EndPaint(Window, &ps); + + return 0; +} + +static LRESULT CALLBACK WindowProc(HWND Window, UINT Message, WPARAM wParam, LPARAM lParam) +{ + switch (Message) + { + case WM_CREATE: + { + RECT Rect; + WindowCreatedOk = FALSE; + + /* It's important for the test that the entire Window is visible. */ + if (!SetWindowPos(Window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE)) + { + skip("Failed to set window as top-most, code: %ld\n", GetLastError()); + return -1; + } + + if (!GetClientRect(Window, &Rect)) + { + skip("Failed to retrieve client area dimensions, code: %ld\n", GetLastError()); + return -1; + } + ClientWidth = Rect.right; + ClientHeight = Rect.bottom; + + if (!GetWindowRect(Window, &Rect)) + { + skip("Failed to retrieve window dimensions, code: %ld\n", GetLastError()); + return -1; + } + OrigWidth = Rect.right - Rect.left; + OrigHeight = Rect.bottom - Rect.top; + + SmallWidth = max((OrigWidth * 3) / 4, 1); + SmallHeight = max((OrigHeight * 3) / 4, 1); + OrigWidth = max(OrigWidth, SmallWidth + 1); + OrigHeight = max(OrigHeight, SmallHeight + 1); + + trace("OrigWidth: %d, OrigHeight: %d, SmallWidth: %d, SmallHeight: %d\n", + OrigWidth, OrigHeight, SmallWidth, SmallHeight); + + HideVertScrollBar(Window); + HideHorzScrollBar(Window); + + FsmState = FSM_STATE_START; + FsmTimer = 0; + WindowCreatedOk = TRUE; + return 0; + } + + case WM_PAINT: + if (FsmTimer == 0 && WindowCreatedOk) + { + FsmTimer = SetTimer(Window, 1, FSM_STEP_PERIOD_MS, NULL); + if (FsmTimer == 0) + { + skip("Failed to initialize FSM timer, code: %ld\n", GetLastError()); + WindowCreatedOk = FALSE; + DestroyWindow(Window); + return 0; + } + } + return OnPaint(Window); + + case WM_SIZE: + { + int NewWidth = LOWORD(lParam); + int NewHeight = HIWORD(lParam); + + if (NewWidth != 0 && NewHeight != 0 && + (NewWidth != ClientWidth || NewHeight != ClientHeight)) + { + CurrentColor = (CurrentColor + 1) % TEST_COLOR_COUNT; + SetClassLongPtrW(Window, + GCLP_HBRBACKGROUND, + (LONG_PTR)ColorBrushes[CurrentColor]); + + trace("New window size: %d x %d, new color: 0x%.8lX\n", + NewWidth, NewHeight, Colors[CurrentColor]); + + ClientWidth = NewWidth; + ClientHeight = NewHeight; + } + return 0; + } + + case WM_ERASEBKGND: + /* We use WM_PAINT instead, since WM_ERASEBKGND is issued before WM_SIZE. */ + return 1; + + case WM_TIMER: + if (wParam != 0 && wParam == FsmTimer) + { + return FsmStep(Window); + } + break; + + case WM_NCDESTROY: + if (FsmTimer != 0) + { + KillTimer(Window, FsmTimer); + FsmTimer = 0; + + if (FsmState != FSM_STATE_END) + { + skip("Window closed before test concluded, FsmState: %d, FSM_STATE_END: %d.\n", + FsmState, FSM_STATE_END); + } + } + else if (WindowCreatedOk) + { + skip("Window closed before test began.\n"); + } + return 0; + + case WM_DESTROY: + PostQuitMessage(0); + return 0; + } + return DefWindowProcW(Window, Message, wParam, lParam); +} diff --git a/modules/rostests/apitests/user32/testlist.c b/modules/rostests/apitests/user32/testlist.c index 5186c71c5d1..f8508301df0 100644 --- a/modules/rostests/apitests/user32/testlist.c +++ b/modules/rostests/apitests/user32/testlist.c @@ -42,6 +42,7 @@ extern void func_RealGetWindowClass(void); extern void func_RedrawWindow(void); extern void func_RegisterHotKey(void); extern void func_RegisterClassEx(void); +extern void func_ScrollBarRedraw(void); extern void func_ScrollBarWndExtra(void); extern void func_ScrollDC(void); extern void func_ScrollWindowEx(void); @@ -104,6 +105,7 @@ const struct test winetest_testlist[] = { "RedrawWindow", func_RedrawWindow }, { "RegisterHotKey", func_RegisterHotKey }, { "RegisterClassEx", func_RegisterClassEx }, + { "ScrollBarRedraw", func_ScrollBarRedraw }, { "ScrollBarWndExtra", func_ScrollBarWndExtra }, { "ScrollDC", func_ScrollDC }, { "ScrollWindowEx", func_ScrollWindowEx },

11 months

[reactos] 01/01: [NTUSER] IntSetTimer: Update HintIndex on each call (#7087)

by Tomáš Veselý

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=fd327db20ffd249bcdb39… commit fd327db20ffd249bcdb3900a9806e379b5998f16 Author: Tomáš Veselý <turican0(a)gmail.com> AuthorDate: Tue Aug 27 08:14:51 2024 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Tue Aug 27 01:14:51 2024 -0500 [NTUSER] IntSetTimer: Update HintIndex on each call (#7087) * fix CORE-9141 - adding a change to IDEvent after each pass If the first index is 0 the first returned ID will be 0x8000, which is fine. Co-authored-by: Joachim Henze <joachim.henze(a)reactos.org> --- win32ss/user/ntuser/timer.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/win32ss/user/ntuser/timer.c b/win32ss/user/ntuser/timer.c index 4a9fd3c44ae..6d4a4e983be 100644 --- a/win32ss/user/ntuser/timer.c +++ b/win32ss/user/ntuser/timer.c @@ -19,10 +19,12 @@ static LONG TimeLast = 0; /* Windows 2000 has room for 32768 window-less timers */ #define NUM_WINDOW_LESS_TIMERS 32768 +#define HINTINDEX_BEGIN_VALUE 0 + static PFAST_MUTEX Mutex; static RTL_BITMAP WindowLessTimersBitMap; static PVOID WindowLessTimersBitMapBuffer; -static ULONG HintIndex = 1; +static ULONG HintIndex = HINTINDEX_BEGIN_VALUE; ERESOURCE TimerLock; @@ -219,8 +221,12 @@ IntSetTimer( PWND Window, { IntLockWindowlessTimerBitmap(); - IDEvent = RtlFindClearBitsAndSet(&WindowLessTimersBitMap, 1, HintIndex); - + IDEvent = RtlFindClearBitsAndSet(&WindowLessTimersBitMap, 1, HintIndex++); + if (IDEvent == (UINT_PTR)-1) + { + HintIndex = HINTINDEX_BEGIN_VALUE; + IDEvent = RtlFindClearBitsAndSet(&WindowLessTimersBitMap, 1, HintIndex++); + } if (IDEvent == (UINT_PTR) -1) { IntUnlockWindowlessTimerBitmap();

11 months

[reactos] 01/01: [WIN32KNT_APITEST] Add NtUserSetTimer API tests (#7100)

by Tomáš Veselý

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=938adaad22f3ff35db561… commit 938adaad22f3ff35db56125bc722fb7ef324958b Author: Tomáš Veselý <turican0(a)gmail.com> AuthorDate: Mon Aug 26 21:34:30 2024 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Mon Aug 26 22:34:30 2024 +0300 [WIN32KNT_APITEST] Add NtUserSetTimer API tests (#7100) Test 1 - test of creating/canceling 20 timers and comparing the raw number of returned messages - without parent window Test 2 - test of creating/cancelling 20 timers and comparing the raw number of returned messages - with parent window Test 3 - test creation/cancellation of 40000 timers - without parent window Test 4 - test of creation/cancellation of 40000 timers - with parent window Test 5 - test creation/cancellation of 2 timers and compare their index to see if they differ - without parent window Covers the case in CORE-9141 (see #7087). --- .../apitests/win32nt/ntuser/NtUserSetTimer.c | 252 ++++++++++++++++++++- 1 file changed, 245 insertions(+), 7 deletions(-) diff --git a/modules/rostests/apitests/win32nt/ntuser/NtUserSetTimer.c b/modules/rostests/apitests/win32nt/ntuser/NtUserSetTimer.c index aad40f49698..ccdc6da4602 100644 --- a/modules/rostests/apitests/win32nt/ntuser/NtUserSetTimer.c +++ b/modules/rostests/apitests/win32nt/ntuser/NtUserSetTimer.c @@ -1,18 +1,256 @@ /* - * PROJECT: ReactOS api tests - * LICENSE: GPL - See COPYING in the top level directory - * PURPOSE: Test for NtUserSetTimer - * PROGRAMMERS: + * PROJECT: ReactOS API tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Tests for NtUserSetTimer + * COPYRIGHT: Copyright 2008 Timo Kreuzer <timo.kreuzer(a)reactos.org> + * Copyright 2024 Tomáš Veselý <turican0(a)gmail.com> */ #include "../win32nt.h" +#define SLEEP_TIME 500 +#define TIME_TOLERANCE 0.5 + +#define TEST1_COUNT 20 +#define TEST1_INTERVAL 10 + +#define TEST2_COUNT 40000 +#define TEST2_INTERVAL 10 + +#define TESTW1_COUNT 20 +#define TESTW1_INTERVAL 10 + +#define TESTW2_COUNT 40000 +#define TESTW2_INTERVAL 10 + +typedef struct TIMER_MESSAGE_STATE1 +{ + UINT_PTR index; + UINT counter; +} TIMER_MESSAGE_STATE1; + +TIMER_MESSAGE_STATE1 timerId1[TEST1_COUNT]; + +typedef struct TIMER_MESSAGE_STATEW1 +{ + UINT counter; +} TIMER_MESSAGE_STATEW1; + +TIMER_MESSAGE_STATEW1 timerIdW1[TESTW1_COUNT]; + +/* TIMERPROC for the test1,2,3() with messages without window */ +static void CALLBACK +TimerProc(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime) +{ + UINT i; + for (i = 0; i < TEST1_COUNT; i++) + { + if (timerId1[i].index == idEvent) + timerId1[i].counter++; + } +} + +/* TIMERPROC for the testW1,2() with messages with window */ +static LRESULT CALLBACK +WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_TIMER: + timerIdW1[wParam].counter++; + return 0; + } + + return DefWindowProcW(hwnd, uMsg, wParam, lParam); +} + +// TEST WITH MESSAGES WITHOUT WINDOW - test count of sent messages +static BOOL test1(void) +{ + UINT i, countErrors = 0; + ULONGLONG startTime; + MSG msg = { NULL }; + + int minMessages = ((float)SLEEP_TIME / (float)TEST1_INTERVAL) * (1 - TIME_TOLERANCE); + int maxMessages = ((float)SLEEP_TIME / (float)TEST1_INTERVAL) * (1 + TIME_TOLERANCE); + + ZeroMemory(timerId1, sizeof(timerId1)); + + for (i = 0; i < TEST1_COUNT; i++) + { + timerId1[i].index = SetTimer(NULL, 0, TEST1_INTERVAL, TimerProc); + if (timerId1[i].index == 0) + countErrors++; + } + + startTime = GetTickCount(); + + while (GetMessageW(&msg, NULL, 0, 0)) + { + TranslateMessage(&msg); + DispatchMessageW(&msg); + + if (GetTickCount() - startTime >= SLEEP_TIME) + PostQuitMessage(0); + } + + for (i = 0; i < TEST1_COUNT; i++) + { + if ((timerId1[i].counter < minMessages) || (timerId1[i].counter > maxMessages)) + countErrors++; + } + + for (i = 0; i < TEST1_COUNT; i++) + { + if (KillTimer(NULL, timerId1[i].index) == 0) + countErrors++; + } + + return (countErrors == 0); +} + +// TEST WITH MESSAGES WITHOUT WINDOW - create many timers +static BOOL test2(void) +{ + UINT i, countErrors = 0; + UINT_PTR locIndex; + + for (i = 0; i < TEST2_COUNT; i++) + { + locIndex = SetTimer(NULL, 0, TEST2_INTERVAL, TimerProc); + + if (locIndex == 0) + countErrors++; + if (KillTimer(NULL, locIndex) == 0) + countErrors++; + } + + return (countErrors == 0); +} + +// TEST WITH MESSAGES WITHOUT WINDOW - test different ids +static BOOL test3(void) +{ + UINT countErrors = 0; + UINT_PTR locIndex1; + UINT_PTR locIndex2; + + locIndex1 = SetTimer(NULL, 0, TEST1_INTERVAL, TimerProc); + if (locIndex1 == 0) + countErrors++; + if (KillTimer(NULL, locIndex1) == 0) + countErrors++; + locIndex2 = SetTimer(NULL, 0, TEST1_INTERVAL, TimerProc); + if (locIndex2 == 0) + countErrors++; + if (KillTimer(NULL, locIndex2) == 0) + countErrors++; + if (locIndex1 == locIndex2) + countErrors++; + + return (countErrors == 0); +} + +// TEST WITH MESSAGES WITH WINDOW - test count of sent messages +static BOOL testW1(HWND hwnd) +{ + UINT i, countErrors = 0; + UINT_PTR locIndex; + ULONGLONG startTime; + MSG msg = { NULL }; + + if (hwnd == NULL) + return FALSE; + + int minMessages = ((float)SLEEP_TIME / (float)TESTW1_INTERVAL) * (1 - TIME_TOLERANCE); + int maxMessages = ((float)SLEEP_TIME / (float)TESTW1_INTERVAL) * (1 + TIME_TOLERANCE); + + ZeroMemory(timerIdW1, sizeof(timerIdW1)); + + for (i = 0; i < TESTW1_COUNT; i++) + { + locIndex = SetTimer(hwnd, i, TESTW1_INTERVAL, NULL); + if (locIndex == 0) + countErrors++; + } + + startTime = GetTickCount(); + + while (GetMessageW(&msg, NULL, 0, 0)) + { + TranslateMessage(&msg); + DispatchMessageW(&msg); + + if (GetTickCount() - startTime >= SLEEP_TIME) + PostQuitMessage(0); + } + + for (i = 0; i < TESTW1_COUNT; i++) + { + if ((timerIdW1[i].counter < minMessages) || (timerIdW1[i].counter > maxMessages)) + countErrors++; + } + + for (i = 0; i < TESTW1_COUNT; i++) + { + if (KillTimer(hwnd, i) == 0) + countErrors++; + } + + return (countErrors == 0); +} + +// TEST WITH MESSAGES WITH WINDOW - create many timers +static BOOL testW2(HWND hwnd) +{ + UINT i, countErrors = 0; + UINT_PTR result; + + if (hwnd == NULL) + return FALSE; + + for (i = 0; i < TESTW2_COUNT; i++) + { + result = SetTimer(hwnd, 1, TESTW2_INTERVAL, NULL); + if (result == 0) + countErrors++; + if (KillTimer(hwnd, 1) == 0) + countErrors++; + } + + return (countErrors == 0); +} + START_TEST(NtUserSetTimer) { + WNDCLASSW wc = { 0 }; + HWND hwnd; + + // TEST WITH MESSAGES WITHOUT WINDOW - test count of sent messages + TEST(test1()); + + // TEST WITH MESSAGES WITHOUT WINDOW - create many timers + TEST(test2()); + + // TEST WITH MESSAGES WITHOUT WINDOW - test different ids + TEST(test3()); + + wc.lpfnWndProc = WindowProc; + wc.hInstance = GetModuleHandleW(NULL); + wc.lpszClassName = L"TimerWindowClass"; + RegisterClassW(&wc); + + hwnd = CreateWindowExW(0, L"TimerWindowClass", L"Timer Window", 0, + CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, + HWND_MESSAGE, NULL, GetModuleHandleW(NULL), NULL); + // TEST WITH MESSAGES WITH WINDOW - test count of sent messages + TEST(testW1(hwnd)); - // check valid argument - // check for replacement / new timers - // check when expiries are handled (msgs and calls) + // TEST WITH MESSAGES WITH WINDOW - create many timers + TEST(testW2(hwnd)); + if (hwnd != NULL) + DestroyWindow(hwnd); + UnregisterClassW(L"TimerWindowClass", NULL); }

11 months

[reactos] 02/02: [SETUPLIB][REACTOS][USETUP] Split FS-volume-specific functionality from partitions (#7258)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6f15802af7948d912be03… commit 6f15802af7948d912be038cfc6083ba14acb4ae6 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sat May 18 23:09:16 2024 +0200 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Mon Aug 26 16:42:47 2024 +0200 [SETUPLIB][REACTOS][USETUP] Split FS-volume-specific functionality from partitions (#7258) CORE-13525 This greatly helps in reducing code complexity in some areas: code that previously iterated over all partitions of a given disk, just to find which ones were partitioned and contained a valid file system, now just have to iterate over mounted volumes. See in particular, `lib/utils/osdetect.c` and `lib/fsutil.c` . - Remove FORMATSTATE "Preformatted" enum value; - Cleanup osdetect code after introducing Volume support; - Some simplifications for FormatState. - Differentiate between 'new' partition and 'new' volume: * "New" partition: it has been created and added in the cached list, but not yet actually written into the disk. * "New" volume: newly-created volume (may be backed by a partition or not), not yet formatted. May exist on either new, or not new partition, or elsewhere. - Cache partition and volume NT device names. These do not change across repartitioning operations, as long as the partition or the filesystem volume hasn't been deleted/recreated. This avoids doing \Device\Harddisk%u\Partition%u sprintf's everytime we need to retrieve the given partition or volume device name. When a partition/fileysystem volume is "virtually" created (i.e. in the partition list, but not yet committed to disk and exposed to the OS), no device partition number and device name are available yet. In particular, validate that no manipulation of \Device\HarddiskM\Partition0 (i.e. the whole disk) is being made. --- base/setup/lib/CMakeLists.txt | 1 + base/setup/lib/fsutil.c | 358 +++++++++----------- base/setup/lib/fsutil.h | 8 +- base/setup/lib/setuplib.c | 19 +- base/setup/lib/setuplib.h | 6 +- base/setup/lib/utils/osdetect.c | 241 ++++++------- base/setup/lib/utils/osdetect.h | 8 +- base/setup/lib/utils/partlist.c | 734 +++++++++++++++++++--------------------- base/setup/lib/utils/partlist.h | 62 ++-- base/setup/lib/utils/volutil.c | 226 +++++++++++++ base/setup/lib/utils/volutil.h | 48 +++ base/setup/reactos/drivepage.c | 14 +- base/setup/reactos/reactos.c | 6 +- base/setup/usetup/partlist.c | 16 +- base/setup/usetup/usetup.c | 143 ++++---- 15 files changed, 1018 insertions(+), 872 deletions(-) diff --git a/base/setup/lib/CMakeLists.txt b/base/setup/lib/CMakeLists.txt index 57eae6b3a6e..836c9ef5967 100644 --- a/base/setup/lib/CMakeLists.txt +++ b/base/setup/lib/CMakeLists.txt @@ -21,6 +21,7 @@ list(APPEND SOURCE utils/partinfo.c utils/partlist.c utils/regutil.c + utils/volutil.c bootcode.c bootsup.c fsutil.c diff --git a/base/setup/lib/fsutil.c b/base/setup/lib/fsutil.c index c4a1f02fa16..875e8ec7f9d 100644 --- a/base/setup/lib/fsutil.c +++ b/base/setup/lib/fsutil.c @@ -754,34 +754,22 @@ Quit: // NTSTATUS -ChkdskPartition( - _In_ PPARTENTRY PartEntry, +ChkdskVolume( + _In_ PVOLINFO Volume, _In_ BOOLEAN FixErrors, _In_ BOOLEAN Verbose, _In_ BOOLEAN CheckOnlyIfDirty, _In_ BOOLEAN ScanDrive, _In_opt_ PFMIFSCALLBACK Callback) { - PDISKENTRY DiskEntry = PartEntry->DiskEntry; - // UNICODE_STRING PartitionRootPath; - WCHAR PartitionRootPath[MAX_PATH]; // PathBuffer - - ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); - - /* Do not check a partition with an unknown file system */ - if (!*PartEntry->FileSystem) - return STATUS_UNRECOGNIZED_VOLUME; // STATUS_NOT_SUPPORTED; - - /* Set PartitionRootPath */ - RtlStringCchPrintfW(PartitionRootPath, ARRAYSIZE(PartitionRootPath), - L"\\Device\\Harddisk%lu\\Partition%lu", - DiskEntry->DiskNumber, - PartEntry->PartitionNumber); - DPRINT("PartitionRootPath: %S\n", PartitionRootPath); + /* Do not check a volume with an unknown file system */ + if (!*Volume->FileSystem) + return STATUS_UNRECOGNIZED_VOLUME; - /* Check the partition */ - return ChkdskFileSystem(PartitionRootPath, - PartEntry->FileSystem, + /* Check the volume */ + DPRINT("Volume->DeviceName: %S\n", Volume->DeviceName); + return ChkdskFileSystem(Volume->DeviceName, + Volume->FileSystem, FixErrors, Verbose, CheckOnlyIfDirty, @@ -789,6 +777,67 @@ ChkdskPartition( Callback); } +NTSTATUS +ChkdskPartition( + _In_ PPARTENTRY PartEntry, + _In_ BOOLEAN FixErrors, + _In_ BOOLEAN Verbose, + _In_ BOOLEAN CheckOnlyIfDirty, + _In_ BOOLEAN ScanDrive, + _In_opt_ PFMIFSCALLBACK Callback) +{ + ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); + ASSERT(PartEntry->Volume); + + // if (!PartEntry->Volume) { check_raw_sectors(); } else { check_FS(); } + + /* Check the associated volume */ + return ChkdskVolume(&PartEntry->Volume->Info, + FixErrors, + Verbose, + CheckOnlyIfDirty, + ScanDrive, + Callback); +} + +NTSTATUS +FormatVolume( + _In_ PVOLINFO Volume, + _In_ PCWSTR FileSystemName, + _In_ FMIFS_MEDIA_FLAG MediaFlag, + _In_opt_ PCWSTR Label, + _In_ BOOLEAN QuickFormat, + _In_ ULONG ClusterSize, + _In_opt_ PFMIFSCALLBACK Callback) +{ + NTSTATUS Status; + + if (!FileSystemName || !*FileSystemName) + { + DPRINT1("No file system specified\n"); + return STATUS_UNRECOGNIZED_VOLUME; + } + + /* Format the volume */ + DPRINT("Volume->DeviceName: %S\n", Volume->DeviceName); + Status = FormatFileSystem(Volume->DeviceName, + FileSystemName, + MediaFlag, + Label, + QuickFormat, + ClusterSize, + Callback); + if (!NT_SUCCESS(Status)) + return Status; + + /* Set the new volume's file system and label */ + RtlStringCbCopyW(Volume->FileSystem, sizeof(Volume->FileSystem), FileSystemName); + if (!Label) Label = L""; + RtlStringCbCopyW(Volume->VolumeLabel, sizeof(Volume->VolumeLabel), Label); + + return STATUS_SUCCESS; +} + NTSTATUS FormatPartition( _In_ PPARTENTRY PartEntry, @@ -802,14 +851,12 @@ FormatPartition( NTSTATUS Status; PDISKENTRY DiskEntry = PartEntry->DiskEntry; UCHAR PartitionType; - // UNICODE_STRING PartitionRootPath; - WCHAR PartitionRootPath[MAX_PATH]; // PathBuffer ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); if (!FileSystemName || !*FileSystemName) { - DPRINT1("No file system specified?\n"); + DPRINT1("No file system specified\n"); return STATUS_UNRECOGNIZED_VOLUME; } @@ -867,37 +914,22 @@ FormatPartition( return STATUS_PARTITION_FAILURE; } - /* Set PartitionRootPath */ - RtlStringCchPrintfW(PartitionRootPath, ARRAYSIZE(PartitionRootPath), - L"\\Device\\Harddisk%lu\\Partition%lu", - DiskEntry->DiskNumber, - PartEntry->PartitionNumber); - DPRINT("PartitionRootPath: %S\n", PartitionRootPath); - - /* Format the partition */ - Status = FormatFileSystem(PartitionRootPath, - FileSystemName, - MediaFlag, - Label, - QuickFormat, - ClusterSize, - Callback); + /* We must have an associated volume now */ + ASSERT(PartEntry->Volume); + + /* Format the associated volume */ + Status = FormatVolume(&PartEntry->Volume->Info, + FileSystemName, + MediaFlag, + Label, + QuickFormat, + ClusterSize, + Callback); if (!NT_SUCCESS(Status)) return Status; -// -// TODO: Here, call a partlist.c function that update the actual -// FS name and the label fields of the volume. -// - PartEntry->FormatState = Formatted; - - /* Set the new partition's file system proper */ - RtlStringCbCopyW(PartEntry->FileSystem, - sizeof(PartEntry->FileSystem), - FileSystemName); - - PartEntry->New = FALSE; - + PartEntry->Volume->FormatState = Formatted; + PartEntry->Volume->New = FALSE; return STATUS_SUCCESS; } @@ -908,17 +940,19 @@ FormatPartition( static FSVOL_OP DoFormatting( - _In_ PPARTENTRY PartEntry, + _In_ PVOLENTRY Volume, _In_opt_ PVOID Context, _In_opt_ PFSVOL_CALLBACK FsVolCallback) { FSVOL_OP Result; NTSTATUS Status = STATUS_SUCCESS; + PPARTENTRY PartEntry; FORMAT_VOLUME_INFO FmtInfo = {0}; - ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); + PartEntry = Volume->PartEntry; + ASSERT(PartEntry && (PartEntry->Volume == Volume)); - FmtInfo.PartEntry = PartEntry; + FmtInfo.Volume = Volume; RetryFormat: Result = FsVolCallback(Context, @@ -964,7 +998,7 @@ EndFormat: static FSVOL_OP DoChecking( - _In_ PPARTENTRY PartEntry, + _In_ PVOLENTRY Volume, _In_opt_ PVOID Context, _In_opt_ PFSVOL_CALLBACK FsVolCallback) { @@ -972,11 +1006,9 @@ DoChecking( NTSTATUS Status = STATUS_SUCCESS; CHECK_VOLUME_INFO ChkInfo = {0}; - ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); - - ASSERT(*PartEntry->FileSystem); + ASSERT(*Volume->Info.FileSystem); - ChkInfo.PartEntry = PartEntry; + ChkInfo.Volume = Volume; RetryCheck: Result = FsVolCallback(Context, @@ -986,18 +1018,18 @@ RetryCheck: if (Result != FSVOL_DOIT) goto EndCheck; - /* Check the partition */ - Status = ChkdskPartition(PartEntry, - ChkInfo.FixErrors, - ChkInfo.Verbose, - ChkInfo.CheckOnlyIfDirty, - ChkInfo.ScanDrive, - ChkInfo.Callback); + /* Check the volume */ + Status = ChkdskVolume(&Volume->Info, + ChkInfo.FixErrors, + ChkInfo.Verbose, + ChkInfo.CheckOnlyIfDirty, + ChkInfo.ScanDrive, + ChkInfo.Callback); /* If volume checking succeeded, or if it is not supported * with the current file system, disable checks on the volume */ if (NT_SUCCESS(Status) || (Status == STATUS_NOT_SUPPORTED)) - PartEntry->NeedsCheck = FALSE; + Volume->NeedsCheck = FALSE; if (!NT_SUCCESS(Status)) { @@ -1012,7 +1044,7 @@ RetryCheck: goto RetryCheck; // else if (Result == FSVOL_ABORT || Result == FSVOL_SKIP), stop. - // PartEntry->NeedsCheck = FALSE; + // Volume->NeedsCheck = FALSE; } EndCheck: @@ -1025,125 +1057,44 @@ EndCheck: return Result; } -static BOOLEAN -GetNextUnformattedPartition( - IN PPARTLIST List, - OUT PPARTENTRY *pPartEntry) +static +PVOLENTRY +GetNextUnformattedVolume( + _In_ PPARTLIST List, + _In_opt_ PVOLENTRY Volume) { - PLIST_ENTRY Entry1, Entry2; - PDISKENTRY DiskEntry; - PPARTENTRY PartEntry; + PLIST_ENTRY Entry; - for (Entry1 = List->DiskListHead.Flink; - Entry1 != &List->DiskListHead; - Entry1 = Entry1->Flink) + for (;;) { - DiskEntry = CONTAINING_RECORD(Entry1, - DISKENTRY, - ListEntry); + /* If we have a current volume, get the next one, otherwise get the first */ + Entry = (Volume ? &Volume->ListEntry : &List->VolumesList); + Entry = Entry->Flink; - if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT) - { - DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n"); - continue; - } + if (Entry == &List->VolumesList) + return NULL; - for (Entry2 = DiskEntry->PrimaryPartListHead.Flink; - Entry2 != &DiskEntry->PrimaryPartListHead; - Entry2 = Entry2->Flink) + Volume = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry); + if (Volume->New && (Volume->FormatState == Unformatted)) { - PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - if (PartEntry->IsPartitioned && PartEntry->New) - { - ASSERT(DiskEntry == PartEntry->DiskEntry); - *pPartEntry = PartEntry; - return TRUE; - } - } - - for (Entry2 = DiskEntry->LogicalPartListHead.Flink; - Entry2 != &DiskEntry->LogicalPartListHead; - Entry2 = Entry2->Flink) - { - PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - if (PartEntry->IsPartitioned && PartEntry->New) - { - ASSERT(DiskEntry == PartEntry->DiskEntry); - *pPartEntry = PartEntry; - return TRUE; - } + /* Found a candidate, return it */ + return Volume; } } - - *pPartEntry = NULL; - return FALSE; -} - -static BOOLEAN -GetNextUncheckedPartition( - IN PPARTLIST List, - OUT PPARTENTRY *pPartEntry) -{ - PLIST_ENTRY Entry1, Entry2; - PDISKENTRY DiskEntry; - PPARTENTRY PartEntry; - - for (Entry1 = List->DiskListHead.Flink; - Entry1 != &List->DiskListHead; - Entry1 = Entry1->Flink) - { - DiskEntry = CONTAINING_RECORD(Entry1, - DISKENTRY, - ListEntry); - - if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT) - { - DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n"); - continue; - } - - for (Entry2 = DiskEntry->PrimaryPartListHead.Flink; - Entry2 != &DiskEntry->PrimaryPartListHead; - Entry2 = Entry2->Flink) - { - PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - if (PartEntry->IsPartitioned && PartEntry->NeedsCheck) - { - ASSERT(DiskEntry == PartEntry->DiskEntry); - *pPartEntry = PartEntry; - return TRUE; - } - } - - for (Entry2 = DiskEntry->LogicalPartListHead.Flink; - Entry2 != &DiskEntry->LogicalPartListHead; - Entry2 = Entry2->Flink) - { - PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - if (PartEntry->IsPartitioned && PartEntry->NeedsCheck) - { - ASSERT(DiskEntry == PartEntry->DiskEntry); - *pPartEntry = PartEntry; - return TRUE; - } - } - } - - *pPartEntry = NULL; - return FALSE; } BOOLEAN FsVolCommitOpsQueue( _In_ PPARTLIST PartitionList, - _In_ PPARTENTRY SystemPartition, - _In_ PPARTENTRY InstallPartition, + _In_ PVOLENTRY SystemVolume, + _In_ PVOLENTRY InstallVolume, _In_opt_ PFSVOL_CALLBACK FsVolCallback, _In_opt_ PVOID Context) { BOOLEAN Success = TRUE; // Suppose success originally. FSVOL_OP Result; - PPARTENTRY PartEntry; + PLIST_ENTRY Entry; + PVOLENTRY Volume; /* Machine state for the format step */ typedef enum _FORMATMACHINESTATE @@ -1163,7 +1114,7 @@ FsVolCommitOpsQueue( "FormatDone" }; - ASSERT(PartitionList && InstallPartition && SystemPartition); + ASSERT(PartitionList && SystemVolume && InstallVolume); /* Commit all partition changes to all the disks */ if (!WritePartitionsToDisk(PartitionList)) @@ -1184,8 +1135,8 @@ FsVolCommitOpsQueue( * we must perform a file system check of both the system and the * installation volumes. */ - SystemPartition->NeedsCheck = TRUE; - InstallPartition->NeedsCheck = TRUE; + SystemVolume->NeedsCheck = TRUE; + InstallVolume->NeedsCheck = TRUE; Result = FsVolCallback(Context, FSVOLNOTIFY_STARTQUEUE, @@ -1210,8 +1161,8 @@ FsVolCommitOpsQueue( /* Reset the formatter machine state */ FormatState = Start; + Volume = NULL; NextFormat: - PartEntry = NULL; OldFormatState = FormatState; switch (FormatState) { @@ -1223,12 +1174,11 @@ NextFormat: * volume. Otherwise we just require a file system check on it, * and start by formatting the installation volume instead. */ - ASSERT(SystemPartition->IsPartitioned); - if (SystemPartition != InstallPartition) + if (SystemVolume != InstallVolume) { - PartEntry = SystemPartition; + Volume = SystemVolume; - if (PartEntry->FormatState == Unformatted) + if (Volume->FormatState == Unformatted) { // TODO: Should we let the user use a custom file system, // or should we always use FAT(32) for it? @@ -1241,18 +1191,17 @@ NextFormat: } /* The system volume is separate, so it had better be formatted! */ - ASSERT((PartEntry->FormatState == Preformatted) || - (PartEntry->FormatState == Formatted)); + ASSERT(Volume->FormatState == Formatted); /* Require a file system check on the system volume too */ - PartEntry->NeedsCheck = TRUE; + Volume->NeedsCheck = TRUE; } __fallthrough; } case FormatSystemVolume: { - PartEntry = InstallPartition; + Volume = InstallVolume; FormatState = FormatInstallVolume; DPRINT1("FormatState: %s --> %s\n", @@ -1261,15 +1210,16 @@ NextFormat: } case FormatInstallVolume: + /* Restart volume enumeration */ + Volume = NULL; case FormatOtherVolume: { - BOOLEAN Found = GetNextUnformattedPartition(PartitionList, &PartEntry); - if (Found) ASSERT(PartEntry); + Volume = GetNextUnformattedVolume(PartitionList, Volume); - FormatState = (PartEntry ? FormatOtherVolume : FormatDone); + FormatState = (Volume ? FormatOtherVolume : FormatDone); DPRINT1("FormatState: %s --> %s\n", FormatStateNames[OldFormatState], FormatStateNames[FormatState]); - if (Found) + if (Volume) break; __fallthrough; } @@ -1283,15 +1233,14 @@ NextFormat: DEFAULT_UNREACHABLE; } - ASSERT(PartEntry); - Result = DoFormatting(PartEntry, Context, FsVolCallback); + Result = DoFormatting(Volume, Context, FsVolCallback); if (Result == FSVOL_ABORT) { Success = FALSE; goto Quit; } /* Schedule a check for this volume */ - PartEntry->NeedsCheck = TRUE; + Volume->NeedsCheck = TRUE; /* Go to the next volume to be formatted */ goto NextFormat; @@ -1314,24 +1263,27 @@ StartCheckQueue: if (Result == FSVOL_ABORT) return FALSE; -NextCheck: - if (!GetNextUncheckedPartition(PartitionList, &PartEntry)) + /* Loop through each unchecked volume and do the check */ + for (Entry = PartitionList->VolumesList.Flink; + Entry != &PartitionList->VolumesList; + Entry = Entry->Flink) { - Success = TRUE; - goto EndCheck; - } + Volume = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry); + if (!Volume->NeedsCheck) + continue; - ASSERT(PartEntry); - Result = DoChecking(PartEntry, Context, FsVolCallback); - if (Result == FSVOL_ABORT) - { - Success = FALSE; - goto Quit; + /* Found a candidate */ + ASSERT(Volume->FormatState == Formatted); + Result = DoChecking(Volume, Context, FsVolCallback); + if (Result == FSVOL_ABORT) + { + Success = FALSE; + goto Quit; + } + /* Go to the next volume to be checked */ } - /* Go to the next volume to be checked */ - goto NextCheck; + Success = TRUE; -EndCheck: FsVolCallback(Context, FSVOLNOTIFY_ENDSUBQUEUE, FSVOL_CHECK, diff --git a/base/setup/lib/fsutil.h b/base/setup/lib/fsutil.h index b132148a1f2..5af0a4265f5 100644 --- a/base/setup/lib/fsutil.h +++ b/base/setup/lib/fsutil.h @@ -163,7 +163,7 @@ typedef enum _FSVOL_OP typedef struct _FORMAT_VOLUME_INFO { - PPARTENTRY PartEntry; + PVOLENTRY Volume; // PCWSTR NtPathPartition; NTSTATUS ErrorStatus; @@ -179,7 +179,7 @@ typedef struct _FORMAT_VOLUME_INFO typedef struct _CHECK_VOLUME_INFO { - PPARTENTRY PartEntry; + PVOLENTRY Volume; // PCWSTR NtPathPartition; NTSTATUS ErrorStatus; @@ -202,8 +202,8 @@ typedef FSVOL_OP BOOLEAN FsVolCommitOpsQueue( _In_ PPARTLIST PartitionList, - _In_ PPARTENTRY SystemPartition, - _In_ PPARTENTRY InstallPartition, + _In_ PVOLENTRY SystemVolume, + _In_ PVOLENTRY InstallVolume, _In_opt_ PFSVOL_CALLBACK FsVolCallback, _In_opt_ PVOID Context); diff --git a/base/setup/lib/setuplib.c b/base/setup/lib/setuplib.c index ea190cece3c..f8a961ab3c1 100644 --- a/base/setup/lib/setuplib.c +++ b/base/setup/lib/setuplib.c @@ -695,7 +695,8 @@ InitSystemPartition( * In all cases, whether or not we are going to perform a formatting, * we must perform a filesystem check of the system partition. */ - SystemPartition->NeedsCheck = TRUE; + if (SystemPartition->Volume) + SystemPartition->Volume->NeedsCheck = TRUE; return TRUE; } @@ -794,23 +795,21 @@ IsValidInstallDirectory( NTSTATUS InitDestinationPaths( - IN OUT PUSETUP_DATA pSetupData, - IN PCWSTR InstallationDir, - IN PPARTENTRY PartEntry) // FIXME: HACK! + _Inout_ PUSETUP_DATA pSetupData, + _In_ PCWSTR InstallationDir, + _In_ PVOLENTRY Volume) { NTSTATUS Status; + PPARTENTRY PartEntry = Volume->PartEntry; PDISKENTRY DiskEntry = PartEntry->DiskEntry; - WCHAR PathBuffer[MAX_PATH]; + WCHAR PathBuffer[RTL_NUMBER_OF_FIELD(VOLINFO, DeviceName) + 1]; ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); /* Create 'pSetupData->DestinationRootPath' string */ RtlFreeUnicodeString(&pSetupData->DestinationRootPath); - Status = RtlStringCchPrintfW(PathBuffer, ARRAYSIZE(PathBuffer), - L"\\Device\\Harddisk%lu\\Partition%lu\\", - DiskEntry->DiskNumber, - PartEntry->PartitionNumber); - + Status = RtlStringCchPrintfW(PathBuffer, _countof(PathBuffer), + L"%s\\", Volume->Info.DeviceName); if (!NT_SUCCESS(Status)) { DPRINT1("RtlStringCchPrintfW() failed with status 0x%08lx\n", Status); diff --git a/base/setup/lib/setuplib.h b/base/setup/lib/setuplib.h index 99c02ba86a1..02abdedc658 100644 --- a/base/setup/lib/setuplib.h +++ b/base/setup/lib/setuplib.h @@ -204,9 +204,9 @@ IsValidInstallDirectory( NTSTATUS InitDestinationPaths( - IN OUT PUSETUP_DATA pSetupData, - IN PCWSTR InstallationDir, - IN PPARTENTRY PartEntry); // FIXME: HACK! + _Inout_ PUSETUP_DATA pSetupData, + _In_ PCWSTR InstallationDir, + _In_ PVOLENTRY Volume); // NTSTATUS ERROR_NUMBER diff --git a/base/setup/lib/utils/osdetect.c b/base/setup/lib/utils/osdetect.c index 2512cfbe26f..1a4abd5cb6a 100644 --- a/base/setup/lib/utils/osdetect.c +++ b/base/setup/lib/utils/osdetect.c @@ -1,9 +1,9 @@ /* * PROJECT: ReactOS Setup Library - * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) * PURPOSE: NT 5.x family (MS Windows <= 2003, and ReactOS) * operating systems detection code. - * COPYRIGHT: Copyright 2017-2018 Hermes Belusca-Maito + * COPYRIGHT: Copyright 2017-2024 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> */ /* INCLUDES *****************************************************************/ @@ -46,22 +46,20 @@ FindExistingNTOSInstall( static PNTOS_INSTALLATION AddNTOSInstallation( - IN PGENERIC_LIST List, - IN PCWSTR InstallationName, - IN USHORT Machine, - IN PCWSTR VendorName, - IN PCWSTR SystemRootArcPath, - IN PUNICODE_STRING SystemRootNtPath, // or PCWSTR ? - IN PCWSTR PathComponent, // Pointer inside SystemRootNtPath buffer - IN ULONG DiskNumber, - IN ULONG PartitionNumber, - IN PPARTENTRY PartEntry OPTIONAL); + _In_ PGENERIC_LIST List, + _In_ PCWSTR InstallationName, + _In_ USHORT Machine, + _In_ PCWSTR VendorName, + _In_ PCWSTR SystemRootArcPath, + _In_ PUNICODE_STRING SystemRootNtPath, // or PCWSTR ? + _In_ PCWSTR PathComponent, // Pointer inside SystemRootNtPath buffer + _In_ ULONG DiskNumber, + _In_ ULONG PartitionNumber); typedef struct _ENUM_INSTALLS_DATA { - IN OUT PGENERIC_LIST List; - IN PPARTLIST PartList; - // IN PPARTENTRY PartEntry; + _Inout_ PGENERIC_LIST List; + _In_ PPARTLIST PartList; } ENUM_INSTALLS_DATA, *PENUM_INSTALLS_DATA; // PENUM_BOOT_ENTRIES_ROUTINE @@ -78,7 +76,6 @@ EnumerateInstallations( ULONG DiskNumber = 0, PartitionNumber = 0; PCWSTR PathComponent = NULL; - PPARTENTRY PartEntry = NULL; UNICODE_STRING SystemRootPath; WCHAR SystemRoot[MAX_PATH]; @@ -136,9 +133,9 @@ EnumerateInstallations( } /* - * Convert the ARC path into an NT path, from which we will deduce - * the real disk drive & partition on which the candidate installation - * resides, as well verifying whether it is indeed an NTOS installation. + * Convert the ARC path into an NT path, from which we will deduce the + * real disk & partition on which the candidate installation resides, + * as well as verifying whether it is indeed an NTOS installation. */ RtlInitEmptyUnicodeString(&SystemRootPath, SystemRoot, sizeof(SystemRoot)); if (!ArcPathToNtPath(&SystemRootPath, Options->OsLoadPath, Data->PartList)) @@ -182,14 +179,6 @@ EnumerateInstallations( { DPRINT("SystemRootPath = '%wZ' points to disk #%d, partition #%d, path '%S'\n", &SystemRootPath, DiskNumber, PartitionNumber, PathComponent); - - /* Retrieve the corresponding partition */ - PartEntry = SelectPartition(Data->PartList, DiskNumber, PartitionNumber); - if (!PartEntry) - { - DPRINT1("SelectPartition(disk #%d, partition #%d) failed\n", - DiskNumber, PartitionNumber); - } } else { @@ -197,13 +186,24 @@ EnumerateInstallations( } /* Add the discovered NTOS installation into the list */ - AddNTOSInstallation(Data->List, - BootEntry->FriendlyName, - Machine, - VendorName.Buffer, // FIXME: What if it's not NULL-terminated? - Options->OsLoadPath, - &SystemRootPath, PathComponent, - DiskNumber, PartitionNumber, PartEntry); + NtOsInstall = AddNTOSInstallation(Data->List, + BootEntry->FriendlyName, + Machine, + VendorName.Buffer, // FIXME: What if it's not NULL-terminated? + Options->OsLoadPath, + &SystemRootPath, PathComponent, + DiskNumber, PartitionNumber); + if (NtOsInstall) + { + /* Retrieve the volume corresponding to the disk and partition numbers */ + PPARTENTRY PartEntry = SelectPartition(Data->PartList, DiskNumber, PartitionNumber); + if (!PartEntry) + { + DPRINT1("SelectPartition(disk #%d, partition #%d) failed\n", + DiskNumber, PartitionNumber); + } + NtOsInstall->Volume = (PartEntry ? PartEntry->Volume : NULL); + } /* Continue the enumeration */ return STATUS_SUCCESS; @@ -607,16 +607,15 @@ FindExistingNTOSInstall( static PNTOS_INSTALLATION AddNTOSInstallation( - IN PGENERIC_LIST List, - IN PCWSTR InstallationName, - IN USHORT Machine, - IN PCWSTR VendorName, - IN PCWSTR SystemRootArcPath, - IN PUNICODE_STRING SystemRootNtPath, // or PCWSTR ? - IN PCWSTR PathComponent, // Pointer inside SystemRootNtPath buffer - IN ULONG DiskNumber, - IN ULONG PartitionNumber, - IN PPARTENTRY PartEntry OPTIONAL) + _In_ PGENERIC_LIST List, + _In_ PCWSTR InstallationName, + _In_ USHORT Machine, + _In_ PCWSTR VendorName, + _In_ PCWSTR SystemRootArcPath, + _In_ PUNICODE_STRING SystemRootNtPath, // or PCWSTR ? + _In_ PCWSTR PathComponent, // Pointer inside SystemRootNtPath buffer + _In_ ULONG DiskNumber, + _In_ ULONG PartitionNumber) { PNTOS_INSTALLATION NtOsInstall; SIZE_T ArcPathLength, NtPathLength; @@ -648,8 +647,6 @@ AddNTOSInstallation( NtOsInstall->DiskNumber = DiskNumber; NtOsInstall->PartitionNumber = PartitionNumber; - NtOsInstall->PartEntry = PartEntry; - NtOsInstall->Machine = Machine; RtlInitEmptyUnicodeString(&NtOsInstall->SystemArcPath, @@ -680,39 +677,34 @@ AddNTOSInstallation( static VOID FindNTOSInstallations( - IN OUT PGENERIC_LIST List, - IN PPARTLIST PartList, - IN PPARTENTRY PartEntry) + _Inout_ PGENERIC_LIST List, + _In_ PPARTLIST PartList, + _In_ PVOLENTRY Volume) { NTSTATUS Status; - ULONG DiskNumber = PartEntry->DiskEntry->DiskNumber; - ULONG PartitionNumber = PartEntry->PartitionNumber; - HANDLE PartitionDirectoryHandle; + HANDLE VolumeRootDirHandle; OBJECT_ATTRIBUTES ObjectAttributes; IO_STATUS_BLOCK IoStatusBlock; - UNICODE_STRING PartitionRootPath; + UNICODE_STRING VolumeRootPath; BOOT_STORE_TYPE Type; PVOID BootStoreHandle; ENUM_INSTALLS_DATA Data; ULONG Version; - WCHAR PathBuffer[MAX_PATH]; - - ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); + WCHAR PathBuffer[RTL_NUMBER_OF_FIELD(VOLINFO, DeviceName) + 1]; - /* Set PartitionRootPath */ - RtlStringCchPrintfW(PathBuffer, ARRAYSIZE(PathBuffer), - L"\\Device\\Harddisk%lu\\Partition%lu\\", - DiskNumber, PartitionNumber); - RtlInitUnicodeString(&PartitionRootPath, PathBuffer); - DPRINT("FindNTOSInstallations: PartitionRootPath: '%wZ'\n", &PartitionRootPath); + /* Set VolumeRootPath */ + RtlStringCchPrintfW(PathBuffer, _countof(PathBuffer), + L"%s\\", Volume->Info.DeviceName); + RtlInitUnicodeString(&VolumeRootPath, PathBuffer); + DPRINT("FindNTOSInstallations(%wZ)\n", &VolumeRootPath); - /* Open the partition */ + /* Open the volume */ InitializeObjectAttributes(&ObjectAttributes, - &PartitionRootPath, + &VolumeRootPath, OBJ_CASE_INSENSITIVE, NULL, NULL); - Status = NtOpenFile(&PartitionDirectoryHandle, + Status = NtOpenFile(&VolumeRootDirHandle, FILE_LIST_DIRECTORY | FILE_TRAVERSE | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, @@ -720,7 +712,7 @@ FindNTOSInstallations( FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE); if (!NT_SUCCESS(Status)) { - DPRINT1("Failed to open partition '%wZ', Status 0x%08lx\n", &PartitionRootPath, Status); + DPRINT1("Failed to open volume '%wZ', Status 0x%08lx\n", &VolumeRootPath, Status); return; } @@ -730,7 +722,7 @@ FindNTOSInstallations( /* Try to see whether we recognize some NT boot loaders */ for (Type = FreeLdr; Type < BldrTypeMax; ++Type) { - Status = FindBootStore(PartitionDirectoryHandle, Type, &Version); + Status = FindBootStore(VolumeRootDirHandle, Type, &Version); if (!NT_SUCCESS(Status)) { /* The loader does not exist, continue with another one */ @@ -740,10 +732,12 @@ FindNTOSInstallations( } /* The loader exists, try to enumerate its boot entries */ - DPRINT("Analyze the OS installations for loader type '%d' in disk #%d, partition #%d\n", - Type, DiskNumber, PartitionNumber); + DPRINT("Analyze the OS installations for loader type '%d' in Volume %wZ (Disk #%d, Partition #%d)\n", + Type, &VolumeRootPath, + Volume->PartEntry->DiskEntry->DiskNumber, + Volume->PartEntry->PartitionNumber); - Status = OpenBootStoreByHandle(&BootStoreHandle, PartitionDirectoryHandle, Type, + Status = OpenBootStoreByHandle(&BootStoreHandle, VolumeRootDirHandle, Type, BS_OpenExisting, BS_ReadAccess); if (!NT_SUCCESS(Status)) { @@ -755,90 +749,63 @@ FindNTOSInstallations( CloseBootStore(BootStoreHandle); } - /* Close the partition */ - NtClose(PartitionDirectoryHandle); -} - -// static -FORCEINLINE BOOLEAN -ShouldICheckThisPartition( - IN PPARTENTRY PartEntry) -{ - if (!PartEntry) - return FALSE; - - return PartEntry->IsPartitioned && - !IsContainerPartition(PartEntry->PartitionType) /* alternatively: PartEntry->PartitionNumber != 0 */ && - !PartEntry->New && - (PartEntry->FormatState == Preformatted /* || PartEntry->FormatState == Formatted */); + /* Close the volume */ + NtClose(VolumeRootDirHandle); } +/** + * @brief + * Create a list of available NT OS installations on the computer, + * by searching for recognized ones on each recognized storage volume. + **/ // EnumerateNTOSInstallations PGENERIC_LIST CreateNTOSInstallationsList( - IN PPARTLIST PartList) + _In_ PPARTLIST PartList) { PGENERIC_LIST List; - PLIST_ENTRY Entry, Entry2; - PDISKENTRY DiskEntry; - PPARTENTRY PartEntry; + PLIST_ENTRY Entry; + PVOLENTRY Volume; + BOOLEAN CheckVolume; List = CreateGenericList(); - if (List == NULL) + if (!List) return NULL; - /* Loop each available disk ... */ - Entry = PartList->DiskListHead.Flink; - while (Entry != &PartList->DiskListHead) + /* Loop each available volume */ + for (Entry = PartList->VolumesList.Flink; + Entry != &PartList->VolumesList; + Entry = Entry->Flink) { - DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry); - Entry = Entry->Flink; - - DPRINT("Disk #%d\n", DiskEntry->DiskNumber); + Volume = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry); + /* Valid OS installations can be found only on basic volumes */ + if (!Volume->PartEntry) // TODO: In the future: (!Volume->IsSimpleVolume) + continue; - /* ... and for each disk, loop each available partition */ + CheckVolume = (!Volume->New && (Volume->FormatState == Formatted)); - /* First, the primary partitions */ - Entry2 = DiskEntry->PrimaryPartListHead.Flink; - while (Entry2 != &DiskEntry->PrimaryPartListHead) +#ifndef NDEBUG { - PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - Entry2 = Entry2->Flink; - - ASSERT(PartEntry->DiskEntry == DiskEntry); - - DPRINT(" Primary Partition #%d, index %d - Type 0x%02x, IsLogical = %s, IsPartitioned = %s, IsNew = %s, FormatState = %lu -- Should I check it? %s\n", - PartEntry->PartitionNumber, PartEntry->PartitionIndex, - PartEntry->PartitionType, PartEntry->LogicalPartition ? "TRUE" : "FALSE", - PartEntry->IsPartitioned ? "TRUE" : "FALSE", - PartEntry->New ? "Yes" : "No", - PartEntry->FormatState, - ShouldICheckThisPartition(PartEntry) ? "YES!" : "NO!"); - - if (ShouldICheckThisPartition(PartEntry)) - FindNTOSInstallations(List, PartList, PartEntry); + PPARTENTRY PartEntry = Volume->PartEntry; + ASSERT(PartEntry->Volume == Volume); + DPRINT("Volume %S (%c%c) on Disk #%d, Partition #%d (%s), " + "index %d - Type 0x%02x, IsVolNew = %s, FormatState = %lu -- Should I check it? %s\n", + Volume->Info.DeviceName, + !Volume->Info.DriveLetter ? '-' : (CHAR)Volume->Info.DriveLetter, + !Volume->Info.DriveLetter ? '-' : ':', + PartEntry->DiskEntry->DiskNumber, + PartEntry->PartitionNumber, + PartEntry->LogicalPartition ? "Logical" : "Primary", + PartEntry->PartitionIndex, + PartEntry->PartitionType, + Volume->New ? "Yes" : "No", + Volume->FormatState, + CheckVolume ? "YES!" : "NO!"); } +#endif - /* Then, the logical partitions (present in the extended partition) */ - Entry2 = DiskEntry->LogicalPartListHead.Flink; - while (Entry2 != &DiskEntry->LogicalPartListHead) - { - PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - Entry2 = Entry2->Flink; - - ASSERT(PartEntry->DiskEntry == DiskEntry); - - DPRINT(" Logical Partition #%d, index %d - Type 0x%02x, IsLogical = %s, IsPartitioned = %s, IsNew = %s, FormatState = %lu -- Should I check it? %s\n", - PartEntry->PartitionNumber, PartEntry->PartitionIndex, - PartEntry->PartitionType, PartEntry->LogicalPartition ? "TRUE" : "FALSE", - PartEntry->IsPartitioned ? "TRUE" : "FALSE", - PartEntry->New ? "Yes" : "No", - PartEntry->FormatState, - ShouldICheckThisPartition(PartEntry) ? "YES!" : "NO!"); - - if (ShouldICheckThisPartition(PartEntry)) - FindNTOSInstallations(List, PartList, PartEntry); - } + if (CheckVolume) + FindNTOSInstallations(List, PartList, Volume); } #ifndef NDEBUG diff --git a/base/setup/lib/utils/osdetect.h b/base/setup/lib/utils/osdetect.h index e8b54496011..e329b1c32f4 100644 --- a/base/setup/lib/utils/osdetect.h +++ b/base/setup/lib/utils/osdetect.h @@ -1,9 +1,9 @@ /* * PROJECT: ReactOS Setup Library - * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) * PURPOSE: NT 5.x family (MS Windows <= 2003, and ReactOS) * operating systems detection code. - * COPYRIGHT: Copyright 2017-2018 Hermes Belusca-Maito + * COPYRIGHT: Copyright 2017-2024 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> */ #pragma once @@ -22,7 +22,7 @@ typedef struct _NTOS_INSTALLATION PCWSTR PathComponent; // Pointer inside SystemNtPath.Buffer ULONG DiskNumber; ULONG PartitionNumber; - PPARTENTRY PartEntry; + PVOLENTRY Volume; // PVOLINFO WCHAR InstallationName[MAX_PATH]; WCHAR VendorName[MAX_PATH]; // CHAR Data[ANYSIZE_ARRAY]; @@ -31,7 +31,7 @@ typedef struct _NTOS_INSTALLATION // EnumerateNTOSInstallations PGENERIC_LIST CreateNTOSInstallationsList( - IN PPARTLIST List); + _In_ PPARTLIST PartList); /* * FindSubStrI(PCWSTR str, PCWSTR strSearch) : diff --git a/base/setup/lib/utils/partlist.c b/base/setup/lib/utils/partlist.c index 914fe69ccb3..466a1826979 100644 --- a/base/setup/lib/utils/partlist.c +++ b/base/setup/lib/utils/partlist.c @@ -1,31 +1,31 @@ /* * PROJECT: ReactOS Setup Library - * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) * PURPOSE: Partition list functions * COPYRIGHT: Copyright 2003-2019 Casper S. Hornstrup (chorns(a)users.sourceforge.net) - * Copyright 2018-2019 Hermes Belusca-Maito + * Copyright 2018-2024 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> */ #include "precomp.h" #include <ntddscsi.h> #include "partlist.h" -#include "fsrec.h" +#include "volutil.h" +#include "fsrec.h" // For FileSystemToMBRPartitionType() + #include "registry.h" #define NDEBUG #include <debug.h> -//#define DUMP_PARTITION_TABLE +// #define DUMP_PARTITION_TABLE #include <pshpack1.h> - typedef struct _REG_DISK_MOUNT_INFO { ULONG Signature; - LARGE_INTEGER StartingOffset; + ULONGLONG StartingOffset; } REG_DISK_MOUNT_INFO, *PREG_DISK_MOUNT_INFO; - #include <poppack.h> @@ -159,22 +159,17 @@ AssignDriveLetters( { PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - PartEntry->DriveLetter = 0; + if (!PartEntry->Volume) + continue; + PartEntry->Volume->Info.DriveLetter = UNICODE_NULL; if (PartEntry->IsPartitioned && - !IsContainerPartition(PartEntry->PartitionType)) + !IsContainerPartition(PartEntry->PartitionType) && + (IsRecognizedPartition(PartEntry->PartitionType) || + PartEntry->SectorCount.QuadPart != 0LL)) { - ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); - - if (IsRecognizedPartition(PartEntry->PartitionType) || - PartEntry->SectorCount.QuadPart != 0LL) - { - if (Letter <= L'Z') - { - PartEntry->DriveLetter = Letter; - Letter++; - } - } + if (Letter <= L'Z') + PartEntry->Volume->Info.DriveLetter = Letter++; } } } @@ -192,21 +187,16 @@ AssignDriveLetters( { PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - PartEntry->DriveLetter = 0; + if (!PartEntry->Volume) + continue; + PartEntry->Volume->Info.DriveLetter = UNICODE_NULL; - if (PartEntry->IsPartitioned) + if (PartEntry->IsPartitioned && + (IsRecognizedPartition(PartEntry->PartitionType) || + PartEntry->SectorCount.QuadPart != 0LL)) { - ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); - - if (IsRecognizedPartition(PartEntry->PartitionType) || - PartEntry->SectorCount.QuadPart != 0LL) - { - if (Letter <= L'Z') - { - PartEntry->DriveLetter = Letter; - Letter++; - } - } + if (Letter <= L'Z') + PartEntry->Volume->Info.DriveLetter = Letter++; } } } @@ -564,8 +554,8 @@ IsSuperFloppy( /* - * Inserts the disk region represented by PartEntry into either the primary - * or the logical partition list of the given disk. + * Inserts the disk region represented by PartEntry into either + * the primary or the logical partition list of the given disk. * The lists are kept sorted by increasing order of start sectors. * Of course no disk region should overlap at all with one another. */ @@ -649,7 +639,7 @@ CreateInsertBlankRegion( NewPartEntry = RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, sizeof(PARTENTRY)); - if (NewPartEntry == NULL) + if (!NewPartEntry) return NULL; NewPartEntry->DiskEntry = DiskEntry; @@ -660,8 +650,7 @@ CreateInsertBlankRegion( NewPartEntry->LogicalPartition = LogicalSpace; NewPartEntry->IsPartitioned = FALSE; NewPartEntry->PartitionType = PARTITION_ENTRY_UNUSED; - NewPartEntry->FormatState = Unformatted; - NewPartEntry->FileSystem[0] = L'\0'; + NewPartEntry->Volume = NULL; DPRINT1("First Sector : %I64u\n", NewPartEntry->StartSector.QuadPart); DPRINT1("Last Sector : %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1); @@ -673,6 +662,17 @@ CreateInsertBlankRegion( return NewPartEntry; } +static +VOID +DestroyRegion( + _Inout_ PPARTENTRY PartEntry) +{ + // RemoveEntryList(&PartEntry->Volume->ListEntry); + if (PartEntry->Volume) + RtlFreeHeap(ProcessHeap, 0, PartEntry->Volume); + RtlFreeHeap(ProcessHeap, 0, PartEntry); +} + static VOID AddLogicalDiskSpace( @@ -719,6 +719,7 @@ InitializePartitionEntry( /* The entry must not be already partitioned and not be void */ ASSERT(!PartEntry->IsPartitioned); ASSERT(PartEntry->SectorCount.QuadPart); + ASSERT(!PartEntry->Volume); /* Either we create a primary/logical partition, or we create an * extended partition but the entry must not be logical space */ @@ -780,7 +781,7 @@ InitializePartitionEntry( PartEntry->SectorCount.QuadPart = StartSector - PartEntry->StartSector.QuadPart; } - /* Convert the partition entry to 'New (Unformatted)' */ + /* Convert to a new partition entry */ PartEntry->New = TRUE; PartEntry->IsPartitioned = TRUE; @@ -819,9 +820,6 @@ InitializePartitionEntry( } ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); - PartEntry->FormatState = Unformatted; - PartEntry->FileSystem[0] = L'\0'; - if (isContainer) { DiskEntry->ExtendedPartition = PartEntry; @@ -835,6 +833,90 @@ InitializePartitionEntry( return TRUE; } +static +VOID +InitPartitionDeviceName( + _Inout_ PPARTENTRY PartEntry) +{ + NTSTATUS Status; + + /* Ignore if this is a container partition */ + if (IsContainerPartition(PartEntry->PartitionType)) + return; + ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); + + /* Make a device name for the partition */ + Status = RtlStringCchPrintfW(PartEntry->DeviceName, + _countof(PartEntry->DeviceName), + L"\\Device\\Harddisk%lu\\Partition%lu", + PartEntry->DiskEntry->DiskNumber, + PartEntry->PartitionNumber); + ASSERT(NT_SUCCESS(Status)); +} + +static +VOID +InitVolumeDeviceName( + _Inout_ PVOLENTRY Volume) +{ + NTSTATUS Status; + PPARTENTRY PartEntry; + + /* If we already have a volume device name, do nothing more */ + if (*Volume->Info.DeviceName) + return; + + /* Use the partition device name as a temporary volume device name */ + // TODO: Ask instead the MOUNTMGR for the name. + PartEntry = Volume->PartEntry; + ASSERT(PartEntry); + ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); + + /* Copy the volume device name */ + Status = RtlStringCchCopyW(Volume->Info.DeviceName, + _countof(Volume->Info.DeviceName), + PartEntry->DeviceName); + ASSERT(NT_SUCCESS(Status)); +} + +static +PVOLENTRY +InitVolume( + _In_ PPARTLIST List, + _In_opt_ PPARTENTRY PartEntry) +{ + PVOLENTRY Volume; + + Volume = RtlAllocateHeap(ProcessHeap, + HEAP_ZERO_MEMORY, + sizeof(VOLENTRY)); + if (!Volume) + return NULL; + + /* Reset some volume information */ + + /* No device name for now */ + Volume->Info.DeviceName[0] = UNICODE_NULL; + // Volume->Info.VolumeName[0] = UNICODE_NULL; + + /* Initialize the volume letter and label */ + Volume->Info.DriveLetter = UNICODE_NULL; + Volume->Info.VolumeLabel[0] = UNICODE_NULL; + + /* Specify the volume as initially unformatted */ + Volume->Info.FileSystem[0] = UNICODE_NULL; + Volume->FormatState = Unformatted; + Volume->NeedsCheck = FALSE; + Volume->New = TRUE; + + if (PartEntry) + { + ASSERT(PartEntry->DiskEntry->PartList == List); + Volume->PartEntry = PartEntry; + } + InsertTailList(&List->VolumesList, &Volume->ListEntry); + return Volume; +} static VOID @@ -844,29 +926,21 @@ AddPartitionToDisk( IN ULONG PartitionIndex, IN BOOLEAN LogicalPartition) { - NTSTATUS Status; PPARTITION_INFORMATION PartitionInfo; PPARTENTRY PartEntry; - HANDLE PartitionHandle; - OBJECT_ATTRIBUTES ObjectAttributes; - IO_STATUS_BLOCK IoStatusBlock; - WCHAR PathBuffer[MAX_PATH]; - UNICODE_STRING Name; - UCHAR LabelBuffer[sizeof(FILE_FS_VOLUME_INFORMATION) + 256 * sizeof(WCHAR)]; - PFILE_FS_VOLUME_INFORMATION LabelInfo = (PFILE_FS_VOLUME_INFORMATION)LabelBuffer; PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[PartitionIndex]; - if (PartitionInfo->PartitionType == PARTITION_ENTRY_UNUSED || - ((LogicalPartition != FALSE) && IsContainerPartition(PartitionInfo->PartitionType))) - { + /* Ignore empty partitions */ + if (PartitionInfo->PartitionType == PARTITION_ENTRY_UNUSED) return; - } + /* Request must be consistent, though! */ + ASSERT(!(LogicalPartition && IsContainerPartition(PartitionInfo->PartitionType))); PartEntry = RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, sizeof(PARTENTRY)); - if (PartEntry == NULL) + if (!PartEntry) return; PartEntry->DiskEntry = DiskEntry; @@ -882,146 +956,73 @@ AddPartitionToDisk( PartEntry->OnDiskPartitionNumber = PartitionInfo->PartitionNumber; PartEntry->PartitionNumber = PartitionInfo->PartitionNumber; PartEntry->PartitionIndex = PartitionIndex; + InitPartitionDeviceName(PartEntry); - /* Specify the partition as initially unformatted */ - PartEntry->FormatState = Unformatted; - PartEntry->FileSystem[0] = L'\0'; - - /* Initialize the partition volume label */ - RtlZeroMemory(PartEntry->VolumeLabel, sizeof(PartEntry->VolumeLabel)); + /* No volume initially */ + PartEntry->Volume = NULL; if (IsContainerPartition(PartEntry->PartitionType)) { - PartEntry->FormatState = Unformatted; - - if (LogicalPartition == FALSE && DiskEntry->ExtendedPartition == NULL) + if (!LogicalPartition && DiskEntry->ExtendedPartition == NULL) DiskEntry->ExtendedPartition = PartEntry; } - else if (IsRecognizedPartition(PartEntry->PartitionType)) + else if (IsRecognizedPartition(PartEntry->PartitionType) || // PartitionInfo->RecognizedPartition + IsOEMPartition(PartEntry->PartitionType)) { - ASSERT(PartitionInfo->RecognizedPartition); - ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); - - /* Try to open the volume so as to mount it */ - RtlStringCchPrintfW(PathBuffer, ARRAYSIZE(PathBuffer), - L"\\Device\\Harddisk%lu\\Partition%lu", - DiskEntry->DiskNumber, - PartEntry->PartitionNumber); - RtlInitUnicodeString(&Name, PathBuffer); - - InitializeObjectAttributes(&ObjectAttributes, - &Name, - OBJ_CASE_INSENSITIVE, - NULL, - NULL); - - PartitionHandle = NULL; - Status = NtOpenFile(&PartitionHandle, - FILE_READ_DATA | SYNCHRONIZE, - &ObjectAttributes, - &IoStatusBlock, - FILE_SHARE_READ | FILE_SHARE_WRITE, - FILE_SYNCHRONOUS_IO_NONALERT); - if (!NT_SUCCESS(Status)) - { - DPRINT1("NtOpenFile() failed, Status 0x%08lx\n", Status); - } + PVOLENTRY Volume; + NTSTATUS Status; - if (PartitionHandle) - { - ASSERT(NT_SUCCESS(Status)); + ASSERT(PartEntry->PartitionNumber != 0); - /* We don't have a FS, try to guess one */ - Status = InferFileSystem(NULL, PartitionHandle, - PartEntry->FileSystem, - sizeof(PartEntry->FileSystem)); - if (!NT_SUCCESS(Status)) - DPRINT1("InferFileSystem() failed, Status 0x%08lx\n", Status); - } - if (*PartEntry->FileSystem) - { - ASSERT(PartitionHandle); - - /* - * Handle partition mounted with RawFS: it is - * either unformatted or has an unknown format. - */ - if (wcsicmp(PartEntry->FileSystem, L"RAW") == 0) - { - /* - * True unformatted partitions on NT are created with their - * partition type set to either one of the following values, - * and are mounted with RawFS. This is done this way since we - * are assured to have FAT support, which is the only FS that - * uses these partition types. Therefore, having a partition - * mounted with RawFS and with these partition types means that - * the FAT FS was unable to mount it beforehand and thus the - * partition is unformatted. - * However, any partition mounted by RawFS that does NOT have - * any of these partition types must be considered as having - * an unknown format. - */ - if (PartEntry->PartitionType == PARTITION_FAT_12 || - PartEntry->PartitionType == PARTITION_FAT_16 || - PartEntry->PartitionType == PARTITION_HUGE || - PartEntry->PartitionType == PARTITION_XINT13 || - PartEntry->PartitionType == PARTITION_FAT32 || - PartEntry->PartitionType == PARTITION_FAT32_XINT13) - { - PartEntry->FormatState = Unformatted; - } - else - { - /* Close the partition before dismounting */ - NtClose(PartitionHandle); - PartitionHandle = NULL; - /* - * Dismount the partition since RawFS owns it, and set its - * format to unknown (may or may not be actually formatted). - */ - DismountVolume(PartEntry); - PartEntry->FormatState = UnknownFormat; - PartEntry->FileSystem[0] = L'\0'; - } - } - else - { - PartEntry->FormatState = Preformatted; - } - } - else + /* The PARTMGR should have notified the MOUNTMGR that a volume + * associated with this partition had to be created */ + Volume = InitVolume(DiskEntry->PartList, PartEntry); + if (!Volume) { - PartEntry->FormatState = UnknownFormat; + DPRINT1("Couldn't allocate a volume for device '%S'\n", + PartEntry->DeviceName); + goto SkipVolume; } + PartEntry->Volume = Volume; + InitVolumeDeviceName(Volume); + Volume->New = FALSE; - /* Retrieve the partition volume label */ - if (PartitionHandle) + /* Attach and mount the volume */ + Status = MountVolume(&Volume->Info, PartEntry->PartitionType); + if (!NT_SUCCESS(Status)) { - Status = NtQueryVolumeInformationFile(PartitionHandle, - &IoStatusBlock, - &LabelBuffer, - sizeof(LabelBuffer), - FileFsVolumeInformation); - if (NT_SUCCESS(Status)) - { - /* Copy the (possibly truncated) volume label and NULL-terminate it */ - RtlStringCbCopyNW(PartEntry->VolumeLabel, sizeof(PartEntry->VolumeLabel), - LabelInfo->VolumeLabel, LabelInfo->VolumeLabelLength); - } - else - { - DPRINT1("NtQueryVolumeInformationFile() failed, Status 0x%08lx\n", Status); - } + DPRINT1("Failed to mount volume '%S', Status 0x%08lx\n", + Volume->Info.DeviceName, Status); } - /* Close the partition */ - if (PartitionHandle) - NtClose(PartitionHandle); + // + // FIXME: TEMP Backward-compatibility: Set the FormatState + // flag in accordance with the FileSystem volume value. + // + /* + * MountVolume() determines whether the given volume is actually + * unformatted, if it was mounted with RawFS and the partition + * type has specific values for FAT volumes. If so, the volume + * stays mounted with RawFS (the FileSystem is "RAW"). However, + * if the partition type has different values, the volume is + * considered as having an unknown format (it may or may not be + * formatted) and the FileSystem value has been emptied. + */ + if (IsUnknown(&Volume->Info)) + Volume->FormatState = UnknownFormat; + else if (IsUnformatted(&Volume->Info)) // FileSystem is "RAW" + Volume->FormatState = Unformatted; + else // !IsUnknown && !IsUnformatted == IsFormatted + Volume->FormatState = Formatted; +SkipVolume:; } else { - /* Unknown partition, hence unknown format (may or may not be actually formatted) */ - PartEntry->FormatState = UnknownFormat; + /* Unknown partition (may or may not be actually formatted): + * the partition is hidden, hence no volume */ + DPRINT1("Disk %lu Partition %lu is not recognized (Type 0x%02x)\n", + DiskEntry->DiskNumber, PartEntry->PartitionNumber, + PartEntry->PartitionType); } InsertDiskRegion(DiskEntry, PartEntry, LogicalPartition); @@ -1262,7 +1263,7 @@ SetDiskSignature( /* Check if the signature already exist */ /* FIXME: * Check also signatures from disks, which are - * not visible (bootable) by the bios. + * not visible (bootable) by the BIOS. */ for (Entry2 = List->DiskListHead.Flink; Entry2 != &List->DiskListHead; @@ -1569,7 +1570,7 @@ AddDiskToList( { BiosDiskEntry = CONTAINING_RECORD(ListEntry, BIOSDISKENTRY, ListEntry); /* FIXME: - * Compare the size from bios and the reported size from driver. + * Compare the size from BIOS and the reported size from driver. * If we have more than one disk with a zero or with the same signature * we must create new signatures and reboot. After the reboot, * it is possible to identify the disks. @@ -1898,12 +1899,13 @@ GetActiveDiskPartition( /* Yes, we've found it */ ASSERT(DiskEntry == PartEntry->DiskEntry); ASSERT(PartEntry->IsPartitioned); + ASSERT(PartEntry->Volume); ActivePartition = PartEntry; DPRINT1("Found active system partition %lu in disk %lu, drive letter %C\n", PartEntry->PartitionNumber, DiskEntry->DiskNumber, - (PartEntry->DriveLetter == 0) ? L'-' : PartEntry->DriveLetter); + !PartEntry->Volume->Info.DriveLetter ? L'-' : PartEntry->Volume->Info.DriveLetter); break; } } @@ -1937,13 +1939,14 @@ CreatePartitionList(VOID) List = (PPARTLIST)RtlAllocateHeap(ProcessHeap, 0, sizeof(PARTLIST)); - if (List == NULL) + if (!List) return NULL; List->SystemPartition = NULL; InitializeListHead(&List->DiskListHead); InitializeListHead(&List->BiosDiskListHead); + InitializeListHead(&List->VolumesList); /* * Enumerate the disks seen by the BIOS; this will be used later @@ -2026,8 +2029,7 @@ DestroyPartitionList( { Entry = RemoveHeadList(&DiskEntry->PrimaryPartListHead); PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry); - - RtlFreeHeap(ProcessHeap, 0, PartEntry); + DestroyRegion(PartEntry); } /* Release logical partition list */ @@ -2035,8 +2037,7 @@ DestroyPartitionList( { Entry = RemoveHeadList(&DiskEntry->LogicalPartListHead); PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry); - - RtlFreeHeap(ProcessHeap, 0, PartEntry); + DestroyRegion(PartEntry); } /* Release layout buffer */ @@ -2047,12 +2048,11 @@ DestroyPartitionList( RtlFreeHeap(ProcessHeap, 0, DiskEntry); } - /* Release the bios disk info */ + /* Release the BIOS disk info */ while (!IsListEmpty(&List->BiosDiskListHead)) { Entry = RemoveHeadList(&List->BiosDiskListHead); BiosDiskEntry = CONTAINING_RECORD(Entry, BIOSDISKENTRY, ListEntry); - RtlFreeHeap(ProcessHeap, 0, BiosDiskEntry); } @@ -2540,7 +2540,7 @@ UpdateDiskLayout( } /* Resize the layout buffer if necessary */ - if (ReAllocateLayoutBuffer(DiskEntry) == FALSE) + if (!ReAllocateLayoutBuffer(DiskEntry)) { DPRINT("ReAllocateLayoutBuffer() failed.\n"); return; @@ -2561,7 +2561,7 @@ UpdateDiskLayout( PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index]; PartEntry->PartitionIndex = Index; - /* Reset the current partition number only for newly-created (unmounted) partitions */ + /* Reset the current partition number only for not-yet written partitions */ if (PartEntry->New) PartEntry->PartitionNumber = 0; @@ -2606,7 +2606,7 @@ UpdateDiskLayout( PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index]; PartEntry->PartitionIndex = Index; - /* Reset the current partition number only for newly-created (unmounted) partitions */ + /* Reset the current partition number only for not-yet written partitions */ if (PartEntry->New) PartEntry->PartitionNumber = 0; @@ -2849,6 +2849,7 @@ CreatePartition( { ERROR_NUMBER Error; BOOLEAN isContainer = IsContainerPartition((UCHAR)PartitionInfo); + PDISKENTRY DiskEntry; PCSTR mainType = "Primary"; if (isContainer) @@ -2878,39 +2879,42 @@ CreatePartition( if (!InitializePartitionEntry(PartEntry, SizeBytes, PartitionInfo)) return FALSE; - if (isContainer) + DiskEntry = PartEntry->DiskEntry; + UpdateDiskLayout(DiskEntry); + + ASSERT(!PartEntry->Volume); + if (!isContainer) { - // FIXME? Possibly to make GetNextUnformattedPartition work (i.e. skip the extended partition container) - PartEntry->New = FALSE; - PartEntry->FormatState = Formatted; + /* We create a primary/logical partition: initialize a new basic + * volume entry. When the partition will actually be written onto + * the disk, the PARTMGR will notify the MOUNTMGR that a volume + * associated with this partition has to be created. */ + PartEntry->Volume = InitVolume(DiskEntry->PartList, PartEntry); + ASSERT(PartEntry->Volume); } - UpdateDiskLayout(PartEntry->DiskEntry); AssignDriveLetters(List); return TRUE; } -NTSTATUS -DismountVolume( - IN PPARTENTRY PartEntry) +static NTSTATUS +DismountPartition( + _In_ PPARTLIST List, + _In_ PPARTENTRY PartEntry) { NTSTATUS Status; - NTSTATUS LockStatus; - UNICODE_STRING Name; - OBJECT_ATTRIBUTES ObjectAttributes; - IO_STATUS_BLOCK IoStatusBlock; - HANDLE PartitionHandle; - WCHAR Buffer[MAX_PATH]; + PVOLENTRY Volume = PartEntry->Volume; + + ASSERT(PartEntry->DiskEntry->PartList == List); /* Check whether the partition is valid and was mounted by the system */ if (!PartEntry->IsPartitioned || IsContainerPartition(PartEntry->PartitionType) || !IsRecognizedPartition(PartEntry->PartitionType) || - PartEntry->FormatState == UnknownFormat || + !Volume || Volume->FormatState == UnknownFormat || // NOTE: If FormatState == Unformatted but *FileSystem != 0 this means // it has been usually mounted with RawFS and thus needs to be dismounted. - !*PartEntry->FileSystem || PartEntry->PartitionNumber == 0) { /* The partition is not mounted, so just return success */ @@ -2918,83 +2922,14 @@ DismountVolume( } ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); - - /* Open the volume */ - RtlStringCchPrintfW(Buffer, ARRAYSIZE(Buffer), - L"\\Device\\Harddisk%lu\\Partition%lu", - PartEntry->DiskEntry->DiskNumber, - PartEntry->PartitionNumber); - RtlInitUnicodeString(&Name, Buffer); - - InitializeObjectAttributes(&ObjectAttributes, - &Name, - OBJ_CASE_INSENSITIVE, - NULL, - NULL); - - Status = NtOpenFile(&PartitionHandle, - GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, - &ObjectAttributes, - &IoStatusBlock, - FILE_SHARE_READ | FILE_SHARE_WRITE, - FILE_SYNCHRONOUS_IO_NONALERT); - if (!NT_SUCCESS(Status)) - { - DPRINT1("ERROR: Cannot open volume %wZ for dismounting! (Status 0x%lx)\n", &Name, Status); - return Status; - } - - /* Lock the volume */ - LockStatus = NtFsControlFile(PartitionHandle, - NULL, - NULL, - NULL, - &IoStatusBlock, - FSCTL_LOCK_VOLUME, - NULL, - 0, - NULL, - 0); - if (!NT_SUCCESS(LockStatus)) - { - DPRINT1("WARNING: Failed to lock volume! Operations may fail! (Status 0x%lx)\n", LockStatus); - } - - /* Dismount the volume */ - Status = NtFsControlFile(PartitionHandle, - NULL, - NULL, - NULL, - &IoStatusBlock, - FSCTL_DISMOUNT_VOLUME, - NULL, - 0, - NULL, - 0); - if (!NT_SUCCESS(Status)) - { - DPRINT1("Failed to unmount volume (Status 0x%lx)\n", Status); - } - - /* Unlock the volume */ - LockStatus = NtFsControlFile(PartitionHandle, - NULL, - NULL, - NULL, - &IoStatusBlock, - FSCTL_UNLOCK_VOLUME, - NULL, - 0, - NULL, - 0); - if (!NT_SUCCESS(LockStatus)) - { - DPRINT1("Failed to unlock volume (Status 0x%lx)\n", LockStatus); - } - - /* Close the volume */ - NtClose(PartitionHandle); - + ASSERT(Volume->PartEntry == PartEntry); + + /* Unlink the basic volume from the volumes list and dismount it */ + PartEntry->Volume = NULL; + Volume->PartEntry = NULL; + RemoveEntryList(&Volume->ListEntry); + Status = DismountVolume(&Volume->Info, TRUE); + RtlFreeHeap(ProcessHeap, 0, Volume); return Status; } @@ -3016,6 +2951,7 @@ DeletePartition( return FALSE; } + ASSERT(PartEntry->DiskEntry->PartList == List); ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); /* Clear the system partition if it is being deleted */ @@ -3036,19 +2972,17 @@ DeletePartition( Entry = RemoveHeadList(&DiskEntry->LogicalPartListHead); LogicalPartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry); - /* Dismount the logical partition */ - DismountVolume(LogicalPartEntry); - - /* Delete it */ - RtlFreeHeap(ProcessHeap, 0, LogicalPartEntry); + /* Dismount the logical partition and delete it */ + DismountPartition(List, LogicalPartEntry); + DestroyRegion(LogicalPartEntry); } DiskEntry->ExtendedPartition = NULL; } else { - /* A primary partition is being deleted: dismount it */ - DismountVolume(PartEntry); + /* A primary/logical partition is being deleted: dismount it */ + DismountPartition(List, PartEntry); } /* Adjust the unpartitioned disk space entries */ @@ -3066,9 +3000,9 @@ DeletePartition( /* Remove the current and next entries */ RemoveEntryList(&PartEntry->ListEntry); - RtlFreeHeap(ProcessHeap, 0, PartEntry); + DestroyRegion(PartEntry); RemoveEntryList(&NextPartEntry->ListEntry); - RtlFreeHeap(ProcessHeap, 0, NextPartEntry); + DestroyRegion(NextPartEntry); /* Optionally return the freed region */ if (FreeRegion) @@ -3083,7 +3017,7 @@ DeletePartition( /* Remove the current entry */ RemoveEntryList(&PartEntry->ListEntry); - RtlFreeHeap(ProcessHeap, 0, PartEntry); + DestroyRegion(PartEntry); /* Optionally return the freed region */ if (FreeRegion) @@ -3099,7 +3033,7 @@ DeletePartition( /* Remove the current entry */ RemoveEntryList(&PartEntry->ListEntry); - RtlFreeHeap(ProcessHeap, 0, PartEntry); + DestroyRegion(PartEntry); /* Optionally return the freed region */ if (FreeRegion) @@ -3108,16 +3042,21 @@ DeletePartition( else { /* Nothing to merge but change the current entry */ + PartEntry->New = FALSE; PartEntry->IsPartitioned = FALSE; + PartEntry->PartitionType = PARTITION_ENTRY_UNUSED; PartEntry->OnDiskPartitionNumber = 0; PartEntry->PartitionNumber = 0; // PartEntry->PartitionIndex = 0; PartEntry->BootIndicator = FALSE; - PartEntry->PartitionType = PARTITION_ENTRY_UNUSED; - PartEntry->FormatState = Unformatted; - PartEntry->FileSystem[0] = L'\0'; - PartEntry->DriveLetter = 0; - RtlZeroMemory(PartEntry->VolumeLabel, sizeof(PartEntry->VolumeLabel)); + PartEntry->DeviceName[0] = UNICODE_NULL; + + if (PartEntry->Volume) + { + RemoveEntryList(&PartEntry->Volume->ListEntry); + RtlFreeHeap(ProcessHeap, 0, PartEntry->Volume); + } + PartEntry->Volume = NULL; /* Optionally return the freed region */ if (FreeRegion) @@ -3135,6 +3074,8 @@ BOOLEAN IsSupportedActivePartition( IN PPARTENTRY PartEntry) { + PVOLENTRY Volume; + /* Check the type and the file system of this partition */ /* @@ -3148,6 +3089,13 @@ IsSupportedActivePartition( return FALSE; } + Volume = PartEntry->Volume; + if (!Volume) + { + /* Still no recognizable volume mounted: partition not supported */ + return FALSE; + } + /* * ADDITIONAL CHECKS / BIG HACK: * @@ -3164,21 +3112,20 @@ IsSupportedActivePartition( * NOTE also that for those architectures looking for a * partition boot indicator is insufficient. */ - if (PartEntry->FormatState == Unformatted) + if (Volume->FormatState == Unformatted) { /* If this partition is mounted, it would use RawFS ("RAW") */ return TRUE; } - else if ((PartEntry->FormatState == Preformatted) || - (PartEntry->FormatState == Formatted)) + else if (Volume->FormatState == Formatted) { - ASSERT(*PartEntry->FileSystem); + ASSERT(*Volume->Info.FileSystem); /* NOTE: Please keep in sync with the RegisteredFileSystems list! */ - if (wcsicmp(PartEntry->FileSystem, L"FAT") == 0 || - wcsicmp(PartEntry->FileSystem, L"FAT32") == 0 || - // wcsicmp(PartEntry->FileSystem, L"NTFS") == 0 || - wcsicmp(PartEntry->FileSystem, L"BTRFS") == 0) + if (wcsicmp(Volume->Info.FileSystem, L"FAT") == 0 || + wcsicmp(Volume->Info.FileSystem, L"FAT32") == 0 || + // wcsicmp(Volume->Info.FileSystem, L"NTFS") == 0 || + wcsicmp(Volume->Info.FileSystem, L"BTRFS") == 0) { return TRUE; } @@ -3186,13 +3133,13 @@ IsSupportedActivePartition( { // WARNING: We cannot write on this FS yet! DPRINT1("Recognized file system '%S' that doesn't have write support yet!\n", - PartEntry->FileSystem); + Volume->Info.FileSystem); return FALSE; } } - else // if (PartEntry->FormatState == UnknownFormat) + else // if (Volume->FormatState == UnknownFormat) { - ASSERT(!*PartEntry->FileSystem); + ASSERT(!*Volume->Info.FileSystem); DPRINT1("System partition %lu in disk %lu with no or unknown FS?!\n", PartEntry->PartitionNumber, PartEntry->DiskEntry->DiskNumber); @@ -3204,7 +3151,7 @@ IsSupportedActivePartition( if (PartEntry->PartitionType == PARTITION_IFS) { DPRINT1("Recognized file system '%S' that doesn't have write support yet!\n", - PartEntry->FileSystem); + Volume->Info.FileSystem); return FALSE; } @@ -3278,7 +3225,7 @@ FindSupportedSystemPartition( DPRINT1("Use the current system partition %lu in disk %lu, drive letter %C\n", CandidatePartition->PartitionNumber, CandidatePartition->DiskEntry->DiskNumber, - (CandidatePartition->DriveLetter == 0) ? L'-' : CandidatePartition->DriveLetter); + !CandidatePartition->Volume->Info.DriveLetter ? L'-' : CandidatePartition->Volume->Info.DriveLetter); /* Return the candidate system partition */ return CandidatePartition; @@ -3427,7 +3374,7 @@ UseAlternativeDisk: DPRINT1("Use new first active system partition %lu in disk %lu, drive letter %C\n", CandidatePartition->PartitionNumber, CandidatePartition->DiskEntry->DiskNumber, - (CandidatePartition->DriveLetter == 0) ? L'-' : CandidatePartition->DriveLetter); + !CandidatePartition->Volume->Info.DriveLetter ? L'-' : CandidatePartition->Volume->Info.DriveLetter); /* Return the candidate system partition */ return CandidatePartition; @@ -3467,7 +3414,7 @@ UseAlternativeDisk: DPRINT1("Use first active system partition %lu in disk %lu, drive letter %C\n", CandidatePartition->PartitionNumber, CandidatePartition->DiskEntry->DiskNumber, - (CandidatePartition->DriveLetter == 0) ? L'-' : CandidatePartition->DriveLetter); + !CandidatePartition->Volume->Info.DriveLetter ? L'-' : CandidatePartition->Volume->Info.DriveLetter); /* Return the candidate system partition */ return CandidatePartition; @@ -3505,7 +3452,7 @@ UseAlternativePartition: DPRINT1("Use alternative active system partition %lu in disk %lu, drive letter %C\n", CandidatePartition->PartitionNumber, CandidatePartition->DiskEntry->DiskNumber, - (CandidatePartition->DriveLetter == 0) ? L'-' : CandidatePartition->DriveLetter); + !CandidatePartition->Volume->Info.DriveLetter ? L'-' : CandidatePartition->Volume->Info.DriveLetter); /* Return the candidate system partition */ return CandidatePartition; @@ -3543,7 +3490,7 @@ SetActivePartition( /* * If the user provided an old active partition hint, verify that it is - * indeeed active and belongs to the same disk where the new partition + * indeed active and belongs to the same disk where the new partition * belongs. Otherwise determine the current active partition on the disk * where the new partition belongs. */ @@ -3633,7 +3580,9 @@ WritePartitions( /* Save the original partition count to be restored later (see comment below) */ PartitionCount = DiskEntry->LayoutBuffer->PartitionCount; - /* Set the new disk layout and retrieve its updated version with possibly modified partition numbers */ + /* Set the new disk layout and retrieve its updated version with + * new partition numbers for the new partitions. The PARTMGR will + * automatically notify the MOUNTMGR of new or deleted volumes. */ BufferSize = sizeof(DRIVE_LAYOUT_INFORMATION) + ((PartitionCount - 1) * sizeof(PARTITION_INFORMATION)); Status = NtDeviceIoControlFile(FileHandle, @@ -3668,7 +3617,7 @@ WritePartitions( DumpPartitionTable(DiskEntry); #endif - /* Update the partition numbers */ + /* Update the partition numbers and device names */ /* Update the primary partition table */ for (ListEntry = DiskEntry->PrimaryPartListHead.Flink; @@ -3676,13 +3625,25 @@ WritePartitions( ListEntry = ListEntry->Flink) { PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry); + if (!PartEntry->IsPartitioned) + continue; + ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); - if (PartEntry->IsPartitioned) + /* + * Initialize the partition's number and its device name only + * if the partition was new. Note that the partition number + * should not change if this partition has not been deleted + * during repartitioning. + */ + // FIXME: Our PartMgr currently returns modified numbers + // in the layout, this needs to be investigated and fixed. + if (PartEntry->New) { - ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex]; PartEntry->PartitionNumber = PartitionInfo->PartitionNumber; + InitPartitionDeviceName(PartEntry); } + PartEntry->New = FALSE; } /* Update the logical partition table */ @@ -3691,13 +3652,18 @@ WritePartitions( ListEntry = ListEntry->Flink) { PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry); + if (!PartEntry->IsPartitioned) + continue; + ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); - if (PartEntry->IsPartitioned) + /* See comment above */ + if (PartEntry->New) { - ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex]; PartEntry->PartitionNumber = PartitionInfo->PartitionNumber; + InitPartitionDeviceName(PartEntry); } + PartEntry->New = FALSE; } // @@ -3726,10 +3692,12 @@ WritePartitionsToDisk( NTSTATUS Status; PLIST_ENTRY Entry; PDISKENTRY DiskEntry; + PVOLENTRY Volume; - if (List == NULL) + if (!List) return TRUE; + /* Write all the partitions to all the disks */ for (Entry = List->DiskListHead.Flink; Entry != &List->DiskListHead; Entry = Entry->Flink) @@ -3753,26 +3721,48 @@ WritePartitionsToDisk( } } + /* The PARTMGR should have notified the MOUNTMGR that new volumes + * associated with the new partitions had to be created */ + + /* Assign valid device names to new volumes */ + for (Entry = List->VolumesList.Flink; + Entry != &List->VolumesList; + Entry = Entry->Flink) + { + Volume = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry); + InitVolumeDeviceName(Volume); + } + return TRUE; } -BOOLEAN + +/** + * @brief + * Assign a "\DosDevices\#:" mount point drive letter to a disk partition or + * volume, specified by a given disk signature and starting partition offset. + **/ +static BOOLEAN SetMountedDeviceValue( - IN WCHAR Letter, - IN ULONG Signature, - IN LARGE_INTEGER StartingOffset) + _In_ PVOLENTRY Volume) { + PPARTENTRY PartEntry = Volume->PartEntry; + WCHAR Letter = Volume->Info.DriveLetter; NTSTATUS Status; OBJECT_ATTRIBUTES ObjectAttributes; UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"SYSTEM\\MountedDevices"); UNICODE_STRING ValueName; - WCHAR ValueNameBuffer[16]; + WCHAR Buffer[16]; HANDLE KeyHandle; REG_DISK_MOUNT_INFO MountInfo; - RtlStringCchPrintfW(ValueNameBuffer, ARRAYSIZE(ValueNameBuffer), + /* Ignore no letter */ + if (!Letter) + return TRUE; + + RtlStringCchPrintfW(Buffer, _countof(Buffer), L"\\DosDevices\\%c:", Letter); - RtlInitUnicodeString(&ValueName, ValueNameBuffer); + RtlInitUnicodeString(&ValueName, Buffer); InitializeObjectAttributes(&ObjectAttributes, &KeyName, @@ -3799,8 +3789,8 @@ SetMountedDeviceValue( return FALSE; } - MountInfo.Signature = Signature; - MountInfo.StartingOffset = StartingOffset; + MountInfo.Signature = PartEntry->DiskEntry->LayoutBuffer->Signature; + MountInfo.StartingOffset = GetPartEntryOffsetInBytes(PartEntry); Status = NtSetValueKey(KeyHandle, &ValueName, 0, @@ -3819,75 +3809,23 @@ SetMountedDeviceValue( BOOLEAN SetMountedDeviceValues( - IN PPARTLIST List) + _In_ PPARTLIST List) { - PLIST_ENTRY Entry1, Entry2; - PDISKENTRY DiskEntry; - PPARTENTRY PartEntry; - LARGE_INTEGER StartingOffset; + PLIST_ENTRY Entry; + PVOLENTRY Volume; - if (List == NULL) + if (!List) return FALSE; - for (Entry1 = List->DiskListHead.Flink; - Entry1 != &List->DiskListHead; - Entry1 = Entry1->Flink) + for (Entry = List->VolumesList.Flink; + Entry != &List->VolumesList; + Entry = Entry->Flink) { - DiskEntry = CONTAINING_RECORD(Entry1, - DISKENTRY, - ListEntry); - - if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT) - { - DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n"); - continue; - } - - for (Entry2 = DiskEntry->PrimaryPartListHead.Flink; - Entry2 != &DiskEntry->PrimaryPartListHead; - Entry2 = Entry2->Flink) - { - PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - if (PartEntry->IsPartitioned) // && !IsContainerPartition(PartEntry->PartitionType) - { - ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); - - /* Assign a "\DosDevices\#:" mount point to this partition */ - if (PartEntry->DriveLetter) - { - StartingOffset.QuadPart = GetPartEntryOffsetInBytes(PartEntry); - if (!SetMountedDeviceValue(PartEntry->DriveLetter, - DiskEntry->LayoutBuffer->Signature, - StartingOffset)) - { - return FALSE; - } - } - } - } - - for (Entry2 = DiskEntry->LogicalPartListHead.Flink; - Entry2 != &DiskEntry->LogicalPartListHead; - Entry2 = Entry2->Flink) - { - PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry); - if (PartEntry->IsPartitioned) // && !IsContainerPartition(PartEntry->PartitionType) - { - ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED); + Volume = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry); - /* Assign a "\DosDevices\#:" mount point to this partition */ - if (PartEntry->DriveLetter) - { - StartingOffset.QuadPart = GetPartEntryOffsetInBytes(PartEntry); - if (!SetMountedDeviceValue(PartEntry->DriveLetter, - DiskEntry->LayoutBuffer->Signature, - StartingOffset)) - { - return FALSE; - } - } - } - } + /* Assign a "\DosDevices\#:" mount point to this volume */ + if (!SetMountedDeviceValue(Volume)) + return FALSE; } return TRUE; @@ -3902,6 +3840,12 @@ SetMBRPartitionType( ASSERT(DiskEntry->DiskStyle == PARTITION_STYLE_MBR); + /* Nothing to do if we assign the same type */ + if (PartitionType == PartEntry->PartitionType) + return; + + // TODO: We might need to remount the associated basic volume... + PartEntry->PartitionType = PartitionType; DiskEntry->Dirty = TRUE; diff --git a/base/setup/lib/utils/partlist.h b/base/setup/lib/utils/partlist.h index 9654baf3839..967c8385b4d 100644 --- a/base/setup/lib/utils/partlist.h +++ b/base/setup/lib/utils/partlist.h @@ -1,9 +1,9 @@ /* * PROJECT: ReactOS Setup Library - * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) * PURPOSE: Partition list functions * COPYRIGHT: Copyright 2003-2019 Casper S. Hornstrup (chorns(a)users.sourceforge.net) - * Copyright 2018-2019 Hermes Belusca-Maito + * Copyright 2018-2024 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> */ #pragma once @@ -34,10 +34,30 @@ typedef enum _FORMATSTATE Unformatted, UnformattedOrDamaged, UnknownFormat, - Preformatted, Formatted } FORMATSTATE, *PFORMATSTATE; +#include "volutil.h" + +typedef struct _PARTENTRY PARTENTRY, *PPARTENTRY; +typedef struct _VOLENTRY +{ + LIST_ENTRY ListEntry; ///< Entry in VolumesList + + VOLINFO Info; + FORMATSTATE FormatState; + + /* Volume must be checked */ + BOOLEAN NeedsCheck; + /* Volume is new and has not yet been actually formatted and mounted */ + BOOLEAN New; + + // union { + // PVOLUME_DISK_EXTENTS pExtents; + PPARTENTRY PartEntry; + // }; +} VOLENTRY, *PVOLENTRY; + typedef struct _PARTENTRY { LIST_ENTRY ListEntry; @@ -54,24 +74,25 @@ typedef struct _PARTENTRY ULONG OnDiskPartitionNumber; /* Enumerated partition number (primary partitions first, excluding the extended partition container, then the logical partitions) */ ULONG PartitionNumber; /* Current partition number, only valid for the currently running NTOS instance */ ULONG PartitionIndex; /* Index in the LayoutBuffer->PartitionEntry[] cached array of the corresponding DiskEntry */ - - WCHAR DriveLetter; - WCHAR VolumeLabel[20]; - WCHAR FileSystem[MAX_PATH+1]; - FORMATSTATE FormatState; + WCHAR DeviceName[MAX_PATH]; ///< NT device name: "\Device\HarddiskM\PartitionN" BOOLEAN LogicalPartition; /* Partition is partitioned disk space */ BOOLEAN IsPartitioned; -/** The following three properties may be replaced by flags **/ - /* Partition is new, table does not exist on disk yet */ BOOLEAN New; - /* Partition must be checked */ - BOOLEAN NeedsCheck; + /* + * Volume-related properties: + * NULL: No volume is associated to this partition (either because it is + * an empty disk region, or the partition type is unrecognized). + * 0x1 : TBD. + * Valid pointer: A basic volume associated to this partition is (or will) + * be mounted by the PARTMGR and enumerated by the MOUNTMGR. + */ + PVOLENTRY Volume; } PARTENTRY, *PPARTENTRY; @@ -162,9 +183,12 @@ typedef struct _PARTLIST LIST_ENTRY DiskListHead; LIST_ENTRY BiosDiskListHead; + /* (Basic) Volumes management */ + LIST_ENTRY VolumesList; + } PARTLIST, *PPARTLIST; -#define PARTITION_TBL_SIZE 4 +#define PARTITION_TBL_SIZE 4 #define PARTITION_MAGIC 0xAA55 @@ -307,10 +331,6 @@ CreatePartition( _In_opt_ ULONGLONG SizeBytes, _In_opt_ ULONG_PTR PartitionInfo); -NTSTATUS -DismountVolume( - IN PPARTENTRY PartEntry); - BOOLEAN DeletePartition( _In_ PPARTLIST List, @@ -338,15 +358,9 @@ BOOLEAN WritePartitionsToDisk( IN PPARTLIST List); -BOOLEAN -SetMountedDeviceValue( - IN WCHAR Letter, - IN ULONG Signature, - IN LARGE_INTEGER StartingOffset); - BOOLEAN SetMountedDeviceValues( - IN PPARTLIST List); + _In_ PPARTLIST List); VOID SetMBRPartitionType( diff --git a/base/setup/lib/utils/volutil.c b/base/setup/lib/utils/volutil.c new file mode 100644 index 00000000000..153488542a0 --- /dev/null +++ b/base/setup/lib/utils/volutil.c @@ -0,0 +1,226 @@ +/* + * PROJECT: ReactOS Setup Library + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Volume utility functions + * COPYRIGHT: Copyright 2024 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> + */ + +/* INCLUDES ******************************************************************/ + +#include "precomp.h" + +#include "volutil.h" +#include "fsrec.h" +#include "devutils.h" + +#define NDEBUG +#include <debug.h> + + +/* FUNCTIONS *****************************************************************/ + +NTSTATUS +MountVolume( + _Inout_ PVOLINFO Volume, + _In_opt_ UCHAR MbrPartitionType) +{ + NTSTATUS Status; + HANDLE VolumeHandle; + + /* If the volume is already mounted, just return success */ + if (*Volume->FileSystem) + return STATUS_SUCCESS; + + /* Try to open the volume so as to mount it */ + VolumeHandle = NULL; + Status = pOpenDevice(Volume->DeviceName, &VolumeHandle); + if (!NT_SUCCESS(Status)) + { + DPRINT1("pOpenDevice() failed, Status 0x%08lx\n", Status); + + /* We failed, reset some data and bail out */ + Volume->DriveLetter = UNICODE_NULL; + Volume->VolumeLabel[0] = UNICODE_NULL; + Volume->FileSystem[0] = UNICODE_NULL; + + return Status; + } + ASSERT(VolumeHandle); + + /* We don't have a FS, try to guess one */ + Status = InferFileSystem(NULL, VolumeHandle, + Volume->FileSystem, + sizeof(Volume->FileSystem)); + if (!NT_SUCCESS(Status)) + DPRINT1("InferFileSystem() failed, Status 0x%08lx\n", Status); + + if (*Volume->FileSystem) + { + /* + * Handle volume mounted with RawFS: it is + * either unformatted or has an unknown format. + */ + if (IsUnformatted(Volume)) // FileSystem is "RAW" + { + /* + * True unformatted partitions on NT are created with their + * partition type set to either one of the following values, + * and are mounted with RawFS. This is done this way since we + * are assured to have FAT support, which is the only FS that + * uses these partition types. Therefore, having a partition + * mounted with RawFS and with these partition types means that + * the FAT FS was unable to mount it beforehand and thus the + * partition is unformatted. + * However, any partition mounted by RawFS that does NOT have + * any of these partition types must be considered as having + * an unknown format. + */ + if (MbrPartitionType == PARTITION_FAT_12 || + MbrPartitionType == PARTITION_FAT_16 || + MbrPartitionType == PARTITION_HUGE || + MbrPartitionType == PARTITION_XINT13 || + MbrPartitionType == PARTITION_FAT32 || + MbrPartitionType == PARTITION_FAT32_XINT13) + { + /* The volume is unformatted */ + } + else + { + /* Close the volume before dismounting */ + NtClose(VolumeHandle); + VolumeHandle = NULL; + /* + * Dismount the volume since RawFS owns it, and reset its + * format (it is unknown, may or may not be actually formatted). + */ + DismountVolume(Volume, TRUE); + Volume->FileSystem[0] = UNICODE_NULL; + } + } + /* Else, the volume is formatted */ + } + /* Else, the volume has an unknown format */ + + /* Retrieve the volume label */ + if (VolumeHandle) + { + IO_STATUS_BLOCK IoStatusBlock; + struct + { + FILE_FS_VOLUME_INFORMATION; + WCHAR Data[255]; + } LabelInfo; + + Status = NtQueryVolumeInformationFile(VolumeHandle, + &IoStatusBlock, + &LabelInfo, + sizeof(LabelInfo), + FileFsVolumeInformation); + if (NT_SUCCESS(Status)) + { + /* Copy the (possibly truncated) volume label and NULL-terminate it */ + RtlStringCbCopyNW(Volume->VolumeLabel, sizeof(Volume->VolumeLabel), + LabelInfo.VolumeLabel, LabelInfo.VolumeLabelLength); + } + else + { + DPRINT1("NtQueryVolumeInformationFile() failed, Status 0x%08lx\n", Status); + } + } + + /* Close the volume */ + if (VolumeHandle) + NtClose(VolumeHandle); + + return STATUS_SUCCESS; +} + +/** + * @brief + * Attempts to dismount the designated volume. + * + * @param[in,out] Volume + * The volume to dismount. + * + * @param[in] Force + * Whether the volume is forcibly dismounted, even + * if there are open handles to files on this volume. + * + * @return An NTSTATUS code indicating success or failure. + **/ +NTSTATUS +DismountVolume( + _Inout_ PVOLINFO Volume, + _In_ BOOLEAN Force) +{ + NTSTATUS Status, LockStatus; + IO_STATUS_BLOCK IoStatusBlock; + HANDLE VolumeHandle; + + /* If the volume is not mounted, just return success */ + if (!*Volume->FileSystem) + return STATUS_SUCCESS; + + /* Open the volume */ + Status = pOpenDeviceEx(Volume->DeviceName, &VolumeHandle, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE); + if (!NT_SUCCESS(Status)) + { + DPRINT1("ERROR: Cannot open volume %S for dismounting! (Status 0x%lx)\n", + Volume->DeviceName, Status); + return Status; + } + + /* Lock the volume (succeeds only if there are no open handles to files) */ + LockStatus = NtFsControlFile(VolumeHandle, + NULL, NULL, NULL, + &IoStatusBlock, + FSCTL_LOCK_VOLUME, + NULL, 0, + NULL, 0); + if (!NT_SUCCESS(LockStatus)) + DPRINT1("WARNING: Failed to lock volume (Status 0x%lx)\n", LockStatus); + + /* Dismount the volume (succeeds even when lock fails and there are open handles) */ + Status = STATUS_ACCESS_DENIED; // Suppose dismount failure. + if (NT_SUCCESS(LockStatus) || Force) + { + Status = NtFsControlFile(VolumeHandle, + NULL, NULL, NULL, + &IoStatusBlock, + FSCTL_DISMOUNT_VOLUME, + NULL, 0, + NULL, 0); + if (!NT_SUCCESS(Status)) + DPRINT1("Failed to unmount volume (Status 0x%lx)\n", Status); + } + + /* Unlock the volume */ + if (NT_SUCCESS(LockStatus)) + { + LockStatus = NtFsControlFile(VolumeHandle, + NULL, NULL, NULL, + &IoStatusBlock, + FSCTL_UNLOCK_VOLUME, + NULL, 0, + NULL, 0); + if (!NT_SUCCESS(LockStatus)) + DPRINT1("Failed to unlock volume (Status 0x%lx)\n", LockStatus); + } + + /* Close the volume */ + NtClose(VolumeHandle); + + /* Reset some data only if dismount succeeded */ + if (NT_SUCCESS(Status)) + { + Volume->DriveLetter = UNICODE_NULL; + Volume->VolumeLabel[0] = UNICODE_NULL; + Volume->FileSystem[0] = UNICODE_NULL; + } + + return Status; +} + +/* EOF */ diff --git a/base/setup/lib/utils/volutil.h b/base/setup/lib/utils/volutil.h new file mode 100644 index 00000000000..2763bb89844 --- /dev/null +++ b/base/setup/lib/utils/volutil.h @@ -0,0 +1,48 @@ +/* + * PROJECT: ReactOS Setup Library + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Volume utility functions + * COPYRIGHT: Copyright 2024 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> + */ + +#pragma once + +typedef struct _VOLINFO +{ + // WCHAR VolumeName[MAX_PATH]; ///< Name in the DOS/Win32 namespace: "\??\Volume{GUID}\" + WCHAR DeviceName[MAX_PATH]; ///< NT device name: "\Device\HarddiskVolumeN" + + WCHAR DriveLetter; + WCHAR VolumeLabel[20]; + WCHAR FileSystem[MAX_PATH+1]; + + // VOLUME_TYPE VolumeType; + // ULARGE_INTEGER Size; + // PVOLUME_DISK_EXTENTS Extents; +} VOLINFO, *PVOLINFO; + +/* RawFS "RAW" file system name */ +#define IS_RAWFS(fs) \ + ((fs)[0] == 'R' && (fs)[1] == 'A' && (fs)[2] == 'W' && (fs)[3] == 0) + +#define IsUnknown(VolInfo) \ + (!*(VolInfo)->FileSystem) + +#define IsUnformatted(VolInfo) \ + IS_RAWFS((VolInfo)->FileSystem) + +#define IsFormatted(VolInfo) \ + (!IsUnknown(VolInfo) && !IsUnformatted(VolInfo)) + + +NTSTATUS +MountVolume( + _Inout_ PVOLINFO Volume, + _In_opt_ UCHAR MbrPartitionType); + +NTSTATUS +DismountVolume( + _Inout_ PVOLINFO Volume, + _In_ BOOLEAN Force); + +/* EOF */ diff --git a/base/setup/reactos/drivepage.c b/base/setup/reactos/drivepage.c index 320e0c62fa3..6c9bcc2a963 100644 --- a/base/setup/reactos/drivepage.c +++ b/base/setup/reactos/drivepage.c @@ -571,6 +571,7 @@ PrintPartitionData( IN PDISKENTRY DiskEntry, IN PPARTENTRY PartEntry) { + PVOLINFO VolInfo = (PartEntry->Volume ? &PartEntry->Volume->Info : NULL); LARGE_INTEGER PartSize; HTLITEM htiPart; CHAR PartTypeString[32]; @@ -589,9 +590,9 @@ PrintPartitionData( StringCchPrintfW(LineBuffer, ARRAYSIZE(LineBuffer), // MUIGetString(STRING_HDDINFOUNK5), L"%s (%c%c)", - *PartEntry->VolumeLabel ? PartEntry->VolumeLabel : L"Partition", - (PartEntry->DriveLetter == 0) ? L'-' : PartEntry->DriveLetter, - (PartEntry->DriveLetter == 0) ? L'-' : L':'); + (VolInfo && *VolInfo->VolumeLabel) ? VolInfo->VolumeLabel : L"Partition", + !(VolInfo && VolInfo->DriveLetter) ? L'-' : VolInfo->DriveLetter, + !(VolInfo && VolInfo->DriveLetter) ? L'-' : L':'); } htiPart = TreeListAddItem(hWndList, htiParent, LineBuffer, @@ -1001,8 +1002,8 @@ DriveDlgProc( if (PartEntry->IsPartitioned && !IsContainerPartition(PartEntry->PartitionType) /* alternatively: PartEntry->PartitionNumber != 0 */ && - // !PartEntry->New && - (PartEntry->FormatState == Preformatted /* || PartEntry->FormatState == Formatted */)) + PartEntry->Volume && // !PartEntry->Volume->New && + (PartEntry->Volume->FormatState == Formatted)) { PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_BACK | PSWIZB_NEXT); } @@ -1079,11 +1080,12 @@ DisableWizNext: DiskEntry.HwFixedDiskNumber = 0; PartEntry.DiskEntry = &DiskEntry; PartEntry.PartitionNumber = 1; // 4; + PartEntry.Volume = NULL; /****/ Status = InitDestinationPaths(&pSetupData->USetupData, NULL, // pSetupData->USetupData.InstallationDirectory, - &PartEntry); + PartEntry.Volume); if (!NT_SUCCESS(Status)) { diff --git a/base/setup/reactos/reactos.c b/base/setup/reactos/reactos.c index 67034f93ea5..ee4f3cc8a2b 100644 --- a/base/setup/reactos/reactos.c +++ b/base/setup/reactos/reactos.c @@ -596,14 +596,14 @@ AddNTOSInstallationItem( IN SIZE_T cchBufferSize) { PNTOS_INSTALLATION NtOsInstall = (PNTOS_INSTALLATION)GetListEntryData(Entry); - PPARTENTRY PartEntry = NtOsInstall->PartEntry; + PVOLINFO VolInfo = (NtOsInstall->Volume ? &NtOsInstall->Volume->Info : NULL); - if (PartEntry && PartEntry->DriveLetter) + if (VolInfo && VolInfo->DriveLetter) { /* We have retrieved a partition that is mounted */ StringCchPrintfW(Buffer, cchBufferSize, L"%c:%s", - PartEntry->DriveLetter, + VolInfo->DriveLetter, NtOsInstall->PathComponent); } else diff --git a/base/setup/usetup/partlist.c b/base/setup/usetup/partlist.c index 570008638b2..a7eb50a8b59 100644 --- a/base/setup/usetup/partlist.c +++ b/base/setup/usetup/partlist.c @@ -154,6 +154,7 @@ PartitionDescription( size_t cchBufferSize = cchBuffer; ULONGLONG PartSize; PCSTR Unit; + PVOLINFO VolInfo = (PartEntry->Volume ? &PartEntry->Volume->Info : NULL); /* Get the partition size */ PartSize = GetPartEntrySizeInBytes(PartEntry); @@ -204,8 +205,8 @@ PartitionDescription( RtlStringCchPrintfExA(pBuffer, cchBufferSize, &pBuffer, &cchBufferSize, 0, "%c%c %c %s(%lu) ", - (PartEntry->DriveLetter == 0) ? '-' : (CHAR)PartEntry->DriveLetter, - (PartEntry->DriveLetter == 0) ? '-' : ':', + !(VolInfo && VolInfo->DriveLetter) ? '-' : (CHAR)VolInfo->DriveLetter, + !(VolInfo && VolInfo->DriveLetter) ? '-' : ':', PartEntry->BootIndicator ? '*' : ' ', PartEntry->LogicalPartition ? " " : "", // Optional indentation PartEntry->PartitionNumber); @@ -215,16 +216,15 @@ PartitionDescription( * (if any) and the file system name. Otherwise, display the partition * type if it's not a new partition. */ - if (!PartEntry->New && *PartEntry->FileSystem && - _wcsicmp(PartEntry->FileSystem, L"RAW") != 0) + if (VolInfo && IsFormatted(VolInfo)) { size_t cchLabelSize = 0; - if (*PartEntry->VolumeLabel) + if (*VolInfo->VolumeLabel) { RtlStringCchPrintfExA(pBuffer, cchBufferSize, &pBuffer, &cchLabelSize, 0, "\"%-.11S\" ", - PartEntry->VolumeLabel); + VolInfo->VolumeLabel); cchLabelSize = cchBufferSize - cchLabelSize; // Actual length of the label part. cchBufferSize -= cchLabelSize; // And reset cchBufferSize to what it should be. } @@ -237,7 +237,7 @@ PartitionDescription( /* The minimum length can be at most 11 since * cchLabelSize can be at most == 11 + 3 == 14 */ 25 - min(cchLabelSize, 25), - PartEntry->FileSystem); + VolInfo->FileSystem); } else { @@ -275,7 +275,7 @@ PartitionDescription( /* Show the remaining free space only if a FS is mounted */ // FIXME: We don't support that yet! #if 0 - if (*PartEntry->FileSystem) + if (VolInfo && *VolInfo->FileSystem) { RtlStringCchPrintfA(pBuffer, cchBufferSize, "%*s%6I64u %s (%6I64u %s %s)", diff --git a/base/setup/usetup/usetup.c b/base/setup/usetup/usetup.c index fb6de2eb614..7dd30bf468f 100644 --- a/base/setup/usetup/usetup.c +++ b/base/setup/usetup/usetup.c @@ -46,6 +46,8 @@ static USETUP_DATA USetupData; /* The partition where to perform the installation */ static PPARTENTRY InstallPartition = NULL; +// static PVOLENTRY InstallVolume = NULL; +#define InstallVolume (InstallPartition->Volume) /* * The system partition we will actually use. It can be different from * PartitionList->SystemPartition in case we don't support it, or we install @@ -57,6 +59,8 @@ static PPARTENTRY InstallPartition = NULL; * operation on them). */ static PPARTENTRY SystemPartition = NULL; +// static PVOLENTRY SystemVolume = NULL; +#define SystemVolume (SystemPartition->Volume) /* OTHER Stuff *****/ @@ -77,8 +81,8 @@ static enum { PartTypeExtended // MBR-disk container } PartCreateType = PartTypeData; -/* Flag set in PARTENTRY::New when a partition is created automatically */ -#define PARTITION_NEW_AUTOCREATE 0x80 +/* Flag set in VOLENTRY::New when a partition/volume is created automatically */ +#define VOLUME_NEW_AUTOCREATE 0x80 /* List of supported file systems for the partition to be formatted */ static PFILE_SYSTEM_LIST FileSystemList = NULL; @@ -508,14 +512,14 @@ GetNTOSInstallationName( IN SIZE_T cchBufferSize) { PNTOS_INSTALLATION NtOsInstall = (PNTOS_INSTALLATION)GetListEntryData(Entry); - PPARTENTRY PartEntry = NtOsInstall->PartEntry; + PVOLINFO VolInfo = (NtOsInstall->Volume ? &NtOsInstall->Volume->Info : NULL); - if (PartEntry && PartEntry->DriveLetter) + if (VolInfo && VolInfo->DriveLetter) { /* We have retrieved a partition that is mounted */ return RtlStringCchPrintfA(Buffer, cchBufferSize, "%C:%S \"%S\"", - PartEntry->DriveLetter, + VolInfo->DriveLetter, NtOsInstall->PathComponent, NtOsInstall->InstallationName); } @@ -1568,7 +1572,6 @@ SelectPartitionPage(PINPUT_RECORD Ir) DPRINT1("RepairUpdateFlag == TRUE, SelectPartition() returned FALSE, assert!\n"); ASSERT(FALSE); } - ASSERT(!IsContainerPartition(InstallPartition->PartitionType)); return START_PARTITION_OPERATIONS_PAGE; } @@ -1603,7 +1606,8 @@ SelectPartitionPage(PINPUT_RECORD Ir) CurrentPartition, 0ULL, 0); - CurrentPartition->New |= PARTITION_NEW_AUTOCREATE; + if (CurrentPartition->Volume) + CurrentPartition->Volume->New |= VOLUME_NEW_AUTOCREATE; // FIXME?? Aren't we going to enter an infinite loop, if this test fails?? if (!IsPartitionLargeEnough(CurrentPartition)) @@ -1735,7 +1739,8 @@ SelectPartitionPage(PINPUT_RECORD Ir) CurrentPartition, 0ULL, 0); - CurrentPartition->New |= PARTITION_NEW_AUTOCREATE; + if (CurrentPartition->Volume) + CurrentPartition->Volume->New |= VOLUME_NEW_AUTOCREATE; } if (!IsPartitionLargeEnough(CurrentPartition)) @@ -1781,28 +1786,23 @@ SelectPartitionPage(PINPUT_RECORD Ir) } else if (Ir->Event.KeyEvent.wVirtualKeyCode == 'D') /* D */ { - UNICODE_STRING CurrentPartitionU; - WCHAR PathBuffer[MAX_PATH]; - ASSERT(CurrentPartition != NULL); /* Ignore deletion in case this is not a partitioned entry */ if (!CurrentPartition->IsPartitioned) - { continue; - } // TODO: Do something similar before trying to format the partition? - if (!CurrentPartition->New && - !IsContainerPartition(CurrentPartition->PartitionType) && - CurrentPartition->FormatState != Unformatted) + if (CurrentPartition->Volume && !CurrentPartition->Volume->New && + (CurrentPartition->Volume->FormatState != Unformatted)) { + UNICODE_STRING CurrentPartitionU; + WCHAR PathBuffer[RTL_NUMBER_OF_FIELD(VOLINFO, DeviceName) + 1]; + ASSERT(CurrentPartition->PartitionNumber != 0); - RtlStringCchPrintfW(PathBuffer, ARRAYSIZE(PathBuffer), - L"\\Device\\Harddisk%lu\\Partition%lu\\", - CurrentPartition->DiskEntry->DiskNumber, - CurrentPartition->PartitionNumber); + RtlStringCchPrintfW(PathBuffer, _countof(PathBuffer), + L"%s\\", CurrentPartition->Volume->Info.DeviceName); RtlInitUnicodeString(&CurrentPartitionU, PathBuffer); /* @@ -2286,16 +2286,16 @@ StartPartitionOperationsPage(PINPUT_RECORD Ir) // /* Set the AUTOCREATE flag if the system partition was automatically created */ - if (SystemPartition->New) - SystemPartition->New |= PARTITION_NEW_AUTOCREATE; + if (SystemPartition->New && SystemVolume) + SystemVolume->New |= VOLUME_NEW_AUTOCREATE; CONSOLE_ClearScreen(); CONSOLE_Flush(); /* Apply all pending operations on partitions: formatting and checking */ Success = FsVolCommitOpsQueue(PartitionList, - SystemPartition, - InstallPartition, + SystemVolume, + InstallVolume, FsVolCallback, &FsVolContext); if (!Success) @@ -2358,41 +2358,43 @@ ResetFileSystemList(VOID) static FSVOL_OP SelectFileSystemPage( - IN PFSVOL_CONTEXT FsVolContext, - IN PPARTENTRY PartEntry) + _In_ PFSVOL_CONTEXT FsVolContext, + _In_ PVOLENTRY Volume) { PINPUT_RECORD Ir = FsVolContext->Ir; + PPARTENTRY PartEntry = Volume->PartEntry; PDISKENTRY DiskEntry = PartEntry->DiskEntry; PCWSTR DefaultFs; + BOOLEAN ForceFormat; CHAR LineBuffer[100]; DPRINT("SelectFileSystemPage()\n"); - ASSERT(PartEntry->IsPartitioned && PartEntry->PartitionNumber != 0); + ForceFormat = (Volume->New || Volume->FormatState == Unformatted); Restart: - /* Reset the file system list for each partition that is to be formatted */ + /* Reset the file system list for each volume that is to be formatted */ ResetFileSystemList(); CONSOLE_ClearScreen(); CONSOLE_Flush(); MUIDisplayPage(SELECT_FILE_SYSTEM_PAGE); - if (PartEntry->New & PARTITION_NEW_AUTOCREATE) + if (Volume->New & VOLUME_NEW_AUTOCREATE) { - PartEntry->New &= ~PARTITION_NEW_AUTOCREATE; + Volume->New &= ~VOLUME_NEW_AUTOCREATE; CONSOLE_SetTextXY(6, 8, MUIGetString(STRING_NEWPARTITION)); } - else if (PartEntry->New) + else if (Volume->New) { ULONG uID; - if (PartEntry == SystemPartition) // FormatSystemPartition + if (Volume == SystemVolume) uID = STRING_NONFORMATTEDSYSTEMPART; - else if (PartEntry == InstallPartition) // FormatInstallPartition + else if (Volume == InstallVolume) uID = STRING_NONFORMATTEDPART; - else // FormatOtherPartition + else uID = STRING_NONFORMATTEDOTHERPART; CONSOLE_SetTextXY(6, 8, MUIGetString(uID)); @@ -2410,7 +2412,7 @@ Restart: LineBuffer); /* Show "This Partition will be formatted next" only if it is unformatted */ - if (PartEntry->New || PartEntry->FormatState == Unformatted) + if (ForceFormat) CONSOLE_SetTextXY(6, 14, MUIGetString(STRING_PARTFORMAT)); ASSERT(!FileSystemList); @@ -2439,11 +2441,8 @@ Restart: } /* Create the file system list */ - // TODO: Display only the FSes compatible with the selected partition! - FileSystemList = CreateFileSystemList(6, 26, - PartEntry->New || - PartEntry->FormatState == Unformatted, - DefaultFs); + // TODO: Display only the FSes compatible with the selected volume! + FileSystemList = CreateFileSystemList(6, 26, ForceFormat, DefaultFs); if (!FileSystemList) { /* FIXME: show an error dialog */ @@ -2493,23 +2492,21 @@ Restart: { if (!FileSystemList->Selected->FileSystem) { - ASSERT(!PartEntry->New && PartEntry->FormatState != Unformatted); + /* The 'Keep existing filesystem' entry was chosen, + * the volume must be already formatted */ + ASSERT(!ForceFormat); - /* - * Skip formatting this partition. We will also ignore + /* Skip formatting this volume. We will also ignore * file system checks on it, unless it is either the - * system or the installation partition. - */ - if (PartEntry != SystemPartition && - PartEntry != InstallPartition) - { - PartEntry->NeedsCheck = FALSE; - } + * system or the installation volume. */ + if ((Volume != SystemVolume) && (Volume != InstallVolume)) + Volume->NeedsCheck = FALSE; + return FSVOL_SKIP; } else { - /* Format this partition */ + /* Format this volume */ return FSVOL_DOIT; } } @@ -2520,10 +2517,11 @@ Restart: static FSVOL_OP FormatPartitionPage( - IN PFSVOL_CONTEXT FsVolContext, - IN PPARTENTRY PartEntry) + _In_ PFSVOL_CONTEXT FsVolContext, + _In_ PVOLENTRY Volume) { PINPUT_RECORD Ir = FsVolContext->Ir; + PPARTENTRY PartEntry = Volume->PartEntry; PDISKENTRY DiskEntry = PartEntry->DiskEntry; CHAR LineBuffer[100]; @@ -2571,8 +2569,9 @@ Restart: static VOID CheckFileSystemPage( - IN PPARTENTRY PartEntry) + _In_ PVOLENTRY Volume) { + PPARTENTRY PartEntry = Volume->PartEntry; PDISKENTRY DiskEntry = PartEntry->DiskEntry; CHAR LineBuffer[100]; @@ -2693,7 +2692,8 @@ FsVolCallback( if (FmtInfo->ErrorStatus == STATUS_UNRECOGNIZED_VOLUME) { /* FIXME: show an error dialog */ - // MUIDisplayError(ERROR_FORMATTING_PARTITION, Ir, POPUP_WAIT_ANY_KEY, PathBuffer); + // MUIDisplayError(ERROR_FORMATTING_PARTITION, Ir, POPUP_WAIT_ANY_KEY, + // FmtInfo->Volume->Info.DeviceName); FsVolContext->NextPageOnAbort = QUIT_PAGE; return FSVOL_ABORT; } @@ -2737,16 +2737,9 @@ FsVolCallback( } else if (!NT_SUCCESS(FmtInfo->ErrorStatus)) { - WCHAR PathBuffer[MAX_PATH]; - - /** HACK!! **/ - RtlStringCchPrintfW(PathBuffer, ARRAYSIZE(PathBuffer), - L"\\Device\\Harddisk%lu\\Partition%lu", - FmtInfo->PartEntry->DiskEntry->DiskNumber, - FmtInfo->PartEntry->PartitionNumber); - DPRINT1("FormatPartition() failed: Status 0x%08lx\n", FmtInfo->ErrorStatus); - MUIDisplayError(ERROR_FORMATTING_PARTITION, Ir, POPUP_WAIT_ANY_KEY, PathBuffer); + MUIDisplayError(ERROR_FORMATTING_PARTITION, Ir, POPUP_WAIT_ANY_KEY, + FmtInfo->Volume->Info.DeviceName); FsVolContext->NextPageOnAbort = QUIT_PAGE; return FSVOL_ABORT; } @@ -2766,7 +2759,7 @@ FsVolCallback( "\n" " \x07 Press ENTER to continue Setup.\n" " \x07 Press F3 to quit Setup.", - ChkInfo->PartEntry->FileSystem); + ChkInfo->Volume->Info.FileSystem); PopupError(Buffer, MUIGetString(STRING_QUITCONTINUE), @@ -2820,12 +2813,12 @@ FsVolCallback( ASSERT((FSVOL_OP)Param2 == FSVOL_FORMAT); /* Select the file system */ - Result = SelectFileSystemPage(FsVolContext, FmtInfo->PartEntry); + Result = SelectFileSystemPage(FsVolContext, FmtInfo->Volume); if (Result != FSVOL_DOIT) return Result; /* Display the formatting page */ - Result = FormatPartitionPage(FsVolContext, FmtInfo->PartEntry); + Result = FormatPartitionPage(FsVolContext, FmtInfo->Volume); if (Result != FSVOL_DOIT) return Result; @@ -2849,7 +2842,7 @@ FsVolCallback( ASSERT((FSVOL_OP)Param2 == FSVOL_CHECK); - CheckFileSystemPage(ChkInfo->PartEntry); + CheckFileSystemPage(ChkInfo->Volume); StartCheck(ChkInfo); return FSVOL_DOIT; } @@ -2907,7 +2900,7 @@ InstallDirectoryPage(PINPUT_RECORD Ir) */ if ((RepairUpdateFlag || IsUnattendedSetup) && IsValidInstallDirectory(InstallDir)) { - Status = InitDestinationPaths(&USetupData, InstallDir, InstallPartition); + Status = InitDestinationPaths(&USetupData, InstallDir, InstallVolume); if (!NT_SUCCESS(Status)) { DPRINT1("InitDestinationPaths() failed: Status 0x%lx\n", Status); @@ -3019,7 +3012,7 @@ InstallDirectoryPage(PINPUT_RECORD Ir) return INSTALL_DIRECTORY_PAGE; } - Status = InitDestinationPaths(&USetupData, InstallDir, InstallPartition); + Status = InitDestinationPaths(&USetupData, InstallDir, InstallVolume); if (!NT_SUCCESS(Status)) { DPRINT1("InitDestinationPaths() failed: Status 0x%lx\n", Status); @@ -3426,7 +3419,7 @@ RegistryPage(PINPUT_RECORD Ir) Error = UpdateRegistry(&USetupData, RepairUpdateFlag, PartitionList, - InstallPartition->DriveLetter, + InstallVolume->Info.DriveLetter, SelectedLanguageId, RegistryStatus, &s_SubstSettings); @@ -3667,11 +3660,11 @@ BootLoaderHardDiskPage(PINPUT_RECORD Ir) Status = InstallVBRToPartition(&USetupData.SystemRootPath, &USetupData.SourceRootPath, &USetupData.DestinationArcPath, - SystemPartition->FileSystem); + SystemVolume->Info.FileSystem); if (!NT_SUCCESS(Status)) { MUIDisplayError(ERROR_WRITE_BOOT, Ir, POPUP_WAIT_ENTER, - SystemPartition->FileSystem); + SystemVolume->Info.FileSystem); return FALSE; } @@ -3697,11 +3690,11 @@ BootLoaderHardDiskPage(PINPUT_RECORD Ir) Status = InstallVBRToPartition(&USetupData.SystemRootPath, &USetupData.SourceRootPath, &USetupData.DestinationArcPath, - SystemPartition->FileSystem); + SystemVolume->Info.FileSystem); if (!NT_SUCCESS(Status)) { MUIDisplayError(ERROR_WRITE_BOOT, Ir, POPUP_WAIT_ENTER, - SystemPartition->FileSystem); + SystemVolume->Info.FileSystem); return FALSE; } }

11 months

[reactos] 01/02: [SETUPLIB] Add some device utility functions; to be used later (#7258)

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0f8dc6b2dfb926c971dc8… commit 0f8dc6b2dfb926c971dc8796c96db05158ead940 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Fri Jul 12 18:39:39 2024 +0200 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Mon Aug 26 16:42:46 2024 +0200 [SETUPLIB] Add some device utility functions; to be used later (#7258) --- base/setup/lib/CMakeLists.txt | 1 + base/setup/lib/utils/devutils.c | 87 +++++++++++++++++++++++++++++++++++++++++ base/setup/lib/utils/devutils.h | 24 ++++++++++++ 3 files changed, 112 insertions(+) diff --git a/base/setup/lib/CMakeLists.txt b/base/setup/lib/CMakeLists.txt index cc79ec83ef8..57eae6b3a6e 100644 --- a/base/setup/lib/CMakeLists.txt +++ b/base/setup/lib/CMakeLists.txt @@ -11,6 +11,7 @@ list(APPEND SOURCE spapisup/infsupp.c utils/arcname.c utils/bldrsup.c + utils/devutils.c utils/filesup.c utils/fsrec.c utils/genlist.c diff --git a/base/setup/lib/utils/devutils.c b/base/setup/lib/utils/devutils.c new file mode 100644 index 00000000000..f8bc8a83daf --- /dev/null +++ b/base/setup/lib/utils/devutils.c @@ -0,0 +1,87 @@ +/* + * PROJECT: ReactOS Setup Library + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Device utility functions + * COPYRIGHT: Copyright 2024 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> + */ + +#include "precomp.h" +#include "devutils.h" + +/* FUNCTIONS *****************************************************************/ + +/** + * @brief + * Open an existing device given by its NT-style path, which is assumed to be + * for a disk device or a partition. The open is for synchronous I/O access. + * + * @param[in] DevicePath + * Supplies the NT-style path to the device to open. + * + * @param[out] DeviceHandle + * If successful, receives the NT handle of the opened device. + * Once the handle is no longer in use, call NtClose() to close it. + * + * @param[in] DesiredAccess + * An ACCESS_MASK value combination that determines the requested access + * to the device. Because the open is for synchronous access, SYNCHRONIZE + * is automatically added to the access mask. + * + * @param[in] ShareAccess + * Specifies the type of share access for the device. + * + * @return An NTSTATUS code indicating success or failure. + **/ +NTSTATUS +pOpenDeviceEx( + _In_ PCWSTR DevicePath, + _Out_ PHANDLE DeviceHandle, + _In_ ACCESS_MASK DesiredAccess, + _In_ ULONG ShareAccess) +{ + UNICODE_STRING Name; + OBJECT_ATTRIBUTES ObjectAttributes; + IO_STATUS_BLOCK IoStatusBlock; + + RtlInitUnicodeString(&Name, DevicePath); + InitializeObjectAttributes(&ObjectAttributes, + &Name, + OBJ_CASE_INSENSITIVE, + NULL, + NULL); + return NtOpenFile(DeviceHandle, + DesiredAccess | SYNCHRONIZE, + &ObjectAttributes, + &IoStatusBlock, + ShareAccess, + /* FILE_NON_DIRECTORY_FILE | */ + FILE_SYNCHRONOUS_IO_NONALERT); +} + +/** + * @brief + * Open an existing device given by its NT-style path, which is assumed to be + * for a disk device or a partition. The open is share read/write/delete, for + * synchronous I/O and read access. + * + * @param[in] DevicePath + * @param[out] DeviceHandle + * See the DevicePath and DeviceHandle parameters of pOpenDeviceEx(). + * + * @return An NTSTATUS code indicating success or failure. + * + * @see pOpenDeviceEx() + **/ +NTSTATUS +pOpenDevice( + _In_ PCWSTR DevicePath, + _Out_ PHANDLE DeviceHandle) +{ + return pOpenDeviceEx(DevicePath, + DeviceHandle, + FILE_READ_DATA | FILE_READ_ATTRIBUTES, + FILE_SHARE_VALID_FLAGS // FILE_SHARE_READ,WRITE,DELETE + ); +} + +/* EOF */ diff --git a/base/setup/lib/utils/devutils.h b/base/setup/lib/utils/devutils.h new file mode 100644 index 00000000000..63bbb624d66 --- /dev/null +++ b/base/setup/lib/utils/devutils.h @@ -0,0 +1,24 @@ +/* + * PROJECT: ReactOS Setup Library + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Device utility functions + * COPYRIGHT: Copyright 2024 Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> + */ + +#pragma once + +/* FUNCTIONS *****************************************************************/ + +NTSTATUS +pOpenDeviceEx( + _In_ PCWSTR DevicePath, + _Out_ PHANDLE DeviceHandle, + _In_ ACCESS_MASK DesiredAccess, + _In_ ULONG ShareAccess); + +NTSTATUS +pOpenDevice( + _In_ PCWSTR DevicePath, + _Out_ PHANDLE DeviceHandle); + +/* EOF */

11 months

[reactos] 01/01: [NTOS:FSRTL] Check for the correct return status when inserting a new Filter Context entry According to our declaration/definition, IoChangeFileObjectFilerContext returns NTSTATUS, not BOOLEAN. Zero return (which was actually checked before) for BOOLEAN means failure, but for NTSTATUS it's success. So it should (and now actually does) free and fail appropriately only in failure case, but not in success, when it shouldn't. This fixes most of problems with fltmgr.sys driver from W

by Oleg Dubinskiy

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c59e2d20d9c8a42f3c944… commit c59e2d20d9c8a42f3c94403282efcab1cbe20fd9 Author: Oleg Dubinskiy <oleg.dubinskij30(a)gmail.com> AuthorDate: Mon Aug 26 11:16:49 2024 +0200 Commit: Oleg Dubinskiy <oleg.dubinskij30(a)gmail.com> CommitDate: Mon Aug 26 11:16:49 2024 +0200 [NTOS:FSRTL] Check for the correct return status when inserting a new Filter Context entry According to our declaration/definition, IoChangeFileObjectFilerContext returns NTSTATUS, not BOOLEAN. Zero return (which was actually checked before) for BOOLEAN means failure, but for NTSTATUS it's success. So it should (and now actually does) free and fail appropriately only in failure case, but not in success, when it shouldn't. This fixes most of problems with fltmgr.sys driver from Windows XP/Server 2003 and a lot of 3rd party filter drivers which use it from many apps (Avast Free Antivirus all versions, Avira AntiVir Personal 8.2, Dr. Web Security Space 8.0, Kaspersky Antivirus 2012 etc. etc.). CORE-14157, CORE-14635, CORE-19318 --- ntoskrnl/fsrtl/filtrctx.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ntoskrnl/fsrtl/filtrctx.c b/ntoskrnl/fsrtl/filtrctx.c index 9bd616fad7a..a71475a93bc 100644 --- a/ntoskrnl/fsrtl/filtrctx.c +++ b/ntoskrnl/fsrtl/filtrctx.c @@ -176,6 +176,7 @@ FsRtlInsertPerFileObjectContext(IN PFILE_OBJECT FileObject, IN PFSRTL_PER_FILEOBJECT_CONTEXT Ptr) { PFILE_OBJECT_FILTER_CONTEXTS FOContext = NULL; + NTSTATUS Status; if (!FileObject) { @@ -203,7 +204,8 @@ FsRtlInsertPerFileObjectContext(IN PFILE_OBJECT FileObject, InitializeListHead(&(FOContext->FilterContexts)); /* Set it */ - if (!IoChangeFileObjectFilterContext(FileObject, FOContext, TRUE)) + Status = IoChangeFileObjectFilterContext(FileObject, FOContext, TRUE); + if (!NT_SUCCESS(Status)) { /* If it fails, it means that someone else has set it in the meanwhile */ ExFreePoolWithTag(FOContext, 'FOCX');

11 months

[reactos] 01/01: [CMD] Convert to explicitly unicode

by Timo Kreuzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c948ea859bf7557cc1c4d… commit c948ea859bf7557cc1c4d84bedb4dc2e8cd42372 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Sat May 18 14:56:29 2024 +0300 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Sun Aug 25 16:17:17 2024 +0300 [CMD] Convert to explicitly unicode --- base/shell/cmd/console.c | 32 ++++++++++++++------------------ base/shell/cmd/error.c | 22 +++++++++++----------- 2 files changed, 25 insertions(+), 29 deletions(-) diff --git a/base/shell/cmd/console.c b/base/shell/cmd/console.c index de35fa7f373..047c744c79f 100644 --- a/base/shell/cmd/console.c +++ b/base/shell/cmd/console.c @@ -78,21 +78,18 @@ VOID ConInKey(PINPUT_RECORD lpBuffer) while (TRUE); } -VOID ConInString(LPTSTR lpInput, DWORD dwLength) +VOID ConInString(LPWSTR lpInput, DWORD dwLength) { DWORD dwOldMode; DWORD dwRead = 0; HANDLE hFile; - LPTSTR p; + LPWSTR p; PCHAR pBuf; -#ifdef _UNICODE pBuf = (PCHAR)cmd_alloc(dwLength - 1); -#else - pBuf = lpInput; -#endif - ZeroMemory(lpInput, dwLength * sizeof(TCHAR)); + + ZeroMemory(lpInput, dwLength * sizeof(WCHAR)); hFile = GetStdHandle(STD_INPUT_HANDLE); GetConsoleMode(hFile, &dwOldMode); @@ -100,15 +97,14 @@ VOID ConInString(LPTSTR lpInput, DWORD dwLength) ReadFile(hFile, (PVOID)pBuf, dwLength - 1, &dwRead, NULL); -#ifdef _UNICODE MultiByteToWideChar(InputCodePage, 0, pBuf, dwRead, lpInput, dwLength - 1); cmd_free(pBuf); -#endif + for (p = lpInput; *p; p++) { - if (*p == _T('\r')) // Terminate at the carriage-return. + if (*p == L'\r') // Terminate at the carriage-return. { - *p = _T('\0'); + *p = L'\0'; break; } } @@ -120,12 +116,12 @@ VOID ConInString(LPTSTR lpInput, DWORD dwLength) /******************** Console STREAM OUT utility functions ********************/ -VOID ConOutChar(TCHAR c) +VOID ConOutChar(WCHAR c) { ConWrite(StdOut, &c, 1); } -VOID ConErrChar(TCHAR c) +VOID ConErrChar(WCHAR c) { ConWrite(StdErr, &c, 1); } @@ -152,23 +148,23 @@ VOID __cdecl ConFormatMessage(PCON_STREAM Stream, DWORD MessageId, ...) /************************** Console PAGER functions ***************************/ -BOOL ConPrintfVPaging(PCON_PAGER Pager, BOOL StartPaging, LPTSTR szFormat, va_list arg_ptr) +BOOL ConPrintfVPaging(PCON_PAGER Pager, BOOL StartPaging, LPWSTR szFormat, va_list arg_ptr) { // INT len; - TCHAR szOut[OUTPUT_BUFFER_SIZE]; + WCHAR szOut[OUTPUT_BUFFER_SIZE]; /* Return if no string has been given */ if (szFormat == NULL) return TRUE; - /*len =*/ _vstprintf(szOut, szFormat, arg_ptr); + /*len =*/ vswprintf(szOut, szFormat, arg_ptr); // return ConPutsPaging(Pager, PagePrompt, StartPaging, szOut); return ConWritePaging(Pager, PagePrompt, StartPaging, szOut, wcslen(szOut)); } -BOOL __cdecl ConOutPrintfPaging(BOOL StartPaging, LPTSTR szFormat, ...) +BOOL __cdecl ConOutPrintfPaging(BOOL StartPaging, LPWSTR szFormat, ...) { BOOL bRet; va_list arg_ptr; @@ -277,7 +273,7 @@ BOOL ConGetDefaultAttributes(PWORD pwDefAttr) #endif -BOOL ConSetTitle(IN LPCTSTR lpConsoleTitle) +BOOL ConSetTitle(IN LPCWSTR lpConsoleTitle) { /* Now really set the console title */ return SetConsoleTitle(lpConsoleTitle); diff --git a/base/shell/cmd/error.c b/base/shell/cmd/error.c index 147b0f7acf9..bd39ff56344 100644 --- a/base/shell/cmd/error.c +++ b/base/shell/cmd/error.c @@ -25,11 +25,11 @@ VOID ErrorMessage( IN DWORD dwErrorCode, - IN PCTSTR szFormat OPTIONAL, + IN PCWSTR szFormat OPTIONAL, ...) { va_list arg_ptr; - PTSTR szError; + PWSTR szError; TCHAR szMsg[RC_STRING_MAX_SIZE]; TCHAR szMessage[1024]; @@ -40,7 +40,7 @@ ErrorMessage( if (szFormat) { va_start(arg_ptr, szFormat); - _vstprintf(szMessage, szFormat, arg_ptr); + vswprintf(szMessage, szFormat, arg_ptr); va_end(arg_ptr); } @@ -62,21 +62,21 @@ ErrorMessage( ConErrPrintf(_T("%s\n"), szMsg); } -VOID error_parameter_format(TCHAR ch) +VOID error_parameter_format(WCHAR ch) { ConErrResPrintf(STRING_ERROR_PARAMETERF_ERROR, ch); nErrorLevel = 1; } -VOID error_invalid_switch(TCHAR ch) +VOID error_invalid_switch(WCHAR ch) { ConErrResPrintf(STRING_ERROR_INVALID_SWITCH, ch); nErrorLevel = 1; } -VOID error_too_many_parameters(PCTSTR s) +VOID error_too_many_parameters(PCWSTR s) { ConErrResPrintf(STRING_ERROR_TOO_MANY_PARAMETERS, s); nErrorLevel = 1; @@ -97,7 +97,7 @@ VOID error_file_not_found(VOID) } -VOID error_sfile_not_found(PCTSTR s) +VOID error_sfile_not_found(PCWSTR s) { TCHAR szMsg[RC_STRING_MAX_SIZE]; @@ -121,7 +121,7 @@ VOID error_invalid_drive(VOID) } -VOID error_bad_command(PCTSTR s) +VOID error_bad_command(PCWSTR s) { ConErrResPrintf(STRING_ERROR_BADCOMMAND, s); nErrorLevel = 9009; @@ -142,16 +142,16 @@ VOID error_out_of_memory(VOID) } -VOID error_invalid_parameter_format(PCTSTR s) +VOID error_invalid_parameter_format(PCWSTR s) { ConErrResPrintf(STRING_ERROR_INVALID_PARAM_FORMAT, s); nErrorLevel = 1; } -VOID error_syntax(PCTSTR s) +VOID error_syntax(PCWSTR s) { - TCHAR szMsg[RC_STRING_MAX_SIZE]; + WCHAR szMsg[RC_STRING_MAX_SIZE]; LoadString(CMD_ModuleHandle, STRING_ERROR_ERROR2, szMsg, ARRAYSIZE(szMsg));

11 months

[reactos] 01/01: [SHELL32] Create link must ask for a parsing name for file targets (#7267)

by Whindmar Saksit

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=cca9acfa1d9d2bf258f34… commit cca9acfa1d9d2bf258f34ea89b210d5e8fb0563d Author: Whindmar Saksit <whindsaks(a)proton.me> AuthorDate: Sat Aug 24 19:01:27 2024 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Sat Aug 24 19:01:27 2024 +0200 [SHELL32] Create link must ask for a parsing name for file targets (#7267) --- dll/win32/shell32/droptargets/CFSDropTarget.cpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/dll/win32/shell32/droptargets/CFSDropTarget.cpp b/dll/win32/shell32/droptargets/CFSDropTarget.cpp index f7694320f57..00c056acd8e 100644 --- a/dll/win32/shell32/droptargets/CFSDropTarget.cpp +++ b/dll/win32/shell32/droptargets/CFSDropTarget.cpp @@ -588,12 +588,19 @@ HRESULT CFSDropTarget::_DoDrop(IDataObject *pDataObject, /* We need to create a link for each pidl in the copied items, so step through the pidls from the clipboard */ for (UINT i = 0; i < lpcida->cidl; i++) { + SFGAOF att = SHGetAttributes(psfFrom, apidl[i], SFGAO_FOLDER | SFGAO_STREAM | SFGAO_FILESYSTEM); CComHeapPtr<ITEMIDLIST_ABSOLUTE> pidlFull; hr = SHILCombine(pidl, apidl[i], &pidlFull); WCHAR targetName[MAX_PATH]; if (SUCCEEDED(hr)) - hr = Shell_DisplayNameOf(psfFrom, apidl[i], SHGDN_FOREDITING | SHGDN_INFOLDER, targetName, _countof(targetName)); + { + // If the target is a file, we use SHGDN_FORPARSING because "NeverShowExt" will hide the ".lnk" extension. + // If the target is a virtual item, we ask for the friendly name because SHGDN_FORPARSING will return a GUID. + BOOL UseParsing = (att & (SFGAO_FILESYSTEM | SFGAO_FOLDER)) == SFGAO_FILESYSTEM; + DWORD ShgdnFor = UseParsing ? SHGDN_FORPARSING : SHGDN_FOREDITING; + hr = Shell_DisplayNameOf(psfFrom, apidl[i], ShgdnFor | SHGDN_INFOLDER, targetName, _countof(targetName)); + } if (FAILED_UNEXPECTEDLY(hr)) { SHELL_ErrorBox(m_hwndSite, hr); @@ -605,7 +612,6 @@ HRESULT CFSDropTarget::_DoDrop(IDataObject *pDataObject, PathCombineW(wszCombined, m_sPathTarget, targetName); // Check to see if the source is a link - SFGAOF att = SHGetAttributes(psfFrom, apidl[i], SFGAO_FOLDER | SFGAO_STREAM | SFGAO_FILESYSTEM); BOOL fSourceIsLink = FALSE; if (!wcsicmp(PathFindExtensionW(targetName), L".lnk") && (att & (SFGAO_FOLDER | SFGAO_STREAM)) != SFGAO_FOLDER) {

11 months

[reactos] 01/01: [MSPAINT] it-IT.rc: Fix compiler warning (#7270)

by Joachim Henze

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=5506a8e17062ad5f2b826… commit 5506a8e17062ad5f2b826f6331fadc69810d031c Author: Joachim Henze <joachim.henze(a)reactos.org> AuthorDate: Sat Aug 24 06:04:48 2024 +0200 Commit: GitHub <noreply(a)github.com> CommitDate: Sat Aug 24 06:04:48 2024 +0200 [MSPAINT] it-IT.rc: Fix compiler warning (#7270) GCC8.4.0dbg warns about: C:/ros/reactos/base/applications/mspaint/lang/it-IT.rc:267: unrecognized escape sequence Fix that. the regression was introduced by 0.4.15-dev-8555-g fbcbbd8768b8a3dda9013dfe3553867176c521b1 from (#7248) --- base/applications/mspaint/lang/it-IT.rc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/applications/mspaint/lang/it-IT.rc b/base/applications/mspaint/lang/it-IT.rc index d48250a1882..d7e62a67d1f 100644 --- a/base/applications/mspaint/lang/it-IT.rc +++ b/base/applications/mspaint/lang/it-IT.rc @@ -264,7 +264,7 @@ BEGIN IDS_PERCENTAGE "La percentuale deve essere compresa tra 1 e 500." IDS_ANGLE "L'angolo deve essere compreso tra -89 e 89." IDS_LOADERRORTEXT "l file %s non può essere caricato." - IDS_ENLARGEPROMPTTEXT "L'immagine negli appunti è più grande della tela.\La si vuole allargare?" + IDS_ENLARGEPROMPTTEXT "L'immagine negli appunti è più grande della tela.\nLa si vuole allargare?" IDS_BOLD "Grossivo" IDS_ITALIC "Italico" IDS_UNDERLINE "Sottolineato"

11 months

← Newer
1
2
3
4
5
6
7
...
14
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs August 2024