Ros-diffs

ros-diffs@reactos.org

12 participants
81031 discussions

[reactos] 01/01: [SHELL32] Fix exception on modifying deleted file type (#5996)

by Katayama Hirofumi MZ

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=edaeef94180e961a78c5a… commit edaeef94180e961a78c5a5ddbb1c4e1e94473763 Author: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> AuthorDate: Mon Nov 20 09:27:06 2023 +0900 Commit: GitHub <noreply(a)github.com> CommitDate: Mon Nov 20 09:27:06 2023 +0900 [SHELL32] Fix exception on modifying deleted file type (#5996) Based on KRosUser's filetypes.patch. Check NULL for pEntry. CORE-19324 --- dll/win32/shell32/dialogs/filetypes.cpp | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/dll/win32/shell32/dialogs/filetypes.cpp b/dll/win32/shell32/dialogs/filetypes.cpp index 78e5f7322ad..ad394c8b1d3 100644 --- a/dll/win32/shell32/dialogs/filetypes.cpp +++ b/dll/win32/shell32/dialogs/filetypes.cpp @@ -1722,8 +1722,11 @@ FolderOptionsFileTypesDlg( case IDC_FILETYPES_ADVANCED: edittype.hwndLV = GetDlgItem(hwndDlg, IDC_FILETYPES_LISTVIEW); edittype.pEntry = FileTypesDlg_GetEntry(edittype.hwndLV); - DialogBoxParamW(shell32_hInstance, MAKEINTRESOURCEW(IDD_EDITTYPE), - hwndDlg, EditTypeDlgProc, (LPARAM)&edittype); + if (edittype.pEntry) + { + DialogBoxParamW(shell32_hInstance, MAKEINTRESOURCEW(IDD_EDITTYPE), + hwndDlg, EditTypeDlgProc, (LPARAM)&edittype); + } break; } break; @@ -1745,8 +1748,11 @@ FolderOptionsFileTypesDlg( case NM_DBLCLK: edittype.hwndLV = GetDlgItem(hwndDlg, IDC_FILETYPES_LISTVIEW); edittype.pEntry = FileTypesDlg_GetEntry(edittype.hwndLV); - DialogBoxParamW(shell32_hInstance, MAKEINTRESOURCEW(IDD_EDITTYPE), - hwndDlg, EditTypeDlgProc, (LPARAM)&edittype); + if (edittype.pEntry) + { + DialogBoxParamW(shell32_hInstance, MAKEINTRESOURCEW(IDD_EDITTYPE), + hwndDlg, EditTypeDlgProc, (LPARAM)&edittype); + } break; case LVN_DELETEALLITEMS:

1 year, 1 month

[reactos] 01/01: [NTOS:KE][HALX86] Implement AP startup code (#5879)

by Justin Miller

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=516ccad340b3da703d595… commit 516ccad340b3da703d5955cdf1fa602c8f9e0c6c Author: Justin Miller <justin.miller(a)reactos.org> AuthorDate: Sun Nov 19 15:51:33 2023 -0800 Commit: GitHub <noreply(a)github.com> CommitDate: Sun Nov 19 15:51:33 2023 -0800 [NTOS:KE][HALX86] Implement AP startup code (#5879) Co-authored-by: Victor Perevertkin <victor.perevertkin(a)reactos.org> Introduce the initial changes needed to get other processors up and into kernel mode. This only supports x86 as of now but is the first real step towards using other system processors. --- boot/freeldr/freeldr/ntldr/arch/i386/winldr.c | 75 ------------- hal/halx86/acpi/halacpi.c | 4 +- hal/halx86/apic/apicsmp.c | 56 ++++++++- hal/halx86/apic/processor.c | 23 ---- hal/halx86/generic/up.c | 34 ++++++ hal/halx86/include/halp.h | 6 + hal/halx86/include/smp.h | 12 ++ hal/halx86/pic/processor.c | 23 ---- hal/halx86/smp.cmake | 18 ++- hal/halx86/smp/amd64/apentry.S | 34 ++++++ hal/halx86/smp/amd64/spinup.c | 24 ++++ hal/halx86/smp/i386/apentry.S | 144 ++++++++++++++++++++++++ hal/halx86/smp/i386/spinup.c | 121 ++++++++++++++++++++ hal/halx86/smp/ipi.c | 24 ++++ hal/halx86/smp/smp.c | 4 +- hal/halx86/up.cmake | 3 +- ntoskrnl/ex/init.c | 5 + ntoskrnl/include/internal/amd64/ke.h | 7 ++ ntoskrnl/include/internal/i386/intrin_i.h | 76 +++++++++++++ ntoskrnl/include/internal/i386/ke.h | 11 ++ ntoskrnl/include/internal/ke.h | 7 ++ ntoskrnl/ke/amd64/mproc.c | 23 ++++ ntoskrnl/ke/i386/kiinit.c | 14 ++- ntoskrnl/ke/i386/mproc.c | 156 ++++++++++++++++++++++++++ ntoskrnl/ntos.cmake | 8 ++ sdk/include/asm/ksx.template.h | 2 +- sdk/include/ndk/amd64/ketypes.h | 5 + sdk/include/ndk/arm/ketypes.h | 5 + sdk/include/ndk/arm64/ketypes.h | 5 + sdk/include/ndk/i386/ketypes.h | 5 + 30 files changed, 799 insertions(+), 135 deletions(-) diff --git a/boot/freeldr/freeldr/ntldr/arch/i386/winldr.c b/boot/freeldr/freeldr/ntldr/arch/i386/winldr.c index ec91b7313a1..2fccbf9225d 100644 --- a/boot/freeldr/freeldr/ntldr/arch/i386/winldr.c +++ b/boot/freeldr/freeldr/ntldr/arch/i386/winldr.c @@ -64,81 +64,6 @@ typedef struct #define TYPE_CODE (0x10 | DESCRIPTOR_CODE | DESCRIPTOR_EXECUTE_READ) #define TYPE_DATA (0x10 | DESCRIPTOR_READ_WRITE) -FORCEINLINE -PKGDTENTRY -KiGetGdtEntry( - IN PVOID pGdt, - IN USHORT Selector) -{ - return (PKGDTENTRY)((ULONG_PTR)pGdt + (Selector & ~RPL_MASK)); -} - -FORCEINLINE -VOID -KiSetGdtDescriptorBase( - IN OUT PKGDTENTRY Entry, - IN ULONG32 Base) -{ - Entry->BaseLow = (USHORT)(Base & 0xffff); - Entry->HighWord.Bytes.BaseMid = (UCHAR)((Base >> 16) & 0xff); - Entry->HighWord.Bytes.BaseHi = (UCHAR)((Base >> 24) & 0xff); - // Entry->BaseUpper = (ULONG)(Base >> 32); -} - -FORCEINLINE -VOID -KiSetGdtDescriptorLimit( - IN OUT PKGDTENTRY Entry, - IN ULONG Limit) -{ - if (Limit < 0x100000) - { - Entry->HighWord.Bits.Granularity = 0; - } - else - { - Limit >>= 12; - Entry->HighWord.Bits.Granularity = 1; - } - Entry->LimitLow = (USHORT)(Limit & 0xffff); - Entry->HighWord.Bits.LimitHi = ((Limit >> 16) & 0x0f); -} - -VOID -KiSetGdtEntryEx( - IN OUT PKGDTENTRY Entry, - IN ULONG32 Base, - IN ULONG Limit, - IN UCHAR Type, - IN UCHAR Dpl, - IN BOOLEAN Granularity, - IN UCHAR SegMode) // 0: 16-bit, 1: 32-bit, 2: 64-bit -{ - KiSetGdtDescriptorBase(Entry, Base); - KiSetGdtDescriptorLimit(Entry, Limit); - Entry->HighWord.Bits.Type = (Type & 0x1f); - Entry->HighWord.Bits.Dpl = (Dpl & 0x3); - Entry->HighWord.Bits.Pres = (Type != 0); // Present, must be 1 when the GDT entry is valid. - Entry->HighWord.Bits.Sys = 0; // System - Entry->HighWord.Bits.Reserved_0 = 0; // LongMode = !!(SegMode & 1); - Entry->HighWord.Bits.Default_Big = !!(SegMode & 2); - Entry->HighWord.Bits.Granularity |= !!Granularity; // The flag may have been already set by KiSetGdtDescriptorLimit(). - // Entry->MustBeZero = 0; -} - -FORCEINLINE -VOID -KiSetGdtEntry( - IN OUT PKGDTENTRY Entry, - IN ULONG32 Base, - IN ULONG Limit, - IN UCHAR Type, - IN UCHAR Dpl, - IN UCHAR SegMode) // 0: 16-bit, 1: 32-bit, 2: 64-bit -{ - KiSetGdtEntryEx(Entry, Base, Limit, Type, Dpl, FALSE, SegMode); -} - #if 0 VOID DumpGDTEntry(ULONG_PTR Base, ULONG Selector) diff --git a/hal/halx86/acpi/halacpi.c b/hal/halx86/acpi/halacpi.c index d03d57f75f4..0d7b7887112 100644 --- a/hal/halx86/acpi/halacpi.c +++ b/hal/halx86/acpi/halacpi.c @@ -851,12 +851,12 @@ HalpSetupAcpiPhase0(IN PLOADER_PARAMETER_BLOCK LoaderBlock) /* Allocate it */ HalpLowStubPhysicalAddress.QuadPart = HalpAllocPhysicalMemory(LoaderBlock, 0x100000, - 1, + HALP_LOW_STUB_SIZE_IN_PAGES, FALSE); if (HalpLowStubPhysicalAddress.QuadPart) { /* Map it */ - HalpLowStub = HalpMapPhysicalMemory64(HalpLowStubPhysicalAddress, 1); + HalpLowStub = HalpMapPhysicalMemory64(HalpLowStubPhysicalAddress, HALP_LOW_STUB_SIZE_IN_PAGES); } } diff --git a/hal/halx86/apic/apicsmp.c b/hal/halx86/apic/apicsmp.c index 6379922dda9..d8684742268 100644 --- a/hal/halx86/apic/apicsmp.c +++ b/hal/halx86/apic/apicsmp.c @@ -1,18 +1,23 @@ /* * PROJECT: ReactOS HAL * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) - * FILE: hal/halx86/apic/apicsmp.c * PURPOSE: SMP specific APIC code - * PROGRAMMERS: Copyright 2021 Timo Kreuzer (timo.kreuzer(a)reactos.org) + * COPYRIGHT: Copyright 2021 Timo Kreuzer <timo.kreuzer(a)reactos.org> + * Copyright 2023 Justin Miller <justin.miller(a)reactos.org> */ /* INCLUDES *******************************************************************/ #include <hal.h> #include "apicp.h" +#include <smp.h> + #define NDEBUG #include <debug.h> + +extern PPROCESSOR_IDENTITY HalpProcessorIdentity; + /* INTERNAL FUNCTIONS *********************************************************/ /*! @@ -36,7 +41,7 @@ local APIC(s) specified in Destination field. Vector specifies the startup address. APIC_MT_ExtInt - Delivers an external interrupt to the target local - APIC specified in Destination field. + APIC specified in Destination field. \param TriggerMode - The trigger mode of the interrupt. Can be: APIC_TGM_Edge - The interrupt is edge triggered. @@ -62,8 +67,19 @@ ApicRequestGlobalInterrupt( _In_ APIC_TGM TriggerMode, _In_ APIC_DSH DestinationShortHand) { + ULONG Flags; APIC_INTERRUPT_COMMAND_REGISTER Icr; + /* Disable interrupts so that we can change IRR without being interrupted */ + Flags = __readeflags(); + _disable(); + + /* Wait for the APIC to be idle */ + do + { + Icr.Long0 = ApicRead(APIC_ICR0); + } while (Icr.DeliveryStatus); + /* Setup the command register */ Icr.LongLong = 0; Icr.Vector = Vector; @@ -79,18 +95,46 @@ ApicRequestGlobalInterrupt( /* Write the low dword last to send the interrupt */ ApicWrite(APIC_ICR1, Icr.Long1); ApicWrite(APIC_ICR0, Icr.Long0); + + /* Finally, restore the original interrupt state */ + if (Flags & EFLAGS_INTERRUPT_MASK) + { + _enable(); + } } /* SMP SUPPORT FUNCTIONS ******************************************************/ -// Should be called by SMP version of HalRequestIpi VOID NTAPI -HalpRequestIpi(KAFFINITY TargetProcessors) +HalpRequestIpi(_In_ KAFFINITY TargetProcessors) { UNIMPLEMENTED; __debugbreak(); } -// APIC specific SMP code here +VOID +ApicStartApplicationProcessor( + _In_ ULONG NTProcessorNumber, + _In_ PHYSICAL_ADDRESS StartupLoc) +{ + ASSERT(StartupLoc.HighPart == 0); + ASSERT((StartupLoc.QuadPart & 0xFFF) == 0); + ASSERT((StartupLoc.QuadPart & 0xFFF00FFF) == 0); + + /* Init IPI */ + ApicRequestGlobalInterrupt(HalpProcessorIdentity[NTProcessorNumber].LapicId, 0, + APIC_MT_INIT, APIC_TGM_Edge, APIC_DSH_Destination); + + /* De-Assert Init IPI */ + ApicRequestGlobalInterrupt(HalpProcessorIdentity[NTProcessorNumber].LapicId, 0, + APIC_MT_INIT, APIC_TGM_Level, APIC_DSH_Destination); + + /* Stall execution for a bit to give APIC time: MPS Spec - B.4 */ + KeStallExecutionProcessor(200); + + /* Startup IPI */ + ApicRequestGlobalInterrupt(HalpProcessorIdentity[NTProcessorNumber].LapicId, (StartupLoc.LowPart) >> 12, + APIC_MT_Startup, APIC_TGM_Edge, APIC_DSH_Destination); +} diff --git a/hal/halx86/apic/processor.c b/hal/halx86/apic/processor.c index c9f370f7459..412f231b5a5 100644 --- a/hal/halx86/apic/processor.c +++ b/hal/halx86/apic/processor.c @@ -38,18 +38,6 @@ HalAllProcessorsStarted(VOID) return TRUE; } -/* - * @implemented - */ -BOOLEAN -NTAPI -HalStartNextProcessor(IN PLOADER_PARAMETER_BLOCK LoaderBlock, - IN PKPROCESSOR_STATE ProcessorState) -{ - /* Ready to start */ - return FALSE; -} - /* * @implemented */ @@ -62,15 +50,4 @@ HalProcessorIdle(VOID) __halt(); } -/* - * @implemented - */ -VOID -NTAPI -HalRequestIpi(KAFFINITY TargetProcessors) -{ - UNIMPLEMENTED; - __debugbreak(); -} - /* EOF */ diff --git a/hal/halx86/generic/up.c b/hal/halx86/generic/up.c new file mode 100644 index 00000000000..a7162774d89 --- /dev/null +++ b/hal/halx86/generic/up.c @@ -0,0 +1,34 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Core source file for Uniprocessor (UP) alternative functions + * COPYRIGHT: Copyright 2021 Justin Miller <justinmiller100(a)gmail.com> + */ + +/* INCLUDES ******************************************************************/ + +#include <hal.h> + +#define NDEBUG +#include <debug.h> + +/* FUNCTIONS *****************************************************************/ + +VOID +NTAPI +HalRequestIpi( + _In_ KAFFINITY TargetProcessors) +{ + /* This should never be called in UP mode */ + __debugbreak(); +} + +BOOLEAN +NTAPI +HalStartNextProcessor( + _In_ PLOADER_PARAMETER_BLOCK LoaderBlock, + _In_ PKPROCESSOR_STATE ProcessorState) +{ + /* Always return false on UP systems */ + return FALSE; +} diff --git a/hal/halx86/include/halp.h b/hal/halx86/include/halp.h index 9ea22e8c3c5..cc55c15b847 100644 --- a/hal/halx86/include/halp.h +++ b/hal/halx86/include/halp.h @@ -53,6 +53,12 @@ VOID #define IDT_INTERNAL 0x11 #define IDT_DEVICE 0x21 +#ifdef _M_AMD64 +#define HALP_LOW_STUB_SIZE_IN_PAGES 5 +#else +#define HALP_LOW_STUB_SIZE_IN_PAGES 3 +#endif + /* Conversion functions */ #define BCD_INT(bcd) \ (((bcd & 0xF0) >> 4) * 10 + (bcd & 0x0F)) diff --git a/hal/halx86/include/smp.h b/hal/halx86/include/smp.h index 06ec42ec6db..86b1ded5f77 100644 --- a/hal/halx86/include/smp.h +++ b/hal/halx86/include/smp.h @@ -41,3 +41,15 @@ HalpSetupProcessorsTable( VOID HalpPrintApicTables(VOID); + +/* APIC specific functions inside apic/apicsmp.c */ + +VOID +ApicStartApplicationProcessor( + _In_ ULONG NTProcessorNumber, + _In_ PHYSICAL_ADDRESS StartupLoc); + +VOID +NTAPI +HalpRequestIpi( + _In_ KAFFINITY TargetProcessors); diff --git a/hal/halx86/pic/processor.c b/hal/halx86/pic/processor.c index 2ea03b57326..6b38073ee7c 100644 --- a/hal/halx86/pic/processor.c +++ b/hal/halx86/pic/processor.c @@ -38,18 +38,6 @@ HalAllProcessorsStarted(VOID) return TRUE; } -/* - * @implemented - */ -BOOLEAN -NTAPI -HalStartNextProcessor(IN PLOADER_PARAMETER_BLOCK LoaderBlock, - IN PKPROCESSOR_STATE ProcessorState) -{ - /* Ready to start */ - return FALSE; -} - /* * @implemented */ @@ -62,15 +50,4 @@ HalProcessorIdle(VOID) __halt(); } -/* - * @implemented - */ -VOID -NTAPI -HalRequestIpi(KAFFINITY TargetProcessors) -{ - /* Not implemented on UP */ - __debugbreak(); -} - /* EOF */ diff --git a/hal/halx86/smp.cmake b/hal/halx86/smp.cmake index 0f302133835..73d9fe5879e 100644 --- a/hal/halx86/smp.cmake +++ b/hal/halx86/smp.cmake @@ -2,8 +2,22 @@ list(APPEND HAL_SMP_SOURCE generic/buildtype.c generic/spinlock.c + smp/ipi.c smp/smp.c) -add_library(lib_hal_smp OBJECT ${HAL_SMP_SOURCE}) -add_dependencies(lib_hal_smp bugcodes xdk) +if(ARCH STREQUAL "i386") + list(APPEND HAL_SMP_ASM_SOURCE + smp/i386/apentry.S) + list(APPEND HAL_SMP_SOURCE + smp/i386/spinup.c) +elseif(ARCH STREQUAL "amd64") + list(APPEND HAL_SMP_ASM_SOURCE + smp/amd64/apentry.S) + list(APPEND HAL_SMP_SOURCE + smp/amd64/spinup.c) +endif() + +add_asm_files(lib_hal_smp_asm ${HAL_SMP_ASM_SOURCE}) +add_library(lib_hal_smp OBJECT ${HAL_SMP_SOURCE} ${lib_hal_smp_asm}) +add_dependencies(lib_hal_smp bugcodes asm xdk) target_compile_definitions(lib_hal_smp PRIVATE CONFIG_SMP) diff --git a/hal/halx86/smp/amd64/apentry.S b/hal/halx86/smp/amd64/apentry.S new file mode 100644 index 00000000000..2e61d4f7b65 --- /dev/null +++ b/hal/halx86/smp/amd64/apentry.S @@ -0,0 +1,34 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: AMD64 Application Processor (AP) spinup setup + * COPYRIGHT: Copyright 2023 Justin Miller <justin.miller(a)reactos.org> + */ + +#include <asm.inc> + +PUBLIC HalpAPEntry16 +PUBLIC HalpAPEntryData +PUBLIC HalpAPEntry32 +PUBLIC HalpAPEntry16End + +.code +HalpAPEntry16: + cli + + xor ax, ax + mov ds, ax + mov ss, ax + mov fs, ax + mov gs, ax + + hlt + +HalpAPEntry16End: +.long HEX(0) +HalpAPEntry32: +.long HEX(0) +HalpAPEntryData: +.long HEX(0) + +END diff --git a/hal/halx86/smp/amd64/spinup.c b/hal/halx86/smp/amd64/spinup.c new file mode 100644 index 00000000000..fe0173f59b6 --- /dev/null +++ b/hal/halx86/smp/amd64/spinup.c @@ -0,0 +1,24 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: AMD64 Application Processor (AP) spinup setup + * COPYRIGHT: Copyright 2023 Justin Miller <justin.miller(a)reactos.org> + */ + +/* INCLUDES ******************************************************************/ + +#include <hal.h> +#include <smp.h> + +#define NDEBUG +#include <debug.h> + +BOOLEAN +NTAPI +HalStartNextProcessor( + _In_ PLOADER_PARAMETER_BLOCK LoaderBlock, + _In_ PKPROCESSOR_STATE ProcessorState) +{ + //TODO: + return FALSE; +} diff --git a/hal/halx86/smp/i386/apentry.S b/hal/halx86/smp/i386/apentry.S new file mode 100644 index 00000000000..3f1a77d4851 --- /dev/null +++ b/hal/halx86/smp/i386/apentry.S @@ -0,0 +1,144 @@ +/* + * PROJECT: ReactOS HAL + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: i386 Application Processor (AP) spinup setup + * COPYRIGHT: Copyright 2021 Victor Perevertkin <victor.perevertkin(a)reactos.org> + * Copyright 2021-2023 Justin Miller <justin.miller(a)reactos.org> + */ + +#include <asm.inc> +#include <ks386.inc> + +#define ZERO_OFFSET(f) (f - _HalpAPEntry16) +#define PS(f) (f - _HalpAPEntryData) + +PUBLIC _HalpAPEntry16 +PUBLIC _HalpAPEntryData +PUBLIC _HalpAPEntry32 +PUBLIC _HalpAPEntry16End + +.code16 +_HalpAPEntry16: + cli + + /* Calculate the flat base address */ + mov ebp, cs + shl ebp, 4 + + /* Use flat addressing */ + xor eax, eax + mov ds, eax + +#ifdef _USE_ML + data32 lgdt fword ptr cs:[ZERO_OFFSET(Gdtr)] + data32 lidt fword ptr cs:[ZERO_OFFSET(Idtr)] +#else + data32 lgdt cs:[ZERO_OFFSET(Gdtr)] + data32 lidt cs:[ZERO_OFFSET(Idtr)] +#endif + + /* Load temp page table */ + mov eax, cs:[ZERO_OFFSET(PageTableRoot)] + mov cr3, eax + + mov eax, cr0 + or eax, HEX(80000001) /* CR0_PG | CR0_PE */ + mov cr0, eax + +.align 4 + /* Long jump, 32bit address */ + .byte HEX(66) + .byte HEX(EA) +_HalpAPEntryData: +_APEntryJump32Offset: + .long 0 +_APEntryJump32Segment: + .long 8 +SelfPtr: + .long 0 +PageTableRoot: + .long 0 +ProcessorState: + .long 0 +Gdtr_Pad: + .short 0 // Pad +Gdtr: + .short 0 // Limit + .long 0 // Base +Idtr_Pad: + .short 0 // Pad +Idtr: + .short 0 // Limit + .long 0 // Base +_HalpAPEntry16End: +.endcode16 + +.code32 +_HalpAPEntry32: + /* Set the Ring 0 DS/ES/SS Segment */ + mov ax, HEX(10) + mov ds, ax + mov es, ax + mov ss, ax + mov gs, ax + + /* Load ProcessorState pointer */ + mov esi, [ebp + ZERO_OFFSET(ProcessorState)] + + mov eax, [esi + PsContextFrame + CsSegDs] + mov ds, eax + mov eax, [esi + PsContextFrame + CsSegEs] + mov es, eax + mov eax, [esi + PsContextFrame + CsSegSs] + mov ss, eax + mov eax, [esi + PsContextFrame + CsSegFs] + mov fs, eax + mov eax, [esi + PsContextFrame + CsSegGs] + mov gs, eax + + /* Write CR registers with ProcessorState values */ + mov eax, [esi + PsSpecialRegisters + SrCr3] + mov cr3, eax + mov eax, [esi + PsSpecialRegisters + SrCr4] + mov cr4, eax + + /* Load debug registers */ + mov eax, [esi + PsSpecialRegisters + SrKernelDr0] + mov dr0, eax + mov eax, [esi + PsSpecialRegisters + SrKernelDr1] + mov dr1, eax + mov eax, [esi + PsSpecialRegisters + SrKernelDr2] + mov dr2, eax + mov eax, [esi + PsSpecialRegisters + SrKernelDr3] + mov dr3, eax + mov eax, [esi + PsSpecialRegisters + SrKernelDr6] + mov dr6, eax + mov eax, [esi + PsSpecialRegisters + SrKernelDr7] + mov dr7, eax + + /* Load TSS */ + ltr word ptr [esi + PsSpecialRegisters + SrTr] + + /* Load AP Stack */ + mov esp, [esi + PsContextFrame + CsEsp] + + /* Load Eip and push it as a "return" address */ + mov eax, [esi + PsContextFrame + CsEip] + push eax + + /* Load flags */ + mov eax, [esi + PsContextFrame + CsEflags] + sahf + + /* Set up all GP registers */ + xor edi, edi + xor esi, esi + xor ebp, ebp + xor ebx, ebx + xor edx, edx + xor ecx, ecx + xor eax, eax + + /* Jump into the kernel */ + ret +END diff --git a/hal/halx86/smp/i386/spinup.c b/hal/halx86/smp/i386/spinup.c new file mode 100644 index 00000000000..12fbea168cb --- /dev/null +++ b/hal/halx86/smp/i386/spinup.c @@ -0,0 +1,121 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: i386 Application Processor (AP) spinup setup + * COPYRIGHT: Copyright 2021 Victor Perevertkin <victor.perevertkin(a)reactos.org> + * Copyright 2021-2023 Justin Miller <justin.miller(a)reactos.org> + */ + +/* INCLUDES ******************************************************************/ + +#include <hal.h> +#include <smp.h> + +#define NDEBUG +#include <debug.h> + +/* GLOBALS *******************************************************************/ + +extern PPROCESSOR_IDENTITY HalpProcessorIdentity; +extern PHYSICAL_ADDRESS HalpLowStubPhysicalAddress; +extern PVOID HalpLowStub; + +// The data necessary for a boot (stored inside HalpLowStub) +extern PVOID HalpAPEntry16; +extern PVOID HalpAPEntryData; +extern PVOID HalpAPEntry32; +extern PVOID HalpAPEntry16End; +extern HALP_APIC_INFO_TABLE HalpApicInfoTable; + +ULONG HalpStartedProcessorCount = 1; + +#ifndef Add2Ptr +#define Add2Ptr(P,I) ((PVOID)((PUCHAR)(P) + (I))) +#endif +#ifndef PtrOffset +#define PtrOffset(B,O) ((ULONG)((ULONG_PTR)(O) - (ULONG_PTR)(B))) +#endif + +typedef struct _AP_ENTRY_DATA +{ + UINT32 Jump32Offset; + ULONG Jump32Segment; + PVOID SelfPtr; + ULONG PageTableRoot; + PKPROCESSOR_STATE ProcessorState; + KDESCRIPTOR Gdtr; + KDESCRIPTOR Idtr; +} AP_ENTRY_DATA, *PAP_ENTRY_DATA; + +/* FUNCTIONS *****************************************************************/ + +static +ULONG +HalpSetupTemporaryMappings( + _In_ PKPROCESSOR_STATE ProcessorState) +{ + PMMPDE RootPageTable = Add2Ptr(HalpLowStub, PAGE_SIZE); + PMMPDE LowMapPde = Add2Ptr(HalpLowStub, 2 * PAGE_SIZE); + PMMPTE LowStubPte = MiAddressToPte(HalpLowStub); + PHYSICAL_ADDRESS PhysicalAddress; + ULONG StartPti; + + /* Copy current mappings */ + RtlCopyMemory(RootPageTable, MiAddressToPde(NULL), PAGE_SIZE); + + /* Set up low PDE */ + PhysicalAddress = MmGetPhysicalAddress(LowMapPde); + RootPageTable[0].u.Hard.PageFrameNumber = PhysicalAddress.QuadPart >> PAGE_SHIFT; + RootPageTable[0].u.Hard.Valid = 1; + RootPageTable[0].u.Hard.Write = 1; + + /* Copy low stub PTEs */ + StartPti = MiAddressToPteOffset(HalpLowStubPhysicalAddress.QuadPart); + ASSERT(StartPti + HALP_LOW_STUB_SIZE_IN_PAGES < 1024); + for (ULONG i = 0; i < HALP_LOW_STUB_SIZE_IN_PAGES; i++) + { + LowMapPde[StartPti + i] = LowStubPte[i]; + } + + PhysicalAddress = MmGetPhysicalAddress(RootPageTable); + ASSERT(PhysicalAddress.QuadPart < 0x100000000); + return (ULONG)PhysicalAddress.QuadPart; +} + +BOOLEAN +NTAPI +HalStartNextProcessor( + _In_ PLOADER_PARAMETER_BLOCK LoaderBlock, + _In_ PKPROCESSOR_STATE ProcessorState) +{ + if (HalpStartedProcessorCount == HalpApicInfoTable.ProcessorCount) + return FALSE; + + // Initalize the temporary page table + // TODO: clean it up after an AP boots successfully + ULONG initialCr3 = HalpSetupTemporaryMappings(ProcessorState); + if (!initialCr3) + return FALSE; + + // Put the bootstrap code into low memory + RtlCopyMemory(HalpLowStub, &HalpAPEntry16, (ULONG_PTR)&HalpAPEntry16End - (ULONG_PTR)&HalpAPEntry16); + + // Get a pointer to apEntryData + PAP_ENTRY_DATA apEntryData = (PVOID)((ULONG_PTR)HalpLowStub + ((ULONG_PTR)&HalpAPEntryData - (ULONG_PTR)&HalpAPEntry16)); + + *apEntryData = (AP_ENTRY_DATA){ + .Jump32Offset = (ULONG)&HalpAPEntry32, + .Jump32Segment = (ULONG)ProcessorState->ContextFrame.SegCs, + .SelfPtr = (PVOID)apEntryData, + .PageTableRoot = initialCr3, + .ProcessorState = ProcessorState, + .Gdtr = ProcessorState->SpecialRegisters.Gdtr, + .Idtr = ProcessorState->SpecialRegisters.Idtr, + }; + + ApicStartApplicationProcessor(HalpStartedProcessorCount, HalpLowStubPhysicalAddress); + + HalpStartedProcessorCount++; + + return TRUE; +} diff --git a/hal/halx86/smp/ipi.c b/hal/halx86/smp/ipi.c new file mode 100644 index 00000000000..b215508c622 --- /dev/null +++ b/hal/halx86/smp/ipi.c @@ -0,0 +1,24 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Source file for Inter-Processor Interrupts management + * COPYRIGHT: Copyright 2023 Justin Miller <justin.miller(a)reactos.org> + */ + +/* INCLUDES ******************************************************************/ + +#include <hal.h> +#include <smp.h> + +#define NDEBUG +#include <debug.h> + +/* GLOBALS *******************************************************************/ + +VOID +NTAPI +HalRequestIpi( + _In_ KAFFINITY TargetProcessors) +{ + HalpRequestIpi(TargetProcessors); +} diff --git a/hal/halx86/smp/smp.c b/hal/halx86/smp/smp.c index f8e2f9e4cdf..780de6ab53a 100644 --- a/hal/halx86/smp/smp.c +++ b/hal/halx86/smp/smp.c @@ -2,13 +2,15 @@ * PROJECT: ReactOS Kernel * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) * PURPOSE: Core source file for SMP management - * COPYRIGHT: Copyright 2021 Justin Miller <justinmiller100(a)gmail.com> + * COPYRIGHT: Copyright 2021 Victor Perevertkin <victor.perevertkin(a)reactos.org> + * Copyright 2021-2023 Justin Miller <justin.miller(a)reactos.org> */ /* INCLUDES ******************************************************************/ #include <hal.h> #include <smp.h> + #define NDEBUG #include <debug.h> diff --git a/hal/halx86/up.cmake b/hal/halx86/up.cmake index 24b8103cefe..47378b83a01 100644 --- a/hal/halx86/up.cmake +++ b/hal/halx86/up.cmake @@ -1,7 +1,8 @@ list(APPEND HAL_UP_SOURCE generic/buildtype.c - generic/spinlock.c) + generic/spinlock.c + generic/up.c) add_library(lib_hal_up OBJECT ${HAL_UP_SOURCE}) add_dependencies(lib_hal_up bugcodes xdk) diff --git a/ntoskrnl/ex/init.c b/ntoskrnl/ex/init.c index 517661dfd4c..734960a206a 100644 --- a/ntoskrnl/ex/init.c +++ b/ntoskrnl/ex/init.c @@ -1558,6 +1558,11 @@ Phase1InitializationDiscard(IN PVOID Context) KeBootTimeBias = 0; } +#ifdef CONFIG_SMP + /* Start Application Processors */ + KeStartAllProcessors(); +#endif + /* Initialize all processors */ if (!HalAllProcessorsStarted()) KeBugCheck(HAL1_INITIALIZATION_FAILED); diff --git a/ntoskrnl/include/internal/amd64/ke.h b/ntoskrnl/include/internal/amd64/ke.h index 84246690638..b44cffbfd94 100644 --- a/ntoskrnl/include/internal/amd64/ke.h +++ b/ntoskrnl/include/internal/amd64/ke.h @@ -476,6 +476,13 @@ KiSetTrapContext( _In_ PCONTEXT Context, _In_ KPROCESSOR_MODE RequestorMode); +VOID +NTAPI +KiInitializePcr(IN PKIPCR Pcr, + IN ULONG ProcessorNumber, + IN PKTHREAD IdleThread, + IN PVOID DpcStack); + #ifdef __cplusplus } // extern "C" #endif diff --git a/ntoskrnl/include/internal/i386/intrin_i.h b/ntoskrnl/include/internal/i386/intrin_i.h index d937057fd0c..7314c0f021f 100644 --- a/ntoskrnl/include/internal/i386/intrin_i.h +++ b/ntoskrnl/include/internal/i386/intrin_i.h @@ -5,6 +5,82 @@ extern "C" { #endif +FORCEINLINE +PKGDTENTRY +KiGetGdtEntry( + _In_ PVOID pGdt, + _In_ USHORT Selector) +{ + return (PKGDTENTRY)((ULONG_PTR)pGdt + (Selector & ~RPL_MASK)); +} + +FORCEINLINE +VOID +KiSetGdtDescriptorBase( + _Inout_ PKGDTENTRY Entry, + _In_ ULONG32 Base) +{ + Entry->BaseLow = (USHORT)(Base & 0xffff); + Entry->HighWord.Bytes.BaseMid = (UCHAR)((Base >> 16) & 0xff); + Entry->HighWord.Bytes.BaseHi = (UCHAR)((Base >> 24) & 0xff); + // Entry->BaseUpper = (ULONG)(Base >> 32); +} + +FORCEINLINE +VOID +KiSetGdtDescriptorLimit( + _Inout_ PKGDTENTRY Entry, + _In_ ULONG Limit) +{ + if (Limit < 0x100000) + { + Entry->HighWord.Bits.Granularity = 0; + } + else + { + Limit >>= 12; + Entry->HighWord.Bits.Granularity = 1; + } + Entry->LimitLow = (USHORT)(Limit & 0xffff); + Entry->HighWord.Bits.LimitHi = ((Limit >> 16) & 0x0f); +} + +FORCEINLINE +VOID +KiSetGdtEntryEx( + _Inout_ PKGDTENTRY Entry, + _In_ ULONG32 Base, + _In_ ULONG Limit, + _In_ UCHAR Type, + _In_ UCHAR Dpl, + _In_ BOOLEAN Granularity, + _In_ UCHAR SegMode) // 0: 16-bit, 1: 32-bit, 2: 64-bit +{ + KiSetGdtDescriptorBase(Entry, Base); + KiSetGdtDescriptorLimit(Entry, Limit); + Entry->HighWord.Bits.Type = (Type & 0x1f); + Entry->HighWord.Bits.Dpl = (Dpl & 0x3); + Entry->HighWord.Bits.Pres = (Type != 0); // Present, must be 1 when the GDT entry is valid. + Entry->HighWord.Bits.Sys = 0; // System + Entry->HighWord.Bits.Reserved_0 = 0; // LongMode = !!(SegMode & 1); + Entry->HighWord.Bits.Default_Big = !!(SegMode & 2); + Entry->HighWord.Bits.Granularity |= !!Granularity; // The flag may have been already set by KiSetGdtDescriptorLimit(). + // Entry->MustBeZero = 0; +} + +FORCEINLINE +VOID +KiSetGdtEntry( + _Inout_ PKGDTENTRY Entry, + _In_ ULONG32 Base, + _In_ ULONG Limit, + _In_ UCHAR Type, + _In_ UCHAR Dpl, + _In_ UCHAR SegMode) // 0: 16-bit, 1: 32-bit, 2: 64-bit +{ + KiSetGdtEntryEx(Entry, Base, Limit, Type, Dpl, FALSE, SegMode); +} + #if defined(__GNUC__) FORCEINLINE diff --git a/ntoskrnl/include/internal/i386/ke.h b/ntoskrnl/include/internal/i386/ke.h index 30509248a2b..f8ddf1349f8 100644 --- a/ntoskrnl/include/internal/i386/ke.h +++ b/ntoskrnl/include/internal/i386/ke.h @@ -399,6 +399,17 @@ KiRundownThread(IN PKTHREAD Thread) #endif } +CODE_SEG("INIT") +VOID +NTAPI +KiInitializePcr(IN ULONG ProcessorNumber, + IN PKIPCR Pcr, + IN PKIDTENTRY Idt, + IN PKGDTENTRY Gdt, + IN PKTSS Tss, + IN PKTHREAD IdleThread, + IN PVOID DpcStack); + FORCEINLINE VOID Ke386SetGdtEntryBase(PKGDTENTRY GdtEntry, PVOID BaseAddress) diff --git a/ntoskrnl/include/internal/ke.h b/ntoskrnl/include/internal/ke.h index ae255961388..10a352a0981 100644 --- a/ntoskrnl/include/internal/ke.h +++ b/ntoskrnl/include/internal/ke.h @@ -304,6 +304,13 @@ KiCompleteTimer( IN PKSPIN_LOCK_QUEUE LockQueue ); +CODE_SEG("INIT") +VOID +NTAPI +KeStartAllProcessors( + VOID +); + /* gmutex.c ********************************************************************/ VOID diff --git a/ntoskrnl/ke/amd64/mproc.c b/ntoskrnl/ke/amd64/mproc.c new file mode 100644 index 00000000000..d990a859269 --- /dev/null +++ b/ntoskrnl/ke/amd64/mproc.c @@ -0,0 +1,23 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Architecture specific source file to hold multiprocessor functions + * COPYRIGHT: Copyright 2023 Justin Miller <justin.miller(a)reactos.org> + */ + +/* INCLUDES *****************************************************************/ + +#include <ntoskrnl.h> + +#define NDEBUG +#include <debug.h> + +/* FUNCTIONS *****************************************************************/ + +CODE_SEG("INIT") +VOID +NTAPI +KeStartAllProcessors(VOID) +{ + UNIMPLEMENTED; +} diff --git a/ntoskrnl/ke/i386/kiinit.c b/ntoskrnl/ke/i386/kiinit.c index 9699d11b03c..54d902add4b 100644 --- a/ntoskrnl/ke/i386/kiinit.c +++ b/ntoskrnl/ke/i386/kiinit.c @@ -536,7 +536,7 @@ KiInitializeKernel(IN PKPROCESS InitProcess, else { /* FIXME */ - DPRINT1("SMP Boot support not yet present\n"); + DPRINT1("Starting CPU#%u - you are brave\n", Number); } /* Setup the Idle Thread */ @@ -811,6 +811,18 @@ KiSystemStartup(IN PLOADER_PARAMETER_BLOCK LoaderBlock) RtlCopyMemory(&Idt[8], &DoubleFaultEntry, sizeof(KIDTENTRY)); AppCpuInit: + //TODO: We don't setup IPIs yet so freeze other processors here. + if (Cpu) + { + KeMemoryBarrier(); + LoaderBlock->Prcb = 0; + + for (;;) + { + YieldProcessor(); + } + } + /* Loop until we can release the freeze lock */ do { diff --git a/ntoskrnl/ke/i386/mproc.c b/ntoskrnl/ke/i386/mproc.c new file mode 100644 index 00000000000..f469f71df81 --- /dev/null +++ b/ntoskrnl/ke/i386/mproc.c @@ -0,0 +1,156 @@ +/* + * PROJECT: ReactOS Kernel + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Architecture specific source file to hold multiprocessor functions + * COPYRIGHT: Copyright 2023 Justin Miller <justin.miller(a)reactos.org> + * Copyright 2023 Victor Perevertkin <victor.perevertkin(a)reactos.org> + */ + +/* INCLUDES *****************************************************************/ + +#include <ntoskrnl.h> +#define NDEBUG +#include <debug.h> + +typedef struct _APINFO +{ + DECLSPEC_ALIGN(PAGE_SIZE) KIDTENTRY Idt[256]; + DECLSPEC_ALIGN(PAGE_SIZE) KGDTENTRY Gdt[128]; + DECLSPEC_ALIGN(16) UINT8 NMIStackData[DOUBLE_FAULT_STACK_SIZE]; + KIPCR Pcr; + ETHREAD Thread; + KTSS Tss; + KTSS TssDoubleFault; + KTSS TssNMI; +} APINFO, *PAPINFO; + +typedef struct _AP_SETUP_STACK +{ + PVOID ReturnAddr; + PVOID KxLoaderBlock; +} AP_SETUP_STACK, *PAP_SETUP_STACK; // Note: expected layout only for 32-bit x86 + +/* FUNCTIONS *****************************************************************/ + +CODE_SEG("INIT") +VOID +NTAPI +KeStartAllProcessors(VOID) +{ + PVOID KernelStack, DPCStack; + SIZE_T ProcessorCount = 0; + PAPINFO APInfo; + + while (TRUE) + { + ProcessorCount++; + KernelStack = NULL; + DPCStack = NULL; + + // Allocate structures for a new CPU. + APInfo = ExAllocatePoolZero(NonPagedPool, sizeof(APINFO), ' eK'); + if (!APInfo) + break; + ASSERT(ALIGN_DOWN_POINTER_BY(APInfo, PAGE_SIZE) == APInfo); + + KernelStack = MmCreateKernelStack(FALSE, 0); + if (!KernelStack) + break; + + DPCStack = MmCreateKernelStack(FALSE, 0); + if (!DPCStack) + break; + + // Initalize a new PCR for the specific AP + KiInitializePcr(ProcessorCount, + &APInfo->Pcr, + &APInfo->Idt[0], + &APInfo->Gdt[0], + &APInfo->Tss, + (PKTHREAD)&APInfo->Thread, + DPCStack); + + // Prepare descriptor tables + KDESCRIPTOR bspGdt, bspIdt; + __sgdt(&bspGdt.Limit); + __sidt(&bspIdt.Limit); + RtlCopyMemory(&APInfo->Gdt, (PVOID)bspGdt.Base, bspGdt.Limit + 1); + RtlCopyMemory(&APInfo->Idt, (PVOID)bspIdt.Base, bspIdt.Limit + 1); + + KiSetGdtDescriptorBase(KiGetGdtEntry(&APInfo->Gdt, KGDT_R0_PCR), (ULONG_PTR)&APInfo->Pcr); + KiSetGdtDescriptorBase(KiGetGdtEntry(&APInfo->Gdt, KGDT_DF_TSS), (ULONG_PTR)&APInfo->TssDoubleFault); + KiSetGdtDescriptorBase(KiGetGdtEntry(&APInfo->Gdt, KGDT_NMI_TSS), (ULONG_PTR)&APInfo->TssNMI); + + KiSetGdtDescriptorBase(KiGetGdtEntry(&APInfo->Gdt, KGDT_TSS), (ULONG_PTR)&APInfo->Tss); + // Clear TSS Busy flag (aka set the type to "TSS (Available)") + KiGetGdtEntry(&APInfo->Gdt, KGDT_TSS)->HighWord.Bits.Type = 0b1001; + + APInfo->TssDoubleFault.Esp0 = (ULONG_PTR)&APInfo->NMIStackData; + APInfo->TssDoubleFault.Esp = (ULONG_PTR)&APInfo->NMIStackData; + + APInfo->TssNMI.Esp0 = (ULONG_PTR)&APInfo->NMIStackData; + APInfo->TssNMI.Esp = (ULONG_PTR)&APInfo->NMIStackData; + + // Fill the processor state + PKPROCESSOR_STATE ProcessorState = &APInfo->Pcr.Prcb->ProcessorState; + RtlZeroMemory(ProcessorState, sizeof(*ProcessorState)); + + ProcessorState->SpecialRegisters.Cr0 = __readcr0(); + ProcessorState->SpecialRegisters.Cr3 = __readcr3(); + ProcessorState->SpecialRegisters.Cr4 = __readcr4(); + + ProcessorState->ContextFrame.SegCs = KGDT_R0_CODE; + ProcessorState->ContextFrame.SegDs = KGDT_R3_DATA; + ProcessorState->ContextFrame.SegEs = KGDT_R3_DATA; + ProcessorState->ContextFrame.SegSs = KGDT_R0_DATA; + ProcessorState->ContextFrame.SegFs = KGDT_R0_PCR; + + ProcessorState->SpecialRegisters.Gdtr.Base = (ULONG_PTR)APInfo->Gdt; + ProcessorState->SpecialRegisters.Gdtr.Limit = sizeof(APInfo->Gdt) - 1; + ProcessorState->SpecialRegisters.Idtr.Base = (ULONG_PTR)APInfo->Idt; + ProcessorState->SpecialRegisters.Idtr.Limit = sizeof(APInfo->Idt) - 1; + + ProcessorState->SpecialRegisters.Tr = KGDT_TSS; + + ProcessorState->ContextFrame.Esp = (ULONG_PTR)KernelStack; + ProcessorState->ContextFrame.Eip = (ULONG_PTR)KiSystemStartup; + ProcessorState->ContextFrame.EFlags = __readeflags() & ~EFLAGS_INTERRUPT_MASK; + + ProcessorState->ContextFrame.Esp = (ULONG)((ULONG_PTR)ProcessorState->ContextFrame.Esp - sizeof(AP_SETUP_STACK)); + PAP_SETUP_STACK ApStack = (PAP_SETUP_STACK)ProcessorState->ContextFrame.Esp; + ApStack->KxLoaderBlock = KeLoaderBlock; + ApStack->ReturnAddr = NULL; + + // Update the LOADER_PARAMETER_BLOCK structure for the new processor + KeLoaderBlock->KernelStack = (ULONG_PTR)KernelStack; + KeLoaderBlock->Prcb = (ULONG_PTR)&APInfo->Pcr.Prcb; + KeLoaderBlock->Thread = (ULONG_PTR)&APInfo->Pcr.Prcb->IdleThread; + + // Start the CPU + DPRINT("Attempting to Start a CPU with number: %u\n", ProcessorCount); + if (!HalStartNextProcessor(KeLoaderBlock, ProcessorState)) + { + break; + } + + // And wait for it to start + while (KeLoaderBlock->Prcb != 0) + { + //TODO: Add a time out so we don't wait forever + KeMemoryBarrier(); + YieldProcessor(); + } + } + + // The last CPU didn't start - clean the data + ProcessorCount--; + + if (APInfo) + ExFreePoolWithTag(APInfo, ' eK'); + if (KernelStack) + MmDeleteKernelStack(KernelStack, FALSE); + if (DPCStack) + MmDeleteKernelStack(DPCStack, FALSE); + + DPRINT1("KeStartAllProcessors: Sucessful AP startup count is %u\n", ProcessorCount); +} diff --git a/ntoskrnl/ntos.cmake b/ntoskrnl/ntos.cmake index d9328ae3d01..e1adedf9892 100644 --- a/ntoskrnl/ntos.cmake +++ b/ntoskrnl/ntos.cmake @@ -332,6 +332,10 @@ if(ARCH STREQUAL "i386") ${REACTOS_SOURCE_DIR}/ntoskrnl/ps/i386/psldt.c ${REACTOS_SOURCE_DIR}/ntoskrnl/vdm/vdmmain.c ${REACTOS_SOURCE_DIR}/ntoskrnl/vdm/vdmexec.c) + if(BUILD_MP) + list(APPEND SOURCE + ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/i386/mproc.c) + endif() elseif(ARCH STREQUAL "amd64") list(APPEND ASM_SOURCE ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/boot.S @@ -357,6 +361,10 @@ elseif(ARCH STREQUAL "amd64") ${REACTOS_SOURCE_DIR}/ntoskrnl/ps/amd64/psctx.c ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/stubs.c ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/usercall.c) + if(BUILD_MP) + list(APPEND SOURCE + ${REACTOS_SOURCE_DIR}/ntoskrnl/ke/amd64/mproc.c) + endif() elseif(ARCH STREQUAL "arm") list(APPEND ASM_SOURCE ${REACTOS_SOURCE_DIR}/ntoskrnl/ex/arm/ioport.s diff --git a/sdk/include/asm/ksx.template.h b/sdk/include/asm/ksx.template.h index 019232bb439..855320bbafa 100644 --- a/sdk/include/asm/ksx.template.h +++ b/sdk/include/asm/ksx.template.h @@ -285,7 +285,7 @@ HEADER("Stack sizes"), CONSTANT(KERNEL_STACK_SIZE), /// FIXME: Obsolete CONSTANT(KERNEL_LARGE_STACK_SIZE), CONSTANT(KERNEL_LARGE_STACK_COMMIT), -//CONSTANT(DOUBLE_FAULT_STACK_SIZE), +CONSTANT(DOUBLE_FAULT_STACK_SIZE), #ifdef _M_AMD64 CONSTANT(KERNEL_MCA_EXCEPTION_STACK_SIZE), CONSTANT(NMI_STACK_SIZE), diff --git a/sdk/include/ndk/amd64/ketypes.h b/sdk/include/ndk/amd64/ketypes.h index 81219a73f82..d59df0135be 100644 --- a/sdk/include/ndk/amd64/ketypes.h +++ b/sdk/include/ndk/amd64/ketypes.h @@ -91,6 +91,11 @@ Author: //#define KeGetPcr() ((volatile KPCR * const)__readfsdword(0x1C)) //#endif +// +// Double fault stack size +// +#define DOUBLE_FAULT_STACK_SIZE 0x2000 + // // CPU Vendors // diff --git a/sdk/include/ndk/arm/ketypes.h b/sdk/include/ndk/arm/ketypes.h index 5bcac60f7d7..6a29c3b22aa 100644 --- a/sdk/include/ndk/arm/ketypes.h +++ b/sdk/include/ndk/arm/ketypes.h @@ -305,6 +305,11 @@ typedef enum // #define SYNCH_LEVEL DISPATCH_LEVEL +// +// Double fault stack size +// +#define DOUBLE_FAULT_STACK_SIZE 0x3000 + // // Number of pool lookaside lists per pool in the PRCB // diff --git a/sdk/include/ndk/arm64/ketypes.h b/sdk/include/ndk/arm64/ketypes.h index 2536ecc6c74..0a40c32f00f 100644 --- a/sdk/include/ndk/arm64/ketypes.h +++ b/sdk/include/ndk/arm64/ketypes.h @@ -49,6 +49,11 @@ extern "C" { #define MM_HAL_VA_START 0xFFFFFFFFFFC00000ULL #define MM_HAL_VA_END 0xFFFFFFFFFFFFFFFFULL +// +// Double fault stack size +// +#define DOUBLE_FAULT_STACK_SIZE 0x8000 + // // Structure for CPUID info // diff --git a/sdk/include/ndk/i386/ketypes.h b/sdk/include/ndk/i386/ketypes.h index 6eb97d81ba0..4d77e015b02 100644 --- a/sdk/include/ndk/i386/ketypes.h +++ b/sdk/include/ndk/i386/ketypes.h @@ -260,6 +260,11 @@ typedef KIO_ACCESS_MAP *PKIO_ACCESS_MAP; #endif #endif +// +// Double fault stack size +// +#define DOUBLE_FAULT_STACK_SIZE 0x3000 + // // Number of pool lookaside lists per pool in the PRCB //

1 year, 1 month

[reactos] 01/01: [NETCFGX] Use CheckDlgButton/IsDlgButtonChecked instead of BM_GETCHECK/BM_SETCHECK

by Katayama Hirofumi MZ

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9e42809fc1ea712c77dec… commit 9e42809fc1ea712c77dec62d0939700a12da8a8c Author: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> AuthorDate: Mon Nov 20 07:58:58 2023 +0900 Commit: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> CommitDate: Mon Nov 20 07:58:58 2023 +0900 [NETCFGX] Use CheckDlgButton/IsDlgButtonChecked instead of BM_GETCHECK/BM_SETCHECK CORE-19331 --- dll/win32/netcfgx/tcpipconf_notify.c | 92 ++++++++++++++++++------------------ 1 file changed, 46 insertions(+), 46 deletions(-) diff --git a/dll/win32/netcfgx/tcpipconf_notify.c b/dll/win32/netcfgx/tcpipconf_notify.c index 0ad1862a070..264a667805b 100644 --- a/dll/win32/netcfgx/tcpipconf_notify.c +++ b/dll/win32/netcfgx/tcpipconf_notify.c @@ -236,7 +236,7 @@ InitFilterListBox(LPWSTR pData, HWND hwndDlg, HWND hDlgCtrl, UINT AllowButton, U if (!pData || !_wtoi(pData)) { - SendDlgItemMessageW(hwndDlg, AllowButton, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, AllowButton, BST_CHECKED); EnableWindow(GetDlgItem(hwndDlg, AddButton), FALSE); EnableWindow(GetDlgItem(hwndDlg, DelButton), FALSE); return; @@ -257,9 +257,9 @@ InitFilterListBox(LPWSTR pData, HWND hwndDlg, HWND hDlgCtrl, UINT AllowButton, U } if (!iItem) - SendDlgItemMessageW(hwndDlg, AllowButton, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, AllowButton, BST_CHECKED); else - SendDlgItemMessageW(hwndDlg, RestrictButton, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, RestrictButton, BST_CHECKED); } LPWSTR @@ -321,7 +321,7 @@ StoreTcpipFilterSettings( if (!pFilter) return NULL; - if (SendDlgItemMessageW(hwndDlg, IDC_USE_FILTER, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_USE_FILTER) == BST_CHECKED) pFilter->EnableSecurityFilters = TRUE; else pFilter->EnableSecurityFilters = FALSE; @@ -390,7 +390,7 @@ TcpipFilterSettingsDlg( InitFilterListBox(pContext->pCurrentConfig->pFilter->szUDPAllowedPorts, hwndDlg, GetDlgItem(hwndDlg, IDC_UDP_LIST), IDC_UDP_ALLOW_ALL, IDC_UDP_RESTRICT, IDC_UDP_ADD, IDC_UDP_DEL); InitFilterListBox(pContext->pCurrentConfig->pFilter->szRawIPAllowedProtocols, hwndDlg, GetDlgItem(hwndDlg, IDC_IP_LIST), IDC_IP_ALLOW_ALL, IDC_IP_RESTRICT, IDC_IP_ADD, IDC_IP_DEL); if (pContext->pCurrentConfig->pFilter->EnableSecurityFilters) - SendDlgItemMessageW(hwndDlg, IDC_USE_FILTER, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_USE_FILTER, BST_CHECKED); } SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pContext); return TRUE; @@ -400,61 +400,61 @@ TcpipFilterSettingsDlg( switch (LOWORD(wParam)) { case IDC_TCP_ALLOW_ALL: - if (SendDlgItemMessageW(hwndDlg, IDC_TCP_ALLOW_ALL, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_TCP_ALLOW_ALL) == BST_CHECKED) { - SendDlgItemMessageW(hwndDlg, IDC_TCP_RESTRICT, BM_SETCHECK, BST_UNCHECKED, 0); + CheckDlgButton(hwndDlg, IDC_TCP_RESTRICT, BST_UNCHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_TCP_LIST), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_TCP_ADD), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_TCP_DEL), FALSE); } break; case IDC_TCP_RESTRICT: - if (SendDlgItemMessageW(hwndDlg, IDC_TCP_RESTRICT, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_TCP_RESTRICT) == BST_CHECKED) { - SendDlgItemMessageW(hwndDlg, IDC_TCP_ALLOW_ALL, BM_SETCHECK, BST_UNCHECKED, 0); + CheckDlgButton(hwndDlg, IDC_TCP_ALLOW_ALL, BST_UNCHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_TCP_LIST), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_TCP_ADD), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_TCP_DEL), TRUE); } break; case IDC_UDP_ALLOW_ALL: - if (SendDlgItemMessageW(hwndDlg, IDC_UDP_ALLOW_ALL, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_UDP_ALLOW_ALL) == BST_CHECKED) { - SendDlgItemMessageW(hwndDlg, IDC_UDP_RESTRICT, BM_SETCHECK, BST_UNCHECKED, 0); + CheckDlgButton(hwndDlg, IDC_UDP_RESTRICT, BST_UNCHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_UDP_LIST), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_UDP_ADD), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_UDP_DEL), FALSE); } break; case IDC_UDP_RESTRICT: - if (SendDlgItemMessageW(hwndDlg, IDC_UDP_RESTRICT, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_UDP_RESTRICT) == BST_CHECKED) { - SendDlgItemMessageW(hwndDlg, IDC_UDP_ALLOW_ALL, BM_SETCHECK, BST_UNCHECKED, 0); + CheckDlgButton(hwndDlg, IDC_UDP_ALLOW_ALL, BST_UNCHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_UDP_LIST), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_UDP_ADD), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_UDP_DEL), TRUE); } break; case IDC_IP_ALLOW_ALL: - if (SendDlgItemMessageW(hwndDlg, IDC_IP_ALLOW_ALL, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_IP_ALLOW_ALL) == BST_CHECKED) { - SendDlgItemMessageW(hwndDlg, IDC_IP_RESTRICT, BM_SETCHECK, BST_UNCHECKED, 0); + CheckDlgButton(hwndDlg, IDC_IP_RESTRICT, BST_UNCHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_IP_LIST), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_IP_ADD), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_IP_DEL), FALSE); } break; case IDC_IP_RESTRICT: - if (SendDlgItemMessageW(hwndDlg, IDC_IP_RESTRICT, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_IP_RESTRICT) == BST_CHECKED) { - SendDlgItemMessageW(hwndDlg, IDC_IP_ALLOW_ALL, BM_SETCHECK, BST_UNCHECKED, 0); + CheckDlgButton(hwndDlg, IDC_IP_ALLOW_ALL, BST_UNCHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_IP_LIST), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_IP_ADD), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_IP_DEL), TRUE); } break; case IDC_USE_FILTER: - if (SendDlgItemMessageW(hwndDlg, IDC_USE_FILTER, BM_GETCHECK, 0, 0) == BST_UNCHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_USE_FILTER) == BST_UNCHECKED) DisplayError(IDS_DISABLE_FILTER, IDS_TCPIP, MB_OK); break; @@ -744,7 +744,7 @@ TcpipAdvGwDlg( SendDlgItemMessageW(hwndDlg, IDC_OK, WM_SETTEXT, 0, (LPARAM)szBuffer); } EnableWindow(GetDlgItem(hwndDlg, IDC_OK), FALSE); - SendDlgItemMessageW(hwndDlg, IDC_USEMETRIC, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_USEMETRIC, BST_CHECKED); } else { @@ -764,7 +764,7 @@ TcpipAdvGwDlg( } else { - SendDlgItemMessageW(hwndDlg, IDC_USEMETRIC, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_USEMETRIC, BST_CHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_METRIC), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_METRICTXT), FALSE); } @@ -773,7 +773,7 @@ TcpipAdvGwDlg( case WM_COMMAND: if (LOWORD(wParam) == IDC_USEMETRIC) { - if (SendDlgItemMessage(hwndDlg, IDC_USEMETRIC, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_USEMETRIC) == BST_CHECKED) { EnableWindow(GetDlgItem(hwndDlg, IDC_METRIC), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_METRICTXT), FALSE); @@ -802,7 +802,7 @@ TcpipAdvGwDlg( find.flags = LVFI_STRING; find.psz = pGwSettings->szIP; - if (SendDlgItemMessage(hwndDlg, IDC_USEMETRIC, BM_GETCHECK, 0, 0) == BST_UNCHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_USEMETRIC) == BST_UNCHECKED) pGwSettings->Metric = GetDlgItemInt(hwndDlg, IDC_METRIC, NULL, FALSE); else pGwSettings->Metric = 0; @@ -1335,7 +1335,7 @@ TcpipAdvancedIpDlg( case WM_COMMAND: if (LOWORD(wParam) == IDC_AUTOMETRIC) { - if (SendDlgItemMessageW(hwndDlg, IDC_AUTOMETRIC, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_AUTOMETRIC) == BST_CHECKED) EnableWindow(GetDlgItem(hwndDlg, IDC_METRIC), FALSE); else EnableWindow(GetDlgItem(hwndDlg, IDC_METRIC), TRUE); @@ -1588,22 +1588,22 @@ InitializeTcpipAdvancedDNSDlg( return; if (This->pCurrentConfig->pDNS->RegisterAdapterName) - SendDlgItemMessageW(hwndDlg, IDC_REGSUFFIX, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_REGSUFFIX, BST_CHECKED); else EnableWindow(GetDlgItem(hwndDlg, IDC_USESUFFIX), FALSE); if (This->pCurrentConfig->pDNS->RegistrationEnabled) - SendDlgItemMessageW(hwndDlg, IDC_USESUFFIX, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_USESUFFIX, BST_CHECKED); if (This->pCurrentConfig->pDNS->szDomain[0]) SendDlgItemMessageW(hwndDlg, IDC_SUFFIX, WM_SETTEXT, 0, (LPARAM)szBuffer); if (This->pCurrentConfig->pDNS->UseDomainNameDevolution) - SendDlgItemMessageW(hwndDlg, IDC_TOPPRIMSUFFIX, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_TOPPRIMSUFFIX, BST_CHECKED); if (!This->pCurrentConfig->pDNS->szSearchList || (wcslen(This->pCurrentConfig->pDNS->szSearchList) == 0)) { - SendDlgItemMessageW(hwndDlg, IDC_PRIMSUFFIX, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_PRIMSUFFIX, BST_CHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_DNSSUFFIXADD), FALSE); return; @@ -1631,7 +1631,7 @@ InitializeTcpipAdvancedDNSDlg( }while(TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_TOPPRIMSUFFIX), FALSE); - SendDlgItemMessageW(hwndDlg, IDC_SELSUFFIX, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_SELSUFFIX, BST_CHECKED); SendDlgItemMessageW(hwndDlg, IDC_DNSSUFFIXLIST, LB_SETCURSEL, 0, 0); } } @@ -1834,7 +1834,7 @@ TcpipAdvancedDnsDlg( lppsn = (LPPSHNOTIFY) lParam; if (lppsn->hdr.code == PSN_KILLACTIVE) { - if (SendDlgItemMessageW(hwndDlg, IDC_SELSUFFIX, BM_GETCHECK, 0, 0) == BST_CHECKED && + if (IsDlgButtonChecked(hwndDlg, IDC_SELSUFFIX) == BST_CHECKED && SendDlgItemMessageW(hwndDlg, IDC_DNSSUFFIXLIST, LB_GETCOUNT, 0, 0) == 0) { DisplayError(IDS_NO_SUFFIX, IDS_TCPIP, MB_ICONWARNING); @@ -1870,11 +1870,11 @@ TcpipAdvancedDnsDlg( break; StoreDNSSettings(GetDlgItem(hwndDlg, IDC_DNSADDRLIST), This); - if (SendDlgItemMessageW(hwndDlg, IDC_PRIMSUFFIX, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_PRIMSUFFIX) == BST_CHECKED) { CoTaskMemFree(This->pCurrentConfig->pDNS->szSearchList); This->pCurrentConfig->pDNS->szSearchList = NULL; - if (SendDlgItemMessageW(hwndDlg, IDC_TOPPRIMSUFFIX, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_TOPPRIMSUFFIX) == BST_CHECKED) This->pCurrentConfig->pDNS->UseDomainNameDevolution = TRUE; else This->pCurrentConfig->pDNS->UseDomainNameDevolution = FALSE; @@ -1887,10 +1887,10 @@ TcpipAdvancedDnsDlg( This->pCurrentConfig->pDNS->szSearchList = GetListViewEntries(GetDlgItem(hwndDlg, IDC_DNSSUFFIXLIST)); } - if (SendDlgItemMessageW(hwndDlg, IDC_REGSUFFIX, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_REGSUFFIX) == BST_CHECKED) { This->pCurrentConfig->pDNS->RegisterAdapterName = TRUE; - if (SendDlgItemMessageW(hwndDlg, IDC_USESUFFIX, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_USESUFFIX) == BST_CHECKED) This->pCurrentConfig->pDNS->RegistrationEnabled = TRUE; else This->pCurrentConfig->pDNS->RegistrationEnabled = FALSE; @@ -2174,7 +2174,7 @@ StoreTcpipBasicSettings( { DWORD dwIpAddr; - if (SendDlgItemMessageW(hwndDlg, IDC_NODHCP, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_NODHCP) == BST_CHECKED) { This->pCurrentConfig->DhcpEnabled = FALSE; if (SendDlgItemMessageW(hwndDlg, IDC_IPADDR, IPM_GETADDRESS, 0, (LPARAM)&dwIpAddr) != 4) @@ -2246,7 +2246,7 @@ StoreTcpipBasicSettings( } } - if (SendDlgItemMessageW(hwndDlg, IDC_FIXEDDNS, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_FIXEDDNS) == BST_CHECKED) { BOOL bSkip = FALSE; This->pCurrentConfig->AutoconfigActive = FALSE; @@ -2354,7 +2354,7 @@ InitializeTcpipBasicDlgCtrls( if (pCurSettings->DhcpEnabled) { - SendDlgItemMessageW(hwndDlg, IDC_USEDHCP, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_USEDHCP, BST_CHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_IPADDR), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_SUBNETMASK), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_DEFGATEWAY), FALSE); @@ -2362,7 +2362,7 @@ InitializeTcpipBasicDlgCtrls( } else { - SendDlgItemMessageW(hwndDlg, IDC_NODHCP, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_NODHCP, BST_CHECKED); if (pCurSettings->Ip) { @@ -2381,13 +2381,13 @@ InitializeTcpipBasicDlgCtrls( if (pCurSettings->AutoconfigActive) { - SendDlgItemMessageW(hwndDlg, IDC_AUTODNS, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_AUTODNS, BST_CHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_DNS1), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_DNS2), FALSE); } else { - SendDlgItemMessageW(hwndDlg, IDC_FIXEDDNS, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_FIXEDDNS, BST_CHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_DNS1), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_DNS2), TRUE); if (pCurSettings->Ns) @@ -2530,7 +2530,7 @@ TcpipBasicDlg( switch (LOWORD(wParam)) { case IDC_USEDHCP: - if (SendDlgItemMessageW(hwndDlg, IDC_USEDHCP, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_USEDHCP) == BST_CHECKED) { PropSheet_Changed(GetParent(hwndDlg), hwndDlg); SendDlgItemMessageW(hwndDlg, IDC_IPADDR, IPM_CLEARADDRESS, 0, 0); @@ -2544,25 +2544,25 @@ TcpipBasicDlg( } break; case IDC_NODHCP: - if (SendDlgItemMessageW(hwndDlg, IDC_NODHCP, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_NODHCP) == BST_CHECKED) { PropSheet_Changed(GetParent(hwndDlg), hwndDlg); EnableWindow(GetDlgItem(hwndDlg, IDC_IPADDR), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_SUBNETMASK), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_DEFGATEWAY), TRUE); - if (SendDlgItemMessageW(hwndDlg, IDC_AUTODNS, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_AUTODNS) == BST_CHECKED) { - SendDlgItemMessageW(hwndDlg, IDC_AUTODNS, BM_SETCHECK, BST_UNCHECKED, 0); + CheckDlgButton(hwndDlg, IDC_AUTODNS, BST_UNCHECKED); } EnableWindow(GetDlgItem(hwndDlg, IDC_AUTODNS), FALSE); - SendDlgItemMessageW(hwndDlg, IDC_FIXEDDNS, BM_SETCHECK, BST_CHECKED, 0); + CheckDlgButton(hwndDlg, IDC_FIXEDDNS, BST_CHECKED); EnableWindow(GetDlgItem(hwndDlg, IDC_DNS1), TRUE); EnableWindow(GetDlgItem(hwndDlg, IDC_DNS2), TRUE); SendMessageW(GetParent(hwndDlg), PSM_REMOVEPAGE, 1, 0); } break; case IDC_AUTODNS: - if (SendDlgItemMessageW(hwndDlg, IDC_AUTODNS, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_AUTODNS) == BST_CHECKED) { PropSheet_Changed(GetParent(hwndDlg), hwndDlg); SendDlgItemMessageW(hwndDlg, IDC_DNS1, IPM_CLEARADDRESS, 0, 0); @@ -2572,7 +2572,7 @@ TcpipBasicDlg( } break; case IDC_FIXEDDNS: - if (SendDlgItemMessageW(hwndDlg, IDC_FIXEDDNS, BM_GETCHECK, 0, 0) == BST_CHECKED) + if (IsDlgButtonChecked(hwndDlg, IDC_FIXEDDNS) == BST_CHECKED) { PropSheet_Changed(GetParent(hwndDlg), hwndDlg); EnableWindow(GetDlgItem(hwndDlg, IDC_DNS1), TRUE);

1 year, 1 month

[reactos] 15/15: [NTOS:CM] Implement support for alternate registry hives

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f3141fb29ebc26bcf1771… commit f3141fb29ebc26bcf177163edd48ae0408bb381b Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Mon Oct 30 18:07:21 2023 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Sun Nov 19 20:44:29 2023 +0100 [NTOS:CM] Implement support for alternate registry hives Sometimes repairing a broken hive with a hive log does not always guarantee the hive in question has fully recovered. In worst cases it could happen the LOG itself is even corrupt too and that would certainly lead to a total unbootable system. This is most likely if the victim hive is the SYSTEM hive. This can be anyhow solved by the help of a mirror hive, or also called an "alternate hive". Alternate hives serve the purpose as backup hives for primary hives of which there is still a risk that is not worth taking. For now only the SYSTEM hive is granted the right to have a backup alternate hive. === NOTE === Currently the SYSTEM hive can only base upon the alternate SYSTEM.ALT hive, which means the corresponding LOG file never gets updated. When time comes the existing code must be adapted to allow the possibility to use .ALT and .LOG hives simultaneously. --- ntoskrnl/config/cmapi.c | 2 + ntoskrnl/config/cminit.c | 29 ++++++---- ntoskrnl/config/cmsysini.c | 119 ++++++++++++++++++++++++++++++++++++++--- ntoskrnl/include/internal/cm.h | 21 ++++---- sdk/lib/cmlib/cmlib.h | 9 ++++ sdk/lib/cmlib/hivedata.h | 4 +- sdk/lib/cmlib/hiveinit.c | 13 +++++ sdk/lib/cmlib/hivewrt.c | 81 ++++++++++++++++++++++++---- 8 files changed, 239 insertions(+), 39 deletions(-) diff --git a/ntoskrnl/config/cmapi.c b/ntoskrnl/config/cmapi.c index 287caecf245..8e3e3edd69a 100644 --- a/ntoskrnl/config/cmapi.c +++ b/ntoskrnl/config/cmapi.c @@ -2703,6 +2703,7 @@ CmSaveKey(IN PCM_KEY_CONTROL_BLOCK Kcb, NULL, NULL, NULL, + NULL, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES); if (!NT_SUCCESS(Status)) goto Cleanup; @@ -2795,6 +2796,7 @@ CmSaveMergedKeys(IN PCM_KEY_CONTROL_BLOCK HighKcb, NULL, NULL, NULL, + NULL, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES); if (!NT_SUCCESS(Status)) goto done; diff --git a/ntoskrnl/config/cminit.c b/ntoskrnl/config/cminit.c index 3406bfea302..15dc4f0d77c 100644 --- a/ntoskrnl/config/cminit.c +++ b/ntoskrnl/config/cminit.c @@ -16,16 +16,18 @@ NTSTATUS NTAPI -CmpInitializeHive(OUT PCMHIVE *CmHive, - IN ULONG OperationType, - IN ULONG HiveFlags, - IN ULONG FileType, - IN PVOID HiveData OPTIONAL, - IN HANDLE Primary, - IN HANDLE Log, - IN HANDLE External, - IN PCUNICODE_STRING FileName OPTIONAL, - IN ULONG CheckFlags) +CmpInitializeHive( + _Out_ PCMHIVE *CmHive, + _In_ ULONG OperationType, + _In_ ULONG HiveFlags, + _In_ ULONG FileType, + _In_opt_ PVOID HiveData, + _In_ HANDLE Primary, + _In_ HANDLE Log, + _In_ HANDLE External, + _In_ HANDLE Alternate, + _In_opt_ PCUNICODE_STRING FileName, + _In_ ULONG CheckFlags) { PCMHIVE Hive; IO_STATUS_BLOCK IoStatusBlock; @@ -44,13 +46,17 @@ CmpInitializeHive(OUT PCMHIVE *CmHive, * unless this hive is a shared system hive. * - An in-memory initialization without hive data. * - A log hive that is not linked to a correct file type. + * - An alternate hive that is not linked to a correct file type. + * - A lonely alternate hive not backed up with its corresponding primary hive. */ if (((External) && ((Primary) || (Log))) || ((Log) && !(Primary)) || (!(CmpShareSystemHives) && (HiveFlags & HIVE_VOLATILE) && ((Primary) || (External) || (Log))) || ((OperationType == HINIT_MEMORY) && (!HiveData)) || - ((Log) && (FileType != HFILE_TYPE_LOG))) + ((Log) && (FileType != HFILE_TYPE_LOG)) || + ((Alternate) && (FileType != HFILE_TYPE_ALTERNATE)) || + ((Alternate) && !(Primary))) { /* Fail the request */ return STATUS_INVALID_PARAMETER; @@ -140,6 +146,7 @@ CmpInitializeHive(OUT PCMHIVE *CmHive, Hive->FileHandles[HFILE_TYPE_PRIMARY] = Primary; Hive->FileHandles[HFILE_TYPE_LOG] = Log; Hive->FileHandles[HFILE_TYPE_EXTERNAL] = External; + Hive->FileHandles[HFILE_TYPE_ALTERNATE] = Alternate; /* Initailize the guarded mutex */ KeInitializeGuardedMutex(Hive->ViewLock); diff --git a/ntoskrnl/config/cmsysini.c b/ntoskrnl/config/cmsysini.c index d74fffe07da..d28a5b5d20d 100644 --- a/ntoskrnl/config/cmsysini.c +++ b/ntoskrnl/config/cmsysini.c @@ -359,6 +359,7 @@ CmpInitHiveFromFile(IN PCUNICODE_STRING HiveName, FileHandle, LogHandle, NULL, + NULL, HiveName, CheckFlags); if (!NT_SUCCESS(Status)) @@ -906,11 +907,12 @@ CmpInitializeSystemHive(IN PLOADER_PARAMETER_BLOCK LoaderBlock) Status = CmpInitializeHive(&SystemHive, HiveBase ? HINIT_MEMORY : HINIT_CREATE, HIVE_NOLAZYFLUSH, - HFILE_TYPE_LOG, + HFILE_TYPE_ALTERNATE, HiveBase, NULL, NULL, NULL, + NULL, &HiveName, HiveBase ? CM_CHECK_REGISTRY_PURGE_VOLATILES : CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES); if (!NT_SUCCESS(Status)) @@ -1181,6 +1183,76 @@ CmpGetRegistryPath(VOID) return ConfigPath; } +/** + * @brief + * Checks if the primary and alternate backing hive are + * the same, by determining the time stamp of both hives. + * + * @param[in] FileName + * A pointer to a string containing the file name of the + * primary hive. + * + * @param[in] CmMainmHive + * A pointer to a CM hive descriptor associated with the + * primary hive. + * + * @param[in] AlternateHandle + * A handle to a file that represents the alternate hive. + * + * @param[in] Diverged + * A pointer to a boolean value, if both hives are the same + * it returns TRUE. Otherwise it returns FALSE. + */ +static +VOID +CmpHasAlternateHiveDiverged( + _In_ PCUNICODE_STRING FileName, + _In_ PCMHIVE CmMainmHive, + _In_ HANDLE AlternateHandle, + _Out_ PBOOLEAN Diverged) +{ + PHHIVE Hive, AlternateHive; + NTSTATUS Status; + PCMHIVE CmiAlternateHive; + + /* Assume it has not diverged */ + *Diverged = FALSE; + + /* Initialize the SYSTEM alternate hive */ + Status = CmpInitializeHive(&CmiAlternateHive, + HINIT_FILE, + 0, + HFILE_TYPE_PRIMARY, + NULL, + AlternateHandle, + NULL, + NULL, + NULL, + FileName, + CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES); + if (!NT_SUCCESS(Status)) + { + /* Assume it has diverged... */ + DPRINT1("Failed to initialize the alternate hive to check for diversion (Status 0x%lx)\n", Status); + *Diverged = TRUE; + return; + } + + /* + * Check the timestamp of both hives. If they do not match they + * have diverged, the kernel has to synchronize the both hives. + */ + Hive = &CmMainmHive->Hive; + AlternateHive = &CmiAlternateHive->Hive; + if (AlternateHive->BaseBlock->TimeStamp.QuadPart != + Hive->BaseBlock->TimeStamp.QuadPart) + { + *Diverged = TRUE; + } + + CmpDestroyHive(CmiAlternateHive); +} + _Function_class_(KSTART_ROUTINE) VOID NTAPI @@ -1193,9 +1265,10 @@ CmpLoadHiveThread(IN PVOID StartContext) USHORT FileStart; ULONG PrimaryDisposition, SecondaryDisposition, ClusterSize; PCMHIVE CmHive; - HANDLE PrimaryHandle = NULL, LogHandle = NULL; + HANDLE PrimaryHandle = NULL, AlternateHandle = NULL; NTSTATUS Status = STATUS_SUCCESS; PVOID ErrorParameters; + BOOLEAN HasDiverged; PAGED_CODE(); /* Get the hive index, make sure it makes sense */ @@ -1274,18 +1347,18 @@ CmpLoadHiveThread(IN PVOID StartContext) { /* It's now, open the hive file and log */ Status = CmpOpenHiveFiles(&FileName, - L".LOG", + L".ALT", &PrimaryHandle, - &LogHandle, + &AlternateHandle, &PrimaryDisposition, &SecondaryDisposition, TRUE, TRUE, FALSE, &ClusterSize); - if (!(NT_SUCCESS(Status)) || !(LogHandle)) + if (!(NT_SUCCESS(Status)) || !(AlternateHandle)) { - /* Couldn't open the hive or its log file, raise a hard error */ + /* Couldn't open the hive or its alternate file, raise a hard error */ ErrorParameters = &FileName; NtRaiseHardError(STATUS_CANNOT_LOAD_REGISTRY_FILE, 1, @@ -1299,7 +1372,14 @@ CmpLoadHiveThread(IN PVOID StartContext) } /* Save the file handles. This should remove our sync hacks */ - CmHive->FileHandles[HFILE_TYPE_LOG] = LogHandle; + /* + * FIXME: Any hive that relies on the alternate hive for recovery purposes + * will only get an alternate hive. As a result, the LOG file would never + * get synced each time a write is done to the hive. In the future it would + * be best to adapt the code so that a primary hive can use a LOG and ALT + * hives at the same time. + */ + CmHive->FileHandles[HFILE_TYPE_ALTERNATE] = AlternateHandle; CmHive->FileHandles[HFILE_TYPE_PRIMARY] = PrimaryHandle; /* Allow lazy flushing since the handles are there -- remove sync hacks */ @@ -1332,6 +1412,28 @@ CmpLoadHiveThread(IN PVOID StartContext) CmHive->Hive.DirtyCount = CmHive->Hive.DirtyVector.SizeOfBitMap; HvSyncHive((PHHIVE)CmHive); } + else + { + /* + * Check whether the both primary and alternate hives are the same, + * or that the primary or alternate were created for the first time. + * Do a write against the alternate hive in these cases. + */ + CmpHasAlternateHiveDiverged(&FileName, + CmHive, + AlternateHandle, + &HasDiverged); + if (HasDiverged || + PrimaryDisposition == FILE_CREATED || + SecondaryDisposition == FILE_CREATED) + { + if (!HvWriteAlternateHive((PHHIVE)CmHive)) + { + DPRINT1("Failed to write to alternate hive\n"); + goto Exit; + } + } + } /* Finally, set our allocated hive to the same hive we've had */ CmpMachineHiveList[i].CmHive2 = CmHive; @@ -1339,6 +1441,7 @@ CmpLoadHiveThread(IN PVOID StartContext) } } +Exit: /* We're done */ CmpMachineHiveList[i].ThreadFinished = TRUE; @@ -1571,6 +1674,7 @@ CmInitSystem1(VOID) NULL, NULL, NULL, + NULL, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES); if (!NT_SUCCESS(Status)) { @@ -1662,6 +1766,7 @@ CmInitSystem1(VOID) NULL, NULL, NULL, + NULL, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES); if (!NT_SUCCESS(Status)) { diff --git a/ntoskrnl/include/internal/cm.h b/ntoskrnl/include/internal/cm.h index 04869a812bc..7657fc77fb9 100644 --- a/ntoskrnl/include/internal/cm.h +++ b/ntoskrnl/include/internal/cm.h @@ -747,16 +747,17 @@ CmpQueryKeyName( NTSTATUS NTAPI CmpInitializeHive( - OUT PCMHIVE *CmHive, - IN ULONG OperationType, - IN ULONG HiveFlags, - IN ULONG FileType, - IN PVOID HiveData OPTIONAL, - IN HANDLE Primary, - IN HANDLE Log, - IN HANDLE External, - IN PCUNICODE_STRING FileName OPTIONAL, - IN ULONG CheckFlags + _Out_ PCMHIVE *CmHive, + _In_ ULONG OperationType, + _In_ ULONG HiveFlags, + _In_ ULONG FileType, + _In_opt_ PVOID HiveData, + _In_ HANDLE Primary, + _In_ HANDLE Log, + _In_ HANDLE External, + _In_ HANDLE Alternate, + _In_opt_ PCUNICODE_STRING FileName, + _In_ ULONG CheckFlags ); NTSTATUS diff --git a/sdk/lib/cmlib/cmlib.h b/sdk/lib/cmlib/cmlib.h index fc73e5a58ac..aee69f58460 100644 --- a/sdk/lib/cmlib/cmlib.h +++ b/sdk/lib/cmlib/cmlib.h @@ -120,6 +120,10 @@ IN ULONG StartingIndex, IN ULONG NumberToSet); + VOID NTAPI + RtlSetAllBits( + IN PRTL_BITMAP BitMapHeader); + VOID NTAPI RtlClearAllBits( IN PRTL_BITMAP BitMapHeader); @@ -509,6 +513,11 @@ BOOLEAN CMAPI HvWriteHive( PHHIVE RegistryHive); +BOOLEAN +CMAPI +HvWriteAlternateHive( + _In_ PHHIVE RegistryHive); + BOOLEAN CMAPI HvSyncHiveFromRecover( diff --git a/sdk/lib/cmlib/hivedata.h b/sdk/lib/cmlib/hivedata.h index 16f96de6b4f..83c9d53a5cd 100644 --- a/sdk/lib/cmlib/hivedata.h +++ b/sdk/lib/cmlib/hivedata.h @@ -33,7 +33,8 @@ #define HFILE_TYPE_PRIMARY 0 #define HFILE_TYPE_LOG 1 #define HFILE_TYPE_EXTERNAL 2 -#define HFILE_TYPE_MAX 3 +#define HFILE_TYPE_ALTERNATE 3 // Technically a HFILE_TYPE_PRIMARY but for mirror backup hives. ONLY USED for the SYSTEM hive! +#define HFILE_TYPE_MAX 4 // // Hive sizes @@ -334,6 +335,7 @@ typedef struct _HHIVE BOOLEAN ReadOnly; #if (NTDDI_VERSION < NTDDI_VISTA) // NTDDI_LONGHORN BOOLEAN Log; + BOOLEAN Alternate; #endif BOOLEAN DirtyFlag; #if (NTDDI_VERSION >= NTDDI_VISTA) // NTDDI_LONGHORN diff --git a/sdk/lib/cmlib/hiveinit.c b/sdk/lib/cmlib/hiveinit.c index a89a5050c21..d79c9dadad3 100644 --- a/sdk/lib/cmlib/hiveinit.c +++ b/sdk/lib/cmlib/hiveinit.c @@ -441,6 +441,18 @@ HvpInitializeMemoryHive( RtlInitializeBitMap(&Hive->DirtyVector, BitmapBuffer, BitmapSize * 8); RtlClearAllBits(&Hive->DirtyVector); + /* + * Mark the entire hive as dirty. Indeed we understand if we charged up + * the alternate variant of the primary hive (e.g. SYSTEM.ALT) because + * FreeLdr could not load the main SYSTEM hive, due to corruptions, and + * repairing it with a LOG did not help at all. + */ + if (ChunkBase->BootRecover == HBOOT_BOOT_RECOVERED_BY_ALTERNATE_HIVE) + { + RtlSetAllBits(&Hive->DirtyVector); + Hive->DirtyCount = Hive->DirtyVector.SizeOfBitMap; + } + HvpInitFileName(Hive->BaseBlock, FileName); return STATUS_SUCCESS; @@ -1377,6 +1389,7 @@ HvInitialize( Hive->Version = HSYS_MINOR; #if (NTDDI_VERSION < NTDDI_VISTA) Hive->Log = (FileType == HFILE_TYPE_LOG); + Hive->Alternate = (FileType == HFILE_TYPE_ALTERNATE); #endif Hive->HiveFlags = HiveFlags & ~HIVE_NOLAZYFLUSH; diff --git a/sdk/lib/cmlib/hivewrt.c b/sdk/lib/cmlib/hivewrt.c index 4fea5fa70e6..d95e8559196 100644 --- a/sdk/lib/cmlib/hivewrt.c +++ b/sdk/lib/cmlib/hivewrt.c @@ -1,7 +1,7 @@ /* * PROJECT: ReactOS Kernel * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) - * PURPOSE: Configuration Manager Library - Registry Syncing & Hive/Log Writing + * PURPOSE: Configuration Manager Library - Registry Syncing & Hive/Log/Alternate Writing * COPYRIGHT: Copyright 2001 - 2005 Eric Kohl * Copyright 2005 Filip Navara <navaraf(a)reactos.org> * Copyright 2021 Max Korostil @@ -297,16 +297,26 @@ HvpWriteLog( * data to be written to the primary hive, otherwise if * it's set to FALSE then the function writes all the data. * + * @param[in] FileType + * The file type of a registry hive. This can be HFILE_TYPE_PRIMARY + * or HFILE_TYPE_ALTERNATE. + * * @return * Returns TRUE if writing to hive has succeeded, * FALSE otherwise. + * + * @remarks + * The on-disk header metadata of a hive is already written with type + * of HFILE_TYPE_PRIMARY, regardless of what file type the caller submits, + * as an alternate hive is basically a mirror of the primary hive. */ static BOOLEAN CMAPI HvpWriteHive( _In_ PHHIVE RegistryHive, - _In_ BOOLEAN OnlyDirty) + _In_ BOOLEAN OnlyDirty, + _In_ ULONG FileType) { BOOLEAN Success; ULONG FileOffset; @@ -348,7 +358,7 @@ HvpWriteHive( /* Write hive block */ FileOffset = 0; - Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_PRIMARY, + Success = RegistryHive->FileWrite(RegistryHive, FileType, &FileOffset, RegistryHive->BaseBlock, sizeof(HBASE_BLOCK)); if (!Success) @@ -384,7 +394,7 @@ HvpWriteHive( FileOffset = (BlockIndex + 1) * HBLOCK_SIZE; /* Now write this block to primary hive file */ - Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_PRIMARY, + Success = RegistryHive->FileWrite(RegistryHive, FileType, &FileOffset, Block, HBLOCK_SIZE); if (!Success) { @@ -401,7 +411,7 @@ HvpWriteHive( * We wrote all the hive contents to the file, we * must flush the changes to disk now. */ - Success = RegistryHive->FileFlush(RegistryHive, HFILE_TYPE_PRIMARY, NULL, 0); + Success = RegistryHive->FileFlush(RegistryHive, FileType, NULL, 0); if (!Success) { DPRINT1("Failed to flush the primary hive\n"); @@ -420,7 +430,7 @@ HvpWriteHive( /* Write hive block */ FileOffset = 0; - Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_PRIMARY, + Success = RegistryHive->FileWrite(RegistryHive, FileType, &FileOffset, RegistryHive->BaseBlock, sizeof(HBASE_BLOCK)); if (!Success) @@ -430,7 +440,7 @@ HvpWriteHive( } /* Flush the hive immediately */ - Success = RegistryHive->FileFlush(RegistryHive, HFILE_TYPE_PRIMARY, NULL, 0); + Success = RegistryHive->FileFlush(RegistryHive, FileType, NULL, 0); if (!Success) { DPRINT1("Failed to flush the primary hive\n"); @@ -526,7 +536,7 @@ HvSyncHive( } /* Update the primary hive file */ - if (!HvpWriteHive(RegistryHive, TRUE)) + if (!HvpWriteHive(RegistryHive, TRUE, HFILE_TYPE_PRIMARY)) { DPRINT1("Failed to write the primary hive\n"); #if !defined(CMLIB_HOST) && !defined(_BLDR_) @@ -535,6 +545,19 @@ HvSyncHive( return FALSE; } + /* Update the alternate hive file if present */ + if (RegistryHive->Alternate == TRUE) + { + if (!HvpWriteHive(RegistryHive, TRUE, HFILE_TYPE_ALTERNATE)) + { + DPRINT1("Failed to write the alternate hive\n"); +#if !defined(CMLIB_HOST) && !defined(_BLDR_) + IoSetThreadHardErrorMode(HardErrors); +#endif + return FALSE; + } + } + /* Clear dirty bitmap. */ RtlClearAllBits(&RegistryHive->DirtyVector); RegistryHive->DirtyCount = 0; @@ -601,7 +624,7 @@ HvWriteHive( #endif /* Update hive file */ - if (!HvpWriteHive(RegistryHive, FALSE)) + if (!HvpWriteHive(RegistryHive, FALSE, HFILE_TYPE_PRIMARY)) { DPRINT1("Failed to write the hive\n"); return FALSE; @@ -610,6 +633,44 @@ HvWriteHive( return TRUE; } +/** + * @brief + * Writes data to an alternate registry hive. + * An alternate hive is usually backed up by a primary + * hive. This function is tipically used to force write + * data into the alternate hive if both hives no longer match. + * + * @param[in] RegistryHive + * A pointer to a hive descriptor where data + * is to be written into. + * + * @return + * Returns TRUE if hive writing has succeeded, + * FALSE otherwise. + */ +BOOLEAN +CMAPI +HvWriteAlternateHive( + _In_ PHHIVE RegistryHive) +{ + ASSERT(RegistryHive->ReadOnly == FALSE); + ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE); + ASSERT(RegistryHive->Alternate == TRUE); + +#if !defined(_BLDR_) + /* Update hive header modification time */ + KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp); +#endif + + /* Update hive file */ + if (!HvpWriteHive(RegistryHive, FALSE, HFILE_TYPE_ALTERNATE)) + { + DPRINT1("Failed to write the alternate hive\n"); + return FALSE; + } + + return TRUE; +} /** * @brief @@ -634,7 +695,7 @@ HvSyncHiveFromRecover( ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE); /* Call the private API call to do the deed for us */ - return HvpWriteHive(RegistryHive, TRUE); + return HvpWriteHive(RegistryHive, TRUE, HFILE_TYPE_PRIMARY); } /* EOF */

1 year, 1 month

[reactos] 14/15: [CMLIB] Fix the bin during hive initialization from memory if it's corrupt

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=279f8f88644246b95521f… commit 279f8f88644246b95521f2deb7c99badcf726f12 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Thu Nov 9 20:40:23 2023 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Sun Nov 19 20:44:29 2023 +0100 [CMLIB] Fix the bin during hive initialization from memory if it's corrupt As we iterate over the chunk hive data pointer for hive bins that we are going to enlist, we might encounter one or several bins that would get corrupted during a premature abortion of a registry writing operation such as due to a power outage of the system, hardware malfunction, etc. Corruption at the level of hive bins is nasty because they contain actual cell data of registry information such as keys, values etc. Assuming a bin is corrupt in part we can fix it by recovering some of the bin properties that, theoretically, could be fixed -- namely the signature, size and offset. For size and offset we are more or less safe because a bin typically has a size of a block, and the offset is the coordinate index of where a hive bin should lay at. --- sdk/lib/cmlib/hiveinit.c | 28 +++++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/sdk/lib/cmlib/hiveinit.c b/sdk/lib/cmlib/hiveinit.c index 0b03ddf258b..a89a5050c21 100644 --- a/sdk/lib/cmlib/hiveinit.c +++ b/sdk/lib/cmlib/hiveinit.c @@ -368,13 +368,31 @@ HvpInitializeMemoryHive( { Bin = (PHBIN)((ULONG_PTR)ChunkBase + (BlockIndex + 1) * HBLOCK_SIZE); if (Bin->Signature != HV_HBIN_SIGNATURE || - (Bin->Size % HBLOCK_SIZE) != 0) + (Bin->Size % HBLOCK_SIZE) != 0 || + (Bin->FileOffset / HBLOCK_SIZE) != BlockIndex) { - DPRINT1("Invalid bin at BlockIndex %lu, Signature 0x%x, Size 0x%x\n", + /* + * Bin is toast but luckily either the signature, size or offset + * is out of order. For the signature it is obvious what we are going + * to do, for the offset we are re-positioning the bin back to where it + * was and for the size we will set it up to a block size, since technically + * a hive bin is large as a block itself to accommodate cells. + */ + if (!CmIsSelfHealEnabled(FALSE)) + { + DPRINT1("Invalid bin at BlockIndex %lu, Signature 0x%x, Size 0x%x. Self-heal not possible!\n", (unsigned long)BlockIndex, (unsigned)Bin->Signature, (unsigned)Bin->Size); - Hive->Free(Hive->Storage[Stable].BlockList, 0); - Hive->Free(Hive->BaseBlock, Hive->BaseBlockAlloc); - return STATUS_REGISTRY_CORRUPT; + Hive->Free(Hive->Storage[Stable].BlockList, 0); + Hive->Free(Hive->BaseBlock, Hive->BaseBlockAlloc); + return STATUS_REGISTRY_CORRUPT; + } + + /* Fix this bin */ + Bin->Signature = HV_HBIN_SIGNATURE; + Bin->Size = HBLOCK_SIZE; + Bin->FileOffset = BlockIndex * HBLOCK_SIZE; + ChunkBase->BootType |= HBOOT_TYPE_SELF_HEAL; + DPRINT1("Bin at index %lu is corrupt and it has been repaired!\n", (unsigned long)BlockIndex); } NewBin = Hive->Allocate(Bin->Size, TRUE, TAG_CM);

1 year, 1 month

[reactos] 13/15: [NTOS:CM] Flush the dirty data to disk if the SYSTEM hive has been recovered by FreeLdr

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=27917c14ed31ea24cf0a0… commit 27917c14ed31ea24cf0a022200d9afd4e665009b Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sun Oct 29 20:34:54 2023 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Sun Nov 19 20:44:29 2023 +0100 [NTOS:CM] Flush the dirty data to disk if the SYSTEM hive has been recovered by FreeLdr If FreeLdr performed recovery against the SYSTEM hive with a log, all of its data is only present in volatile memory thus dirty. So the kernel is responsible to flush all the data that's been recovered within the SYSTEM hive into the backing storage. --- ntoskrnl/config/cmsysini.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/ntoskrnl/config/cmsysini.c b/ntoskrnl/config/cmsysini.c index f65449d1962..d74fffe07da 100644 --- a/ntoskrnl/config/cmsysini.c +++ b/ntoskrnl/config/cmsysini.c @@ -1324,8 +1324,14 @@ CmpLoadHiveThread(IN PVOID StartContext) //ASSERT(FALSE); //} - /* Another thing we don't support is NTLDR-recovery */ - if (CmHive->Hive.BaseBlock->BootRecover) ASSERT(FALSE); + /* FreeLdr has recovered the hive with a log, we must do a flush */ + if (CmHive->Hive.BaseBlock->BootRecover == HBOOT_BOOT_RECOVERED_BY_HIVE_LOG) + { + DPRINT1("FreeLdr recovered the hive (hive 0x%p)\n", CmHive); + RtlSetAllBits(&CmHive->Hive.DirtyVector); + CmHive->Hive.DirtyCount = CmHive->Hive.DirtyVector.SizeOfBitMap; + HvSyncHive((PHHIVE)CmHive); + } /* Finally, set our allocated hive to the same hive we've had */ CmpMachineHiveList[i].CmHive2 = CmHive;

1 year, 1 month

[reactos] 12/15: [FREELDR][HACK] Temporarily disable registry recovery code for AMD64

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=fa80176a628790d07dce2… commit fa80176a628790d07dce2c6ee238e5c8a94c31c7 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sun Oct 22 21:28:39 2023 +0200 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Sun Nov 19 20:44:28 2023 +0100 [FREELDR][HACK] Temporarily disable registry recovery code for AMD64 The newly implemented code for registry recovery makes the FreeLdr binary to grow in size, to the point that it would BSOD because the PE image is too big. For now we have to temporarily disable any of the newly added code, until either FreeLdr is split into a basic PE bootloader image itself and a "FreeLdrlib" that is used by the PE image to access various bootloader APIs or another proper solution is found. --- boot/freeldr/freeldr/ntldr/registry.c | 22 ++++++++++++++++++++++ sdk/lib/cmlib/hiveinit.c | 22 +++++++++++++++++++++- 2 files changed, 43 insertions(+), 1 deletion(-) diff --git a/boot/freeldr/freeldr/ntldr/registry.c b/boot/freeldr/freeldr/ntldr/registry.c index 0b81b71cf16..73d6f68097e 100644 --- a/boot/freeldr/freeldr/ntldr/registry.c +++ b/boot/freeldr/freeldr/ntldr/registry.c @@ -99,7 +99,14 @@ RegInitializeHive( _In_ BOOLEAN LoadAlternate) { NTSTATUS Status; +/* + * FIXME: Disable compilation of some parts of code for AMD64 for now, + * since it makes the FreeLdr binary size so large that it prevents + * x64 ROS from booting. + */ +#if !defined(_M_AMD64) CM_CHECK_REGISTRY_STATUS CmStatusCode; +#endif /* Initialize the hive */ Status = HvInitialize(GET_HHIVE(CmHive), @@ -121,6 +128,8 @@ RegInitializeHive( return FALSE; } +/* FIXME: See the comment above */ +#if !defined(_M_AMD64) /* Now check the hive and purge volatile data */ CmStatusCode = CmCheckRegistry(CmHive, CM_CHECK_REGISTRY_BOOTLOADER_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE); if (!CM_CHECK_REGISTRY_SUCCESS(CmStatusCode)) @@ -128,10 +137,13 @@ RegInitializeHive( ERR("CmCheckRegistry detected problems with the loaded flat hive (check code %lu)\n", CmStatusCode); return FALSE; } +#endif return TRUE; } +/* FIXME: See the comment above */ +#if !defined(_M_AMD64) /** * @brief * Loads and reads a hive log at specified @@ -406,6 +418,7 @@ RegRecoverDataHive( HiveBaseBlock->CheckSum = HvpHiveHeaderChecksum(HiveBaseBlock); return TRUE; } +#endif /** * @brief @@ -451,6 +464,14 @@ RegImportBinaryHive( CmSystemHive = FrLdrTempAlloc(sizeof(CMHIVE), 'eviH'); Success = RegInitializeHive(CmSystemHive, ChunkBase, LoadAlternate); if (!Success) +/* FIXME: See the comment above */ +#if defined(_M_AMD64) + { + ERR("Corrupted hive %p!\n", ChunkBase); + FrLdrTempFree(CmSystemHive, 'eviH'); + return FALSE; + } +#else { /* Free the buffer and retry again */ FrLdrTempFree(CmSystemHive, 'eviH'); @@ -484,6 +505,7 @@ RegImportBinaryHive( */ ((PHBASE_BLOCK)ChunkBase)->BootRecover = HBOOT_BOOT_RECOVERED_BY_HIVE_LOG; } +#endif /* Save the root key node */ SystemHive = GET_HHIVE(CmSystemHive); diff --git a/sdk/lib/cmlib/hiveinit.c b/sdk/lib/cmlib/hiveinit.c index d4adeb99518..0b03ddf258b 100644 --- a/sdk/lib/cmlib/hiveinit.c +++ b/sdk/lib/cmlib/hiveinit.c @@ -619,6 +619,11 @@ HvpGetHiveHeader( return HiveSuccess; } +/* + * FIXME: Disable compilation for AMD64 for now since it makes + * the FreeLdr binary size so large it makes booting impossible. + */ +#if !defined(_M_AMD64) /** * @brief * Computes the hive space size by querying @@ -960,6 +965,7 @@ HvpRecoverDataFromLog( return HiveSuccess; } +#endif /** * @brief @@ -998,7 +1004,12 @@ HvLoadHive( NTSTATUS Status; BOOLEAN Success; PHBASE_BLOCK BaseBlock = NULL; +/* FIXME: See the comment above (near HvpQueryHiveSize) */ +#if defined(_M_AMD64) + ULONG Result; +#else ULONG Result, Result2; +#endif LARGE_INTEGER TimeStamp; ULONG Offset = 0; PVOID HiveData; @@ -1044,6 +1055,12 @@ HvLoadHive( /* Hive header needs a repair */ case RecoverHeader: +/* FIXME: See the comment above (near HvpQueryHiveSize) */ +#if defined(_M_AMD64) + { + return STATUS_REGISTRY_CORRUPT; + } +#else { /* Check if this hive has a log at hand to begin with */ #if (NTDDI_VERSION < NTDDI_VISTA) @@ -1092,6 +1109,7 @@ HvLoadHive( break; } +#endif } /* Set the boot type */ @@ -1384,6 +1402,8 @@ HvInitialize( return Status; } +/* FIXME: See the comment above (near HvpQueryHiveSize) */ +#if !defined(_M_AMD64) /* * Check if we have recovered this hive. We are responsible to * flush the primary hive back to backing storage afterwards. @@ -1418,7 +1438,7 @@ HvInitialize( */ Status = STATUS_SUCCESS; } - +#endif break; }

1 year, 1 month

[reactos] 11/15: [FREELDR] Implement SYSTEM hive recovery at bootloader level & use CmCheckRegistry for registry validation

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=7983b65e10ec032f0a523… commit 7983b65e10ec032f0a52387da9cb3280dc2b6d3a Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Wed Oct 26 21:36:02 2022 +0200 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Sun Nov 19 20:44:28 2023 +0100 [FREELDR] Implement SYSTEM hive recovery at bootloader level & use CmCheckRegistry for registry validation Validate the SYSTEM hive with CmCheckRegistry and purge volatile data with the same function when initializing a hive descriptor for SYSTEM. Also implement SYSTEM recovery code that takes use of SYSTEM log in case something is fishy with the hive. If hive repair doesn't have fully recovered the SYSTEM hive, FreeLdr will load the alternate variant of the SYSTEM hive, aka SYSTEM.ALT. If FreeLdr repairs the hive with a LOG, it will mark it with HBOOT_BOOT_RECOVERED_BY_HIVE_LOG on BootRecover field of the header. All the recovered data that is present as dirty in memory will have to be flushed by the kernel once it is in charge of the system. Otherwise if the system boot occurred by loading SYSTEM.ALT instead, FreeLdr will mark HBOOT_BOOT_RECOVERED_BY_ALTERNATE_HIVE, the kernel will start recovering the main hive as soon as it does any I/O activity into it. --- boot/freeldr/freeldr/ntldr/registry.c | 413 +++++++++++++++++++++++++++++++- boot/freeldr/freeldr/ntldr/registry.h | 4 +- boot/freeldr/freeldr/ntldr/wlregistry.c | 92 ++++++- 3 files changed, 486 insertions(+), 23 deletions(-) diff --git a/boot/freeldr/freeldr/ntldr/registry.c b/boot/freeldr/freeldr/ntldr/registry.c index adc0f9d075c..0b81b71cf16 100644 --- a/boot/freeldr/freeldr/ntldr/registry.c +++ b/boot/freeldr/freeldr/ntldr/registry.c @@ -2,6 +2,7 @@ * FreeLoader * * Copyright (C) 2014 Timo Kreuzer <timo.kreuzer(a)reactos.org> + * 2022 George Bișoc <george.bisoc(a)reactos.org> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -41,6 +42,8 @@ HKEY CurrentControlSetKey = NULL; #define GET_HHIVE_FROM_HKEY(hKey) GET_HHIVE(CmSystemHive) #define GET_CM_KEY_NODE(hHive, hKey) ((PCM_KEY_NODE)HvGetCell(hHive, HKEY_TO_HCI(hKey))) +#define GET_HBASE_BLOCK(ChunkBase) ((PHBASE_BLOCK)ChunkBase) + PVOID NTAPI CmpAllocate( @@ -62,22 +65,47 @@ CmpFree( FrLdrHeapFree(Ptr, 0); } +/** + * @brief + * Initializes a flat hive descriptor for the + * hive and validates the registry hive. + * Volatile data is purged during this procedure + * for initialization. + * + * @param[in] CmHive + * A pointer to a CM (in-memory) hive descriptor + * containing the hive descriptor to be initialized. + * + * @param[in] ChunkBase + * An arbitrary pointer that points to the registry + * chunk base. This pointer serves as the base block + * containing the hive file header data. + * + * @param[in] LoadAlternate + * If set to TRUE, the function will initialize the + * hive as an alternate hive, otherwise FALSE to initialize + * it as primary. + * + * @return + * Returns TRUE if the hive has been initialized + * and registry data inside the hive is valid, FALSE + * otherwise. + */ +static BOOLEAN -RegImportBinaryHive( +RegInitializeHive( + _In_ PCMHIVE CmHive, _In_ PVOID ChunkBase, - _In_ ULONG ChunkSize) + _In_ BOOLEAN LoadAlternate) { NTSTATUS Status; - PCM_KEY_NODE KeyNode; + CM_CHECK_REGISTRY_STATUS CmStatusCode; - TRACE("RegImportBinaryHive(%p, 0x%lx)\n", ChunkBase, ChunkSize); - - /* Allocate and initialize the hive */ - CmSystemHive = FrLdrTempAlloc(sizeof(CMHIVE), 'eviH'); - Status = HvInitialize(GET_HHIVE(CmSystemHive), + /* Initialize the hive */ + Status = HvInitialize(GET_HHIVE(CmHive), HINIT_FLAT, // HINIT_MEMORY_INPLACE 0, - 0, + LoadAlternate ? HFILE_TYPE_ALTERNATE : HFILE_TYPE_PRIMARY, ChunkBase, CmpAllocate, CmpFree, @@ -89,11 +117,374 @@ RegImportBinaryHive( NULL); if (!NT_SUCCESS(Status)) { - ERR("Corrupted hive %p!\n", ChunkBase); - FrLdrTempFree(CmSystemHive, 'eviH'); + ERR("Failed to initialize the flat hive (Status 0x%lx)\n", Status); + return FALSE; + } + + /* Now check the hive and purge volatile data */ + CmStatusCode = CmCheckRegistry(CmHive, CM_CHECK_REGISTRY_BOOTLOADER_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE); + if (!CM_CHECK_REGISTRY_SUCCESS(CmStatusCode)) + { + ERR("CmCheckRegistry detected problems with the loaded flat hive (check code %lu)\n", CmStatusCode); + return FALSE; + } + + return TRUE; +} + +/** + * @brief + * Loads and reads a hive log at specified + * file offset. + * + * @param[in] DirectoryPath + * A pointer to a string that denotes the directory + * path of the hives and logs location. + * + * @param[in] LogFileOffset + * The file offset of which this function uses to + * seek at specific position during read. + * + * @param[in] LogName + * A pointer to a string that denotes the name of + * the desired hive log (e.g. "SYSTEM"). + * + * @param[out] LogData + * A pointer to the returned hive log data that was + * read. The following data varies depending on the + * specified offset set up by the caller, that is used + * to where to start reading from the hive log. + * + * @return + * Returns TRUE if the hive log was loaded and read + * successfully, FALSE otherwise. + * + * @remarks + * The returned log data pointer to the caller is a + * virtual address. You must use VaToPa that converts + * the address to a physical one in order to actually + * use it! + */ +static +BOOLEAN +RegLoadHiveLog( + _In_ PCSTR DirectoryPath, + _In_ ULONG LogFileOffset, + _In_ PCSTR LogName, + _Out_ PVOID *LogData) +{ + ARC_STATUS Status; + ULONG LogId; + CHAR LogPath[MAX_PATH]; + ULONG LogFileSize; + FILEINFORMATION FileInfo; + LARGE_INTEGER Position; + ULONG BytesRead; + PVOID LogDataVirtual; + PVOID LogDataPhysical; + + /* Build the full path to the hive log */ + RtlStringCbCopyA(LogPath, sizeof(LogPath), DirectoryPath); + RtlStringCbCatA(LogPath, sizeof(LogPath), LogName); + + /* Open the file */ + Status = ArcOpen(LogPath, OpenReadOnly, &LogId); + if (Status != ESUCCESS) + { + ERR("Failed to open %s (ARC code %lu)\n", LogName, Status); + return FALSE; + } + + /* Get the file length */ + Status = ArcGetFileInformation(LogId, &FileInfo); + if (Status != ESUCCESS) + { + ERR("Failed to get file information from %s (ARC code %lu)\n", LogName, Status); + ArcClose(LogId); + return FALSE; + } + + /* Capture the size of the hive log file */ + LogFileSize = FileInfo.EndingAddress.LowPart; + if (LogFileSize == 0) + { + ERR("LogFileSize is 0, %s is corrupt\n", LogName); + ArcClose(LogId); + return FALSE; + } + + /* Allocate memory blocks for our log data */ + LogDataPhysical = MmAllocateMemoryWithType( + MM_SIZE_TO_PAGES(LogFileSize + MM_PAGE_SIZE - 1) << MM_PAGE_SHIFT, + LoaderRegistryData); + if (LogDataPhysical == NULL) + { + ERR("Failed to allocate memory for log data\n"); + ArcClose(LogId); + return FALSE; + } + + /* Convert the address to virtual so that it can be useable */ + LogDataVirtual = PaToVa(LogDataPhysical); + + /* Seek within the log file at desired position */ + Position.QuadPart = LogFileOffset; + Status = ArcSeek(LogId, &Position, SeekAbsolute); + if (Status != ESUCCESS) + { + ERR("Failed to seek at %s (ARC code %lu)\n", LogName, Status); + ArcClose(LogId); + return FALSE; + } + + /* And read the actual data from the log */ + Status = ArcRead(LogId, LogDataPhysical, LogFileSize, &BytesRead); + if (Status != ESUCCESS) + { + ERR("Failed to read %s (ARC code %lu)\n", LogName, Status); + ArcClose(LogId); + return FALSE; + } + + *LogData = LogDataVirtual; + ArcClose(LogId); + return TRUE; +} + +/** + * @brief + * Recovers the header base block of a flat + * registry hive. + * + * @param[in] ChunkBase + * A pointer to the registry hive chunk base of + * which the damaged header block is to be recovered. + * + * @param[in] DirectoryPath + * A pointer to a string that denotes the directory + * path of the hives and logs location. + * + * @param[in] LogName + * A pointer to a string that denotes the name of + * the desired hive log (e.g. "SYSTEM"). + * + * @return + * Returns TRUE if the header base block was successfully + * recovered, FALSE otherwise. + */ +static +BOOLEAN +RegRecoverHeaderHive( + _Inout_ PVOID ChunkBase, + _In_ PCSTR DirectoryPath, + _In_ PCSTR LogName) +{ + BOOLEAN Success; + CHAR FullLogFileName[MAX_PATH]; + PVOID LogData; + PHBASE_BLOCK HiveBaseBlock; + PHBASE_BLOCK LogBaseBlock; + + /* Build the complete path of the hive log */ + RtlStringCbCopyA(FullLogFileName, sizeof(FullLogFileName), LogName); + RtlStringCbCatA(FullLogFileName, sizeof(FullLogFileName), ".LOG"); + Success = RegLoadHiveLog(DirectoryPath, 0, FullLogFileName, &LogData); + if (!Success) + { + ERR("Failed to read the hive log\n"); + return FALSE; + } + + /* Make sure the header from the hive log is actually sane */ + LogData = VaToPa(LogData); + LogBaseBlock = GET_HBASE_BLOCK(LogData); + if (!HvpVerifyHiveHeader(LogBaseBlock, HFILE_TYPE_LOG)) + { + ERR("The hive log has corrupt base block\n"); + return FALSE; + } + + /* Copy the healthy header base block into the primary hive */ + HiveBaseBlock = GET_HBASE_BLOCK(ChunkBase); + WARN("Recovering the hive base block...\n"); + RtlCopyMemory(HiveBaseBlock, + LogBaseBlock, + LogBaseBlock->Cluster * HSECTOR_SIZE); + HiveBaseBlock->Type = HFILE_TYPE_PRIMARY; + return TRUE; +} + +/** + * @brief + * Recovers the corrupt data of a primary flat + * registry hive. + * + * @param[in] ChunkBase + * A pointer to the registry hive chunk base of + * which the damaged hive data is to be replaced + * with healthy data from the corresponding hive log. + * + * @param[in] DirectoryPath + * A pointer to a string that denotes the directory + * path of the hives and logs location. + * + * @param[in] LogName + * A pointer to a string that denotes the name of + * the desired hive log (e.g. "SYSTEM"). + * + * @return + * Returns TRUE if the hive data was successfully + * recovered, FALSE otherwise. + * + * @remarks + * Data recovery of the target hive does not always + * guarantee the primary hive is fully recovered. + * It could happen a block from a hive log is not + * marked dirty (pending to be written to disk) that + * has healthy data therefore the following bad block + * would still remain in corrupt state in the main primary + * hive. In such scenarios an alternate hive must be replayed. + */ +static +BOOLEAN +RegRecoverDataHive( + _Inout_ PVOID ChunkBase, + _In_ PCSTR DirectoryPath, + _In_ PCSTR LogName) +{ + BOOLEAN Success; + ULONG StorageLength; + ULONG BlockIndex, LogIndex; + PUCHAR BlockPtr, BlockDest; + CHAR FullLogFileName[MAX_PATH]; + PVOID LogData; + PUCHAR LogDataPhysical; + PHBASE_BLOCK HiveBaseBlock; + + /* Build the complete path of the hive log */ + RtlStringCbCopyA(FullLogFileName, sizeof(FullLogFileName), LogName); + RtlStringCbCatA(FullLogFileName, sizeof(FullLogFileName), ".LOG"); + Success = RegLoadHiveLog(DirectoryPath, HV_LOG_HEADER_SIZE, FullLogFileName, &LogData); + if (!Success) + { + ERR("Failed to read the hive log\n"); return FALSE; } + /* Make sure the dirty vector signature is there otherwise the hive log is corrupt */ + LogDataPhysical = (PUCHAR)VaToPa(LogData); + if (*((PULONG)LogDataPhysical) != HV_LOG_DIRTY_SIGNATURE) + { + ERR("The hive log dirty signature could not be found\n"); + return FALSE; + } + + /* Copy the dirty data into the primary hive */ + LogIndex = 0; + BlockIndex = 0; + HiveBaseBlock = GET_HBASE_BLOCK(ChunkBase); + StorageLength = HiveBaseBlock->Length / HBLOCK_SIZE; + for (; BlockIndex < StorageLength; ++BlockIndex) + { + /* Skip this block if it's not dirty and go to the next one */ + if (LogDataPhysical[BlockIndex + sizeof(HV_LOG_DIRTY_SIGNATURE)] != HV_LOG_DIRTY_BLOCK) + { + continue; + } + + /* Read the dirty block and copy it at right offsets */ + BlockPtr = (PUCHAR)((ULONG_PTR)LogDataPhysical + 2 * HSECTOR_SIZE + LogIndex * HBLOCK_SIZE); + BlockDest = (PUCHAR)((ULONG_PTR)ChunkBase + (BlockIndex + 1) * HBLOCK_SIZE); + RtlCopyMemory(BlockDest, BlockPtr, HBLOCK_SIZE); + + /* Increment the index in log as we continue further */ + LogIndex++; + } + + /* Fix the secondary sequence of the primary hive and compute a new checksum */ + HiveBaseBlock->Sequence2 = HiveBaseBlock->Sequence1; + HiveBaseBlock->CheckSum = HvpHiveHeaderChecksum(HiveBaseBlock); + return TRUE; +} + +/** + * @brief + * Imports the SYSTEM binary hive from + * the registry base chunk that's been + * provided by the loader block. + * + * @param[in] ChunkBase + * A pointer to the registry base chunk + * that serves for SYSTEM hive initialization. + * + * @param[in] ChunkSize + * The size of the registry base chunk. This + * parameter refers to the actual size of + * the SYSTEM hive. This parameter is currently + * unused. + * + * @param[in] LoadAlternate + * If set to TRUE, the function will initialize the + * hive as an alternate hive, otherwise FALSE to initialize + * it as primary. + * + * @return + * Returns TRUE if hive importing and initialization + * have succeeded, FALSE otherwise. + */ +BOOLEAN +RegImportBinaryHive( + _In_ PVOID ChunkBase, + _In_ ULONG ChunkSize, + _In_ PCSTR SearchPath, + _In_ BOOLEAN LoadAlternate) +{ + BOOLEAN Success; + PCM_KEY_NODE KeyNode; + + TRACE("RegImportBinaryHive(%p, 0x%lx)\n", ChunkBase, ChunkSize); + + /* Assume that we don't need boot recover, unless we have to */ + ((PHBASE_BLOCK)ChunkBase)->BootRecover = HBOOT_NO_BOOT_RECOVER; + + /* Allocate and initialize the hive */ + CmSystemHive = FrLdrTempAlloc(sizeof(CMHIVE), 'eviH'); + Success = RegInitializeHive(CmSystemHive, ChunkBase, LoadAlternate); + if (!Success) + { + /* Free the buffer and retry again */ + FrLdrTempFree(CmSystemHive, 'eviH'); + CmSystemHive = NULL; + + if (!RegRecoverHeaderHive(ChunkBase, SearchPath, "SYSTEM")) + { + ERR("Failed to recover the hive header block\n"); + return FALSE; + } + + if (!RegRecoverDataHive(ChunkBase, SearchPath, "SYSTEM")) + { + ERR("Failed to recover the hive data\n"); + return FALSE; + } + + /* Now retry initializing the hive again */ + CmSystemHive = FrLdrTempAlloc(sizeof(CMHIVE), 'eviH'); + Success = RegInitializeHive(CmSystemHive, ChunkBase, LoadAlternate); + if (!Success) + { + ERR("Corrupted hive (despite recovery) %p\n", ChunkBase); + FrLdrTempFree(CmSystemHive, 'eviH'); + return FALSE; + } + + /* + * Acknowledge the kernel we recovered the SYSTEM hive + * on our side by applying log data. + */ + ((PHBASE_BLOCK)ChunkBase)->BootRecover = HBOOT_BOOT_RECOVERED_BY_HIVE_LOG; + } + /* Save the root key node */ SystemHive = GET_HHIVE(CmSystemHive); SystemRootCell = SystemHive->BaseBlock->RootCell; diff --git a/boot/freeldr/freeldr/ntldr/registry.h b/boot/freeldr/freeldr/ntldr/registry.h index 769d5b7c477..54ecbfd296c 100644 --- a/boot/freeldr/freeldr/ntldr/registry.h +++ b/boot/freeldr/freeldr/ntldr/registry.h @@ -30,7 +30,9 @@ typedef HANDLE HKEY, *PHKEY; BOOLEAN RegImportBinaryHive( _In_ PVOID ChunkBase, - _In_ ULONG ChunkSize); + _In_ ULONG ChunkSize, + _In_ PCSTR SearchPath, + _In_ BOOLEAN LoadAlternate); BOOLEAN RegInitCurrentControlSet( diff --git a/boot/freeldr/freeldr/ntldr/wlregistry.c b/boot/freeldr/freeldr/ntldr/wlregistry.c index cea9c2544db..124dc5fc048 100644 --- a/boot/freeldr/freeldr/ntldr/wlregistry.c +++ b/boot/freeldr/freeldr/ntldr/wlregistry.c @@ -31,14 +31,22 @@ static BOOLEAN WinLdrScanRegistry( IN OUT PLIST_ENTRY BootDriverListHead); +typedef enum _BAD_HIVE_REASON +{ + GoodHive = 1, + CorruptHive, + NoHive, + NoHiveAlloc +} BAD_HIVE_REASON, *PBAD_HIVE_REASON; /* FUNCTIONS **************************************************************/ static BOOLEAN WinLdrLoadSystemHive( - IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock, - IN PCSTR DirectoryPath, - IN PCSTR HiveName) + _Inout_ PLOADER_PARAMETER_BLOCK LoaderBlock, + _In_ PCSTR DirectoryPath, + _In_ PCSTR HiveName, + _Out_ PBAD_HIVE_REASON Reason) { ULONG FileId; CHAR FullHiveName[MAX_PATH]; @@ -49,6 +57,9 @@ WinLdrLoadSystemHive( PVOID HiveDataVirtual; ULONG BytesRead; + /* Do not setup any bad reason for now */ + *Reason = GoodHive; + /* Concatenate path and filename to get the full name */ RtlStringCbCopyA(FullHiveName, sizeof(FullHiveName), DirectoryPath); RtlStringCbCatA(FullHiveName, sizeof(FullHiveName), HiveName); @@ -58,6 +69,7 @@ WinLdrLoadSystemHive( if (Status != ESUCCESS) { WARN("Error while opening '%s', Status: %u\n", FullHiveName, Status); + *Reason = NoHive; return FALSE; } @@ -66,6 +78,7 @@ WinLdrLoadSystemHive( if (Status != ESUCCESS) { WARN("Hive file has 0 size!\n"); + *Reason = CorruptHive; ArcClose(FileId); return FALSE; } @@ -79,6 +92,7 @@ WinLdrLoadSystemHive( if (HiveDataPhysical == NULL) { WARN("Could not alloc memory for hive!\n"); + *Reason = NoHiveAlloc; ArcClose(FileId); return FALSE; } @@ -95,6 +109,7 @@ WinLdrLoadSystemHive( if (Status != ESUCCESS) { WARN("Error while reading '%s', Status: %u\n", FullHiveName, Status); + *Reason = CorruptHive; ArcClose(FileId); return FALSE; } @@ -113,9 +128,12 @@ WinLdrInitSystemHive( IN BOOLEAN Setup) { CHAR SearchPath[1024]; + PVOID ChunkBase; PCSTR HiveName; BOOLEAN Success; + BAD_HIVE_REASON Reason; + /* Load the corresponding text-mode setup system hive or the standard hive */ if (Setup) { RtlStringCbCopyA(SearchPath, sizeof(SearchPath), SystemRoot); @@ -123,31 +141,83 @@ WinLdrInitSystemHive( } else { - // There is a simple logic here: try to load usual hive (system), if it - // fails, then give system.alt a try, and finally try a system.sav - - // FIXME: For now we only try system RtlStringCbCopyA(SearchPath, sizeof(SearchPath), SystemRoot); RtlStringCbCatA(SearchPath, sizeof(SearchPath), "system32\\config\\"); HiveName = "SYSTEM"; } TRACE("WinLdrInitSystemHive: loading hive %s%s\n", SearchPath, HiveName); - Success = WinLdrLoadSystemHive(LoaderBlock, SearchPath, HiveName); + Success = WinLdrLoadSystemHive(LoaderBlock, SearchPath, HiveName, &Reason); if (!Success) { + /* Check whether the SYSTEM hive does not exist or is too corrupt to be read */ + if (Reason == CorruptHive || Reason == NoHive) + { + /* Try loading the alternate hive, the main hive should be recovered later */ + goto LoadAlternateHive; + } + + /* We are failing for other reason, bail out */ UiMessageBox("Could not load %s hive!", HiveName); return FALSE; } /* Import what was loaded */ - Success = RegImportBinaryHive(VaToPa(LoaderBlock->RegistryBase), LoaderBlock->RegistryLength); + Success = RegImportBinaryHive(VaToPa(LoaderBlock->RegistryBase), LoaderBlock->RegistryLength, SearchPath, FALSE); if (!Success) { - UiMessageBox("Importing binary hive failed!"); - return FALSE; + /* + * Importing of the SYSTEM hive failed. The scenarios that would + * have made this possible are the following: + * + * 1. The primary hive is corrupt beyond repair (such as when + * core FS structures are total toast); + * + * 2. Repairing the hive could with a LOG could not recover it + * to the fullest. This is the case when the hive and LOG have + * diverged too much, or are mismatched, or the containing healthy + * data in the LOG was not marked as dirty that could be copied + * into the primary hive; + * + * 3. LOG is bad (e.g. corrupt dirty vector); + * + * 4. LOG does not physically exist on the backing storage. + * + * 5. SYSTEM hive does not physically exist or it is a 0 bytes file + * (the latter case still counts as corruption). + * + * With the hope to boot the system, load the mirror counterpart + * of the main hive, the alternate. The kernel should be able to recover + * the main hive later on as soon as it starts writing to it. + */ +LoadAlternateHive: + HiveName = "SYSTEM.ALT"; + Success = WinLdrLoadSystemHive(LoaderBlock, SearchPath, HiveName, &Reason); + if (!Success) + { + UiMessageBox("Could not load %s hive!", HiveName); + return FALSE; + } + + /* Retry importing it again */ + Success = RegImportBinaryHive(VaToPa(LoaderBlock->RegistryBase), LoaderBlock->RegistryLength, SearchPath, TRUE); + if (!Success) + { + UiMessageBox("Importing binary hive failed!"); + return FALSE; + } + + /* + * Acknowledge the kernel we recovered the SYSTEM hive + * on our side by loading the alternate variant of the hive. + */ + WARN("SYSTEM hive does not exist or is corrupt and SYSTEM.ALT has been loaded!\n"); + ChunkBase = VaToPa(LoaderBlock->RegistryBase); + ((PHBASE_BLOCK)ChunkBase)->BootRecover = HBOOT_BOOT_RECOVERED_BY_ALTERNATE_HIVE; } + // FIXME: Load SYSTEM.SAV if GUI setup installation is still in progress + /* Initialize the 'CurrentControlSet' link */ if (!RegInitCurrentControlSet(FALSE)) {

1 year, 1 month

[reactos] 10/15: [ROSLOAD] Use CmCheckRegistry to purge volatile data

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=cce399e772d30f360f4b8… commit cce399e772d30f360f4b8ed578939adc75eea243 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Wed Oct 26 21:32:46 2022 +0200 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Sun Nov 19 20:44:28 2023 +0100 [ROSLOAD] Use CmCheckRegistry to purge volatile data --- boot/environ/lib/misc/bootreg.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/boot/environ/lib/misc/bootreg.c b/boot/environ/lib/misc/bootreg.c index 0551e4c7884..0a32a73f955 100644 --- a/boot/environ/lib/misc/bootreg.c +++ b/boot/environ/lib/misc/bootreg.c @@ -318,6 +318,7 @@ BiInitializeAndValidateHive ( ) { ULONG HiveSize; + CM_CHECK_REGISTRY_STATUS CmStatusCode; NTSTATUS Status; /* Make sure the hive is at least the size of a base block */ @@ -351,7 +352,12 @@ BiInitializeAndValidateHive ( if (NT_SUCCESS(Status)) { /* Cleanup volatile/old data */ - CmPrepareHive(&Hive->Hive.Hive); // CmCheckRegistry + CmStatusCode = CmCheckRegistry(Hive->Hive, CM_CHECK_REGISTRY_BOOTLOADER_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE); + if (!CM_CHECK_REGISTRY_SUCCESS(CmStatusCode)) + { + return STATUS_REGISTRY_CORRUPT; + } + Status = STATUS_SUCCESS; }

1 year, 1 month

[reactos] 09/15: [SDK][CMLIB] Purge volatile data of registry in a proper way with CmCheckRegistry

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=4db1b0fb6289f79de4499… commit 4db1b0fb6289f79de44991d44e9b772798fa98f1 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Wed Oct 26 21:29:03 2022 +0200 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Sun Nov 19 20:44:28 2023 +0100 [SDK][CMLIB] Purge volatile data of registry in a proper way with CmCheckRegistry Thanks to CmCheckRegistry, the function can perform volatile data purging upon boot which this removes old hacky CmPrepareHive code. This also slightly refactors HvInitialize making it more proper. --- sdk/lib/cmlib/cminit.c | 71 ------------------------------------------------ sdk/lib/cmlib/cmlib.h | 5 ---- sdk/lib/cmlib/hiveinit.c | 7 ----- 3 files changed, 83 deletions(-) diff --git a/sdk/lib/cmlib/cminit.c b/sdk/lib/cmlib/cminit.c index d7c7d208797..f7c5a2f122a 100644 --- a/sdk/lib/cmlib/cminit.c +++ b/sdk/lib/cmlib/cminit.c @@ -69,74 +69,3 @@ CmCreateRootNode( HvReleaseCell(Hive, RootCellIndex); return TRUE; } - -static VOID CMAPI -CmpPrepareKey( - PHHIVE RegistryHive, - PCM_KEY_NODE KeyCell); - -static VOID CMAPI -CmpPrepareIndexOfKeys( - PHHIVE RegistryHive, - PCM_KEY_INDEX IndexCell) -{ - ULONG i; - - if (IndexCell->Signature == CM_KEY_INDEX_ROOT || - IndexCell->Signature == CM_KEY_INDEX_LEAF) - { - for (i = 0; i < IndexCell->Count; i++) - { - PCM_KEY_INDEX SubIndexCell = (PCM_KEY_INDEX)HvGetCell(RegistryHive, IndexCell->List[i]); - if (SubIndexCell->Signature == CM_KEY_NODE_SIGNATURE) - CmpPrepareKey(RegistryHive, (PCM_KEY_NODE)SubIndexCell); - else - CmpPrepareIndexOfKeys(RegistryHive, SubIndexCell); - } - } - else if (IndexCell->Signature == CM_KEY_FAST_LEAF || - IndexCell->Signature == CM_KEY_HASH_LEAF) - { - PCM_KEY_FAST_INDEX HashCell = (PCM_KEY_FAST_INDEX)IndexCell; - for (i = 0; i < HashCell->Count; i++) - { - PCM_KEY_NODE SubKeyCell = (PCM_KEY_NODE)HvGetCell(RegistryHive, HashCell->List[i].Cell); - CmpPrepareKey(RegistryHive, SubKeyCell); - } - } - else - { - DPRINT1("IndexCell->Signature %x\n", IndexCell->Signature); - ASSERT(FALSE); - } -} - -static VOID CMAPI -CmpPrepareKey( - PHHIVE RegistryHive, - PCM_KEY_NODE KeyCell) -{ - PCM_KEY_INDEX IndexCell; - - ASSERT(KeyCell->Signature == CM_KEY_NODE_SIGNATURE); - - KeyCell->SubKeyCounts[Volatile] = 0; - // KeyCell->SubKeyLists[Volatile] = HCELL_NIL; // FIXME! Done only on Windows < XP. - - /* Enumerate and add subkeys */ - if (KeyCell->SubKeyCounts[Stable] > 0) - { - IndexCell = (PCM_KEY_INDEX)HvGetCell(RegistryHive, KeyCell->SubKeyLists[Stable]); - CmpPrepareIndexOfKeys(RegistryHive, IndexCell); - } -} - -VOID CMAPI -CmPrepareHive( - PHHIVE RegistryHive) -{ - PCM_KEY_NODE RootCell; - - RootCell = (PCM_KEY_NODE)HvGetCell(RegistryHive, RegistryHive->BaseBlock->RootCell); - CmpPrepareKey(RegistryHive, RootCell); -} diff --git a/sdk/lib/cmlib/cmlib.h b/sdk/lib/cmlib/cmlib.h index 8a7c13c6f15..fc73e5a58ac 100644 --- a/sdk/lib/cmlib/cmlib.h +++ b/sdk/lib/cmlib/cmlib.h @@ -637,11 +637,6 @@ CmCreateRootNode( PHHIVE Hive, PCWSTR Name); -VOID CMAPI -CmPrepareHive( - PHHIVE RegistryHive); - - /* NT-style Public Cm functions */ // diff --git a/sdk/lib/cmlib/hiveinit.c b/sdk/lib/cmlib/hiveinit.c index 3ec381695ed..d4adeb99518 100644 --- a/sdk/lib/cmlib/hiveinit.c +++ b/sdk/lib/cmlib/hiveinit.c @@ -1443,13 +1443,6 @@ HvInitialize( } } - if (!NT_SUCCESS(Status)) return Status; - - /* HACK: ROS: Init root key cell and prepare the hive */ - // r31253 - // if (OperationType == HINIT_CREATE) CmCreateRootNode(Hive, L""); - if (OperationType != HINIT_CREATE) CmPrepareHive(Hive); - return Status; }

1 year, 1 month

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