Ros-diffs November 2022

ros-diffs@reactos.org

26 participants
175 discussions

[reactos] 05/05: [NTOS:KD64] Implement KdLogDbgPrint() for the WinDbg !dbgprint command.

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ffb05406e6f4a408df857… commit ffb05406e6f4a408df8577c4b3472f0a0972d77e Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Wed Nov 23 23:24:59 2022 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Thu Nov 24 01:18:18 2022 +0100 [NTOS:KD64] Implement KdLogDbgPrint() for the WinDbg !dbgprint command. See this command's documentation: https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/-dbgprint and the section "DbgPrint buffer and the debugger" https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/reading-… for more details. - Loosely implement the function, based on our existing circular printout buffers in kdio.c. - Enable its usage in the KdpPrint() and KdpPrompt() functions. Notice that this function will *only* capture the strings being sent **to** the debugger, and not the strings the debugger itself produce. (This means that we cannot use the KdPrintCircularBuffer as a replacement for our KDBG dmesg one, for example...) How to test: Run ReactOS under WinDbg, and use the !dbgprint command to view the buffer. You can also use the Memory Window, place yourself at the address pointed by KdPrintCircularBuffer and KdPrintWritePointer, and read its contents. What you should observe: Prior notice: The circular buffer in debug builds of ReactOS and Windows is 0x8000 bytes large. In release builds, its size is down to 0x1000. 1- When you start e.g. the 2nd-stage GUI installation of ReactOS, going past the initial "devices installation" and letting it stabilize on the Welcome page, break into WinDbg and run the !dbgprint command. You should notice that the end of its output is weirdly truncated, compared to what has been actually emitted to the debug output. Comparing this with the actual contents of the circular buffer (via Memory Window), shows that the buffer contents is actually correct. 2- Copy all the text that has been output by the !dbgprint command and paste it in an editor; count the number of all characters appearing + newlines (only CR or LF), and observe that this number is "mysteriously" equal to 16384 == 0x4000. 3- Continue running ReactOS installation for a little while, breaking back back into WinDbg and looking at !dbgprint again. Its output seems to be still stopping at the same place as before (but the actual buffer memory contents shows otherwise). Continue running ROS installation, and break into the debugger when ROS is about to restart. You should now observe that the dbgprint buffer rolled over: dd nt!KdPrintRolloverCount shows 1. Carefully analysing the output of !dbgprint, however, you will notice that it looks a bit garbage-y: the first part of the output is actually truncated after 16384 characters, then you get a second part of the buffer showing what ReactOS was printing while shutting down. Then you get again what was shown at the top of the !dbgprint output. (Of course, comparing with the actual contents of the circular buffer in memory shows that its contents are fine...) The reason of these strange observations, is because there is an intrinsic bug in the !dbgprint command implementation (in kdexts.dll). Essentially, it displays the contents of the circular buffer in two single dprintf() calls: one for the "older" (bottom) part of the buffer: [WritePointer, EndOfBuffer] and one for the "newer" (upper) part of the buffer: [CircularBuffer, WritePointer[ . The first aspect of the bug (causing observation 3), is that those two parts are not necessarily NULL-terminated strings (especially after rollover), so for example, displaying the upper part of the buffer, will potentially also display part of the buffer's bottom part. The second aspect of the bug (explaining observations 1 and 2), is due to the implementation of the dprintf() function (callback in dbgenv.dll). There, it uses a fixed-sized buffer of size 0x4000 == 16384 characters. Since the output of the circular buffer is not done by little chunks, but by the two large parts, if any of those are larger than 0x4000 they get truncated on display. (This last observation is confirmed in a completely different context by https://community.osr.com/discussion/112439/dprintf-s-max-string-length .) --- ntoskrnl/include/internal/kd64.h | 13 ++++++ ntoskrnl/kd64/kddata.c | 1 + ntoskrnl/kd64/kdprint.c | 91 +++++++++++++++++++++++++++++++++++++++- 3 files changed, 103 insertions(+), 2 deletions(-) diff --git a/ntoskrnl/include/internal/kd64.h b/ntoskrnl/include/internal/kd64.h index d12d10fde1e..9c8670ab557 100644 --- a/ntoskrnl/include/internal/kd64.h +++ b/ntoskrnl/include/internal/kd64.h @@ -523,6 +523,11 @@ NTAPI KdpPrintString( _In_ PSTRING Output); +VOID +NTAPI +KdLogDbgPrint( + _In_ PSTRING String); + // // Global KD Data // @@ -558,7 +563,15 @@ extern LARGE_INTEGER KdTimerStop, KdTimerStart, KdTimerDifference; extern CHAR KdpMessageBuffer[KDP_MSG_BUFFER_SIZE]; extern CHAR KdpPathBuffer[KDP_MSG_BUFFER_SIZE]; + extern CHAR KdPrintDefaultCircularBuffer[KD_DEFAULT_LOG_BUFFER_SIZE]; +extern PCHAR KdPrintWritePointer; +extern ULONG KdPrintRolloverCount; +extern PCHAR KdPrintCircularBuffer; +extern ULONG KdPrintBufferSize; +extern ULONG KdPrintBufferChanges; +extern KSPIN_LOCK KdpPrintSpinLock; + extern BREAKPOINT_ENTRY KdpBreakpointTable[KD_BREAKPOINT_MAX]; extern KD_BREAKPOINT_TYPE KdpBreakpointInstruction; extern BOOLEAN KdpOweBreakpoint; diff --git a/ntoskrnl/kd64/kddata.c b/ntoskrnl/kd64/kddata.c index 6e99c18d374..7111d287d0a 100644 --- a/ntoskrnl/kd64/kddata.c +++ b/ntoskrnl/kd64/kddata.c @@ -136,6 +136,7 @@ ULONG KdPrintRolloverCount; PCHAR KdPrintCircularBuffer = KdPrintDefaultCircularBuffer; ULONG KdPrintBufferSize = sizeof(KdPrintDefaultCircularBuffer); ULONG KdPrintBufferChanges = 0; +KSPIN_LOCK KdpPrintSpinLock; // // Debug Filter Masks diff --git a/ntoskrnl/kd64/kdprint.c b/ntoskrnl/kd64/kdprint.c index 83e2e2f3840..c6089b534b4 100644 --- a/ntoskrnl/kd64/kdprint.c +++ b/ntoskrnl/kd64/kdprint.c @@ -17,6 +17,93 @@ /* FUNCTIONS *****************************************************************/ +KIRQL +NTAPI +KdpAcquireLock( + _In_ PKSPIN_LOCK SpinLock) +{ + KIRQL OldIrql; + + /* Acquire the spinlock without waiting at raised IRQL */ + while (TRUE) + { + /* Loop until the spinlock becomes available */ + while (!KeTestSpinLock(SpinLock)); + + /* Spinlock is free, raise IRQL to high level */ + KeRaiseIrql(HIGH_LEVEL, &OldIrql); + + /* Try to get the spinlock */ + if (KeTryToAcquireSpinLockAtDpcLevel(SpinLock)) + break; + + /* Someone else got the spinlock, lower IRQL back */ + KeLowerIrql(OldIrql); + } + + return OldIrql; +} + +VOID +NTAPI +KdpReleaseLock( + _In_ PKSPIN_LOCK SpinLock, + _In_ KIRQL OldIrql) +{ + /* Release the spinlock */ + KiReleaseSpinLock(SpinLock); + // KeReleaseSpinLockFromDpcLevel(SpinLock); + + /* Restore the old IRQL */ + KeLowerIrql(OldIrql); +} + +VOID +NTAPI +KdLogDbgPrint( + _In_ PSTRING String) +{ + SIZE_T Length, Remaining; + KIRQL OldIrql; + + /* If the string is empty, bail out */ + if (!String->Buffer || (String->Length == 0)) + return; + + /* If no log buffer available, bail out */ + if (!KdPrintCircularBuffer /*|| (KdPrintBufferSize == 0)*/) + return; + + /* Acquire the log spinlock without waiting at raised IRQL */ + OldIrql = KdpAcquireLock(&KdpPrintSpinLock); + + Length = min(String->Length, KdPrintBufferSize); + Remaining = KdPrintCircularBuffer + KdPrintBufferSize - KdPrintWritePointer; + + if (Length < Remaining) + { + KdpMoveMemory(KdPrintWritePointer, String->Buffer, Length); + KdPrintWritePointer += Length; + } + else + { + KdpMoveMemory(KdPrintWritePointer, String->Buffer, Remaining); + Length -= Remaining; + if (Length > 0) + KdpMoveMemory(KdPrintCircularBuffer, String->Buffer + Remaining, Length); + + KdPrintWritePointer = KdPrintCircularBuffer + Length; + + /* Got a rollover, update count (handle wrapping, must always be >= 1) */ + ++KdPrintRolloverCount; + if (KdPrintRolloverCount == 0) + ++KdPrintRolloverCount; + } + + /* Release the spinlock */ + KdpReleaseLock(&KdpPrintSpinLock, OldIrql); +} + BOOLEAN NTAPI KdpPrintString( @@ -270,7 +357,7 @@ KdpPrompt( ResponseBuffer.MaximumLength = MaximumResponseLength; /* Log the print */ - //KdLogDbgPrint(&PromptBuffer); + KdLogDbgPrint(&PromptBuffer); /* Enter the debugger */ Enable = KdEnterDebugger(TrapFrame, ExceptionFrame); @@ -405,7 +492,7 @@ KdpPrint( OutputString.Length = OutputString.MaximumLength = Length; /* Log the print */ - //KdLogDbgPrint(&OutputString); + KdLogDbgPrint(&OutputString); /* Check for a debugger */ if (KdDebuggerNotPresent)

2 years, 1 month

[reactos] 04/05: [NTOS:KD64] Correctly initialize the KdPrint buffer data in KdDebuggerDataBlock so as to fix the WinDbg !dbgprint command.

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=36335d9ceeed7342b70b6… commit 36335d9ceeed7342b70b6dab7e162cab419a6b76 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Wed Nov 23 18:19:41 2022 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Thu Nov 24 01:18:17 2022 +0100 [NTOS:KD64] Correctly initialize the KdPrint buffer data in KdDebuggerDataBlock so as to fix the WinDbg !dbgprint command. Now, !dbgprint just shows an empty log (since we don't fill it), instead of showing the following error: kd> !dbgprint Can't find DbgPrint buffer --- ntoskrnl/include/internal/kd64.h | 11 ++++++++--- ntoskrnl/kd64/kddata.c | 8 ++++---- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/ntoskrnl/include/internal/kd64.h b/ntoskrnl/include/internal/kd64.h index 8f87c591634..d12d10fde1e 100644 --- a/ntoskrnl/include/internal/kd64.h +++ b/ntoskrnl/include/internal/kd64.h @@ -17,6 +17,11 @@ #define KD_DEFAULT_LOG_BUFFER_SIZE 0x1000 #endif +// +// Default size of the Message and Path buffers +// +#define KDP_MSG_BUFFER_SIZE 0x1000 + // // Maximum supported number of breakpoints // @@ -511,8 +516,7 @@ VOID __cdecl KdpDprintf( _In_ PCHAR Format, - ... -); + ...); BOOLEAN NTAPI @@ -552,7 +556,8 @@ extern BOOLEAN KdpContextSent; extern KSPIN_LOCK KdpDebuggerLock; extern LARGE_INTEGER KdTimerStop, KdTimerStart, KdTimerDifference; -extern CHAR KdpMessageBuffer[0x1000], KdpPathBuffer[0x1000]; +extern CHAR KdpMessageBuffer[KDP_MSG_BUFFER_SIZE]; +extern CHAR KdpPathBuffer[KDP_MSG_BUFFER_SIZE]; extern CHAR KdPrintDefaultCircularBuffer[KD_DEFAULT_LOG_BUFFER_SIZE]; extern BREAKPOINT_ENTRY KdpBreakpointTable[KD_BREAKPOINT_MAX]; extern KD_BREAKPOINT_TYPE KdpBreakpointInstruction; diff --git a/ntoskrnl/kd64/kddata.c b/ntoskrnl/kd64/kddata.c index bd7e038aba6..6e99c18d374 100644 --- a/ntoskrnl/kd64/kddata.c +++ b/ntoskrnl/kd64/kddata.c @@ -124,8 +124,8 @@ LARGE_INTEGER KdTimerStop, KdTimerStart, KdTimerDifference; // // Buffers // -CHAR KdpMessageBuffer[0x1000]; -CHAR KdpPathBuffer[0x1000]; +CHAR KdpMessageBuffer[KDP_MSG_BUFFER_SIZE]; +CHAR KdpPathBuffer[KDP_MSG_BUFFER_SIZE]; // // KdPrint Buffers @@ -593,7 +593,7 @@ KDDEBUGGER_DATA64 KdDebuggerDataBlock = PtrToUL64(&MmSystemRangeStart), PtrToUL64(&MmUserProbeAddress), PtrToUL64(KdPrintDefaultCircularBuffer), - PtrToUL64(KdPrintDefaultCircularBuffer + 1), + PtrToUL64(KdPrintDefaultCircularBuffer + sizeof(KdPrintDefaultCircularBuffer)), PtrToUL64(&KdPrintWritePointer), PtrToUL64(&KdPrintRolloverCount), PtrToUL64(&MmLoadedUserImageList), @@ -636,7 +636,7 @@ KDDEBUGGER_DATA64 KdDebuggerDataBlock = FIELD_OFFSET(KPRCB, ProcessorState.ContextFrame), FIELD_OFFSET(KPRCB, Number), sizeof(ETHREAD), - PtrToUL64(&KdPrintDefaultCircularBuffer), + PtrToUL64(&KdPrintCircularBuffer), PtrToUL64(&KdPrintBufferSize), PtrToUL64(&KeLoaderBlock), sizeof(KPCR),

2 years, 1 month

[reactos] 03/05: [PSDK][NTOS:KD64] Rename GCC_ULONG64 to ULPTR64 to self-document the fact it stores a pointer as a 64-bit quantity. But the underlying GCC stupidity is still there (15 years later).

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=de81021bab39c84dfcc6b… commit de81021bab39c84dfcc6b4ca6896f6eef2219d72 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Wed Nov 23 16:46:35 2022 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Thu Nov 24 01:18:16 2022 +0100 [PSDK][NTOS:KD64] Rename GCC_ULONG64 to ULPTR64 to self-document the fact it stores a pointer as a 64-bit quantity. But the underlying GCC stupidity is still there (15 years later). However, enable it only in 32-bit GCC builds, not in 64-bits nor with MSVC. See commit b9cd3f2d9 (r25845) for some details. GCC is indeed still incapable of casting 32-bit pointers up to 64-bits, when static-initializing arrays (**outside** a function) without emitting the error: "error: initializer element is not constant" (which might somehow indicate it actually tries to generate executable code for casting the pointers, instead of doing it at compile-time). Going down the rabbit hole, other stupidities show up: Our PVOID64 type and the related POINTER_64 (in 32-bit archs), or the PVOID32 and POINTER_32 (in 64-bit archs), are all silently broken in GCC builds, because the pointer size attributes __ptr64 and __ptr32, which are originally MSVC-specific, are defined to nothing in _mingw.h. (And similarly for the __uptr and __sptr sign-extension attributes.) Clang and other sane ompilers has since then implemented those (enabled with -fms-extensions), but not GCC. The closest thing that could exist for GCC is to do: #define __ptr64 __attribute__((mode(DI))) in order to get a 64-bit-sized pointer type with typedef void* __ptr64 PVOID64; but even this does not work, with the error: "error: invalid pointer mode 'DI'" --- ntoskrnl/kd64/kddata.c | 168 ++++++++++++++++++++------------------- sdk/include/psdk/wdbgexts.h | 186 +++++++++++++++++++++++--------------------- 2 files changed, 183 insertions(+), 171 deletions(-) diff --git a/ntoskrnl/kd64/kddata.c b/ntoskrnl/kd64/kddata.c index 40a42fb01ba..bd7e038aba6 100644 --- a/ntoskrnl/kd64/kddata.c +++ b/ntoskrnl/kd64/kddata.c @@ -518,11 +518,17 @@ DBGKD_GET_VERSION64 KdVersionBlock = C_ASSERT(sizeof(KDDEBUGGER_DATA64) >= 0x318); #endif +/* Minimal hackery for GCC, see commit b9cd3f2d9 (r25845) */ +#if defined(__GNUC__) && defined(_M_IX86) +#define PtrToUL64(x) ((ULPTR64)(ULONG_PTR)(x)) +#else +#define PtrToUL64(x) ((ULPTR64)(x)) +#endif KDDEBUGGER_DATA64 KdDebuggerDataBlock = { {{0}}, 0, - {(ULONG_PTR)RtlpBreakWithStatusInstruction}, + PtrToUL64(RtlpBreakWithStatusInstruction), 0, FIELD_OFFSET(KTHREAD, CallbackStack), #if defined(_M_ARM) || defined(_M_AMD64) @@ -533,82 +539,82 @@ KDDEBUGGER_DATA64 KdDebuggerDataBlock = FIELD_OFFSET(KCALLOUT_FRAME, CBSTACK_FRAME_POINTER), #endif FALSE, - {(ULONG_PTR)KiCallUserMode}, - 0, - {(ULONG_PTR)&PsLoadedModuleList}, - {(ULONG_PTR)&PsActiveProcessHead}, - {(ULONG_PTR)&PspCidTable}, - {(ULONG_PTR)&ExpSystemResourcesList}, - {(ULONG_PTR)ExpPagedPoolDescriptor}, - {(ULONG_PTR)&ExpNumberOfPagedPools}, - {(ULONG_PTR)&KeTimeIncrement}, - {(ULONG_PTR)&KeBugcheckCallbackListHead}, - {(ULONG_PTR)KiBugCheckData}, - {(ULONG_PTR)&IopErrorLogListHead}, - {(ULONG_PTR)&ObpRootDirectoryObject}, - {(ULONG_PTR)&ObpTypeObjectType}, - {(ULONG_PTR)&MmSystemCacheStart}, - {(ULONG_PTR)&MmSystemCacheEnd}, - {(ULONG_PTR)&MmSystemCacheWs}, - {(ULONG_PTR)&MmPfnDatabase}, - {(ULONG_PTR)MmSystemPtesStart}, - {(ULONG_PTR)MmSystemPtesEnd}, - {(ULONG_PTR)&MmSubsectionBase}, - {(ULONG_PTR)&MmNumberOfPagingFiles}, - {(ULONG_PTR)&MmLowestPhysicalPage}, - {(ULONG_PTR)&MmHighestPhysicalPage}, - {(ULONG_PTR)&MmNumberOfPhysicalPages}, - {(ULONG_PTR)&MmMaximumNonPagedPoolInBytes}, - {(ULONG_PTR)&MmNonPagedSystemStart}, - {(ULONG_PTR)&MmNonPagedPoolStart}, - {(ULONG_PTR)&MmNonPagedPoolEnd}, - {(ULONG_PTR)&MmPagedPoolStart}, - {(ULONG_PTR)&MmPagedPoolEnd}, - {(ULONG_PTR)&MmPagedPoolInfo}, + PtrToUL64(KiCallUserMode), + 0, + PtrToUL64(&PsLoadedModuleList), + PtrToUL64(&PsActiveProcessHead), + PtrToUL64(&PspCidTable), + PtrToUL64(&ExpSystemResourcesList), + PtrToUL64(ExpPagedPoolDescriptor), + PtrToUL64(&ExpNumberOfPagedPools), + PtrToUL64(&KeTimeIncrement), + PtrToUL64(&KeBugcheckCallbackListHead), + PtrToUL64(KiBugCheckData), + PtrToUL64(&IopErrorLogListHead), + PtrToUL64(&ObpRootDirectoryObject), + PtrToUL64(&ObpTypeObjectType), + PtrToUL64(&MmSystemCacheStart), + PtrToUL64(&MmSystemCacheEnd), + PtrToUL64(&MmSystemCacheWs), + PtrToUL64(&MmPfnDatabase), + PtrToUL64(MmSystemPtesStart), + PtrToUL64(MmSystemPtesEnd), + PtrToUL64(&MmSubsectionBase), + PtrToUL64(&MmNumberOfPagingFiles), + PtrToUL64(&MmLowestPhysicalPage), + PtrToUL64(&MmHighestPhysicalPage), + PtrToUL64(&MmNumberOfPhysicalPages), + PtrToUL64(&MmMaximumNonPagedPoolInBytes), + PtrToUL64(&MmNonPagedSystemStart), + PtrToUL64(&MmNonPagedPoolStart), + PtrToUL64(&MmNonPagedPoolEnd), + PtrToUL64(&MmPagedPoolStart), + PtrToUL64(&MmPagedPoolEnd), + PtrToUL64(&MmPagedPoolInfo), PAGE_SIZE, - {(ULONG_PTR)&MmSizeOfPagedPoolInBytes}, - {(ULONG_PTR)&MmTotalCommitLimit}, - {(ULONG_PTR)&MmTotalCommittedPages}, - {(ULONG_PTR)&MmSharedCommit}, - {(ULONG_PTR)&MmDriverCommit}, - {(ULONG_PTR)&MmProcessCommit}, - {(ULONG_PTR)&MmPagedPoolCommit}, - {0}, - {(ULONG_PTR)&MmZeroedPageListHead}, - {(ULONG_PTR)&MmFreePageListHead}, - {(ULONG_PTR)&MmStandbyPageListHead}, - {(ULONG_PTR)&MmModifiedPageListHead}, - {(ULONG_PTR)&MmModifiedNoWritePageListHead}, - {(ULONG_PTR)&MmAvailablePages}, - {(ULONG_PTR)&MmResidentAvailablePages}, - {(ULONG_PTR)&PoolTrackTable}, - {(ULONG_PTR)&NonPagedPoolDescriptor}, - {(ULONG_PTR)&MmHighestUserAddress}, - {(ULONG_PTR)&MmSystemRangeStart}, - {(ULONG_PTR)&MmUserProbeAddress}, - {(ULONG_PTR)KdPrintDefaultCircularBuffer}, - {(ULONG_PTR)KdPrintDefaultCircularBuffer + 1}, - {(ULONG_PTR)&KdPrintWritePointer}, - {(ULONG_PTR)&KdPrintRolloverCount}, - {(ULONG_PTR)&MmLoadedUserImageList}, - {(ULONG_PTR)&NtBuildLab}, - {0}, - {(ULONG_PTR)KiProcessorBlock}, - {(ULONG_PTR)&MmUnloadedDrivers}, - {(ULONG_PTR)&MmLastUnloadedDrivers}, - {(ULONG_PTR)&MmTriageActionTaken}, - {(ULONG_PTR)&MmSpecialPoolTag}, - {(ULONG_PTR)&KernelVerifier}, - {(ULONG_PTR)&MmVerifierData}, - {(ULONG_PTR)&MmAllocatedNonPagedPool}, - {(ULONG_PTR)&MmPeakCommitment}, - {(ULONG_PTR)&MmtotalCommitLimitMaximum}, - {(ULONG_PTR)&CmNtCSDVersion}, - {(ULONG_PTR)&MmPhysicalMemoryBlock}, - {(ULONG_PTR)&MmSessionBase}, - {(ULONG_PTR)&MmSessionSize}, - {0}, - {0}, + PtrToUL64(&MmSizeOfPagedPoolInBytes), + PtrToUL64(&MmTotalCommitLimit), + PtrToUL64(&MmTotalCommittedPages), + PtrToUL64(&MmSharedCommit), + PtrToUL64(&MmDriverCommit), + PtrToUL64(&MmProcessCommit), + PtrToUL64(&MmPagedPoolCommit), + PtrToUL64(0), + PtrToUL64(&MmZeroedPageListHead), + PtrToUL64(&MmFreePageListHead), + PtrToUL64(&MmStandbyPageListHead), + PtrToUL64(&MmModifiedPageListHead), + PtrToUL64(&MmModifiedNoWritePageListHead), + PtrToUL64(&MmAvailablePages), + PtrToUL64(&MmResidentAvailablePages), + PtrToUL64(&PoolTrackTable), + PtrToUL64(&NonPagedPoolDescriptor), + PtrToUL64(&MmHighestUserAddress), + PtrToUL64(&MmSystemRangeStart), + PtrToUL64(&MmUserProbeAddress), + PtrToUL64(KdPrintDefaultCircularBuffer), + PtrToUL64(KdPrintDefaultCircularBuffer + 1), + PtrToUL64(&KdPrintWritePointer), + PtrToUL64(&KdPrintRolloverCount), + PtrToUL64(&MmLoadedUserImageList), + PtrToUL64(&NtBuildLab), + PtrToUL64(0), + PtrToUL64(KiProcessorBlock), + PtrToUL64(&MmUnloadedDrivers), + PtrToUL64(&MmLastUnloadedDrivers), + PtrToUL64(&MmTriageActionTaken), + PtrToUL64(&MmSpecialPoolTag), + PtrToUL64(&KernelVerifier), + PtrToUL64(&MmVerifierData), + PtrToUL64(&MmAllocatedNonPagedPool), + PtrToUL64(&MmPeakCommitment), + PtrToUL64(&MmtotalCommitLimitMaximum), + PtrToUL64(&CmNtCSDVersion), + PtrToUL64(&MmPhysicalMemoryBlock), + PtrToUL64(&MmSessionBase), + PtrToUL64(&MmSessionSize), + PtrToUL64(0), + PtrToUL64(0), FIELD_OFFSET(KTHREAD, NextProcessor), FIELD_OFFSET(KTHREAD, Teb), FIELD_OFFSET(KTHREAD, KernelStack), @@ -630,9 +636,9 @@ KDDEBUGGER_DATA64 KdDebuggerDataBlock = FIELD_OFFSET(KPRCB, ProcessorState.ContextFrame), FIELD_OFFSET(KPRCB, Number), sizeof(ETHREAD), - {(ULONG_PTR)KdPrintDefaultCircularBuffer}, - {(ULONG_PTR)&KdPrintBufferSize}, - {(ULONG_PTR)&KeLoaderBlock}, + PtrToUL64(&KdPrintDefaultCircularBuffer), + PtrToUL64(&KdPrintBufferSize), + PtrToUL64(&KeLoaderBlock), sizeof(KPCR), KPCR_SELF_PCR_OFFSET, KPCR_CURRENT_PRCB_OFFSET, @@ -693,8 +699,8 @@ KDDEBUGGER_DATA64 KdDebuggerDataBlock = 0, 0, #endif - {(ULONG_PTR)&IopNumTriageDumpDataBlocks}, - {(ULONG_PTR)IopTriageDumpDataBlocks}, + PtrToUL64(&IopNumTriageDumpDataBlocks), + PtrToUL64(IopTriageDumpDataBlocks), #if (NTDDI_VERSION >= NTDDI_LONGHORN) #error KdDebuggerDataBlock requires other fields for this NT version! diff --git a/sdk/include/psdk/wdbgexts.h b/sdk/include/psdk/wdbgexts.h index 9664ec201be..d682814a7dc 100644 --- a/sdk/include/psdk/wdbgexts.h +++ b/sdk/include/psdk/wdbgexts.h @@ -174,110 +174,116 @@ typedef struct _DBGKD_DEBUG_DATA_HEADER64 ULONG Size; } DBGKD_DEBUG_DATA_HEADER64, *PDBGKD_DEBUG_DATA_HEADER64; -typedef union _GCC_ULONG64 +/* Self-documenting type: stores a pointer as a 64-bit quantity */ +#if defined(__GNUC__) && defined(_M_IX86) // See commit b9cd3f2d9 (r25845) +typedef union _ULPTR64 { - ULONG_PTR Pointer; - ULONG64 RealPointer; -} GCC_ULONG64, *PGCC_ULONG64; + ULONG_PTR ptr; + ULONG64 ptr64; +} ULPTR64; +#else +// #define ULPTR64 PVOID64 +#define ULPTR64 ULONG64 +#endif typedef struct _KDDEBUGGER_DATA64 { DBGKD_DEBUG_DATA_HEADER64 Header; ULONG64 KernBase; - GCC_ULONG64 BreakpointWithStatus; + ULPTR64 BreakpointWithStatus; ULONG64 SavedContext; USHORT ThCallbackStack; USHORT NextCallback; USHORT FramePointer; USHORT PaeEnabled:1; - GCC_ULONG64 KiCallUserMode; + ULPTR64 KiCallUserMode; ULONG64 KeUserCallbackDispatcher; - GCC_ULONG64 PsLoadedModuleList; - GCC_ULONG64 PsActiveProcessHead; - GCC_ULONG64 PspCidTable; - GCC_ULONG64 ExpSystemResourcesList; - GCC_ULONG64 ExpPagedPoolDescriptor; - GCC_ULONG64 ExpNumberOfPagedPools; - GCC_ULONG64 KeTimeIncrement; - GCC_ULONG64 KeBugCheckCallbackListHead; - GCC_ULONG64 KiBugcheckData; - GCC_ULONG64 IopErrorLogListHead; - GCC_ULONG64 ObpRootDirectoryObject; - GCC_ULONG64 ObpTypeObjectType; - GCC_ULONG64 MmSystemCacheStart; - GCC_ULONG64 MmSystemCacheEnd; - GCC_ULONG64 MmSystemCacheWs; - GCC_ULONG64 MmPfnDatabase; - GCC_ULONG64 MmSystemPtesStart; - GCC_ULONG64 MmSystemPtesEnd; - GCC_ULONG64 MmSubsectionBase; - GCC_ULONG64 MmNumberOfPagingFiles; - GCC_ULONG64 MmLowestPhysicalPage; - GCC_ULONG64 MmHighestPhysicalPage; - GCC_ULONG64 MmNumberOfPhysicalPages; - GCC_ULONG64 MmMaximumNonPagedPoolInBytes; - GCC_ULONG64 MmNonPagedSystemStart; - GCC_ULONG64 MmNonPagedPoolStart; - GCC_ULONG64 MmNonPagedPoolEnd; - GCC_ULONG64 MmPagedPoolStart; - GCC_ULONG64 MmPagedPoolEnd; - GCC_ULONG64 MmPagedPoolInformation; + ULPTR64 PsLoadedModuleList; + ULPTR64 PsActiveProcessHead; + ULPTR64 PspCidTable; + ULPTR64 ExpSystemResourcesList; + ULPTR64 ExpPagedPoolDescriptor; + ULPTR64 ExpNumberOfPagedPools; + ULPTR64 KeTimeIncrement; + ULPTR64 KeBugCheckCallbackListHead; + ULPTR64 KiBugcheckData; + ULPTR64 IopErrorLogListHead; + ULPTR64 ObpRootDirectoryObject; + ULPTR64 ObpTypeObjectType; + ULPTR64 MmSystemCacheStart; + ULPTR64 MmSystemCacheEnd; + ULPTR64 MmSystemCacheWs; + ULPTR64 MmPfnDatabase; + ULPTR64 MmSystemPtesStart; + ULPTR64 MmSystemPtesEnd; + ULPTR64 MmSubsectionBase; + ULPTR64 MmNumberOfPagingFiles; + ULPTR64 MmLowestPhysicalPage; + ULPTR64 MmHighestPhysicalPage; + ULPTR64 MmNumberOfPhysicalPages; + ULPTR64 MmMaximumNonPagedPoolInBytes; + ULPTR64 MmNonPagedSystemStart; + ULPTR64 MmNonPagedPoolStart; + ULPTR64 MmNonPagedPoolEnd; + ULPTR64 MmPagedPoolStart; + ULPTR64 MmPagedPoolEnd; + ULPTR64 MmPagedPoolInformation; ULONG64 MmPageSize; - GCC_ULONG64 MmSizeOfPagedPoolInBytes; - GCC_ULONG64 MmTotalCommitLimit; - GCC_ULONG64 MmTotalCommittedPages; - GCC_ULONG64 MmSharedCommit; - GCC_ULONG64 MmDriverCommit; - GCC_ULONG64 MmProcessCommit; - GCC_ULONG64 MmPagedPoolCommit; - GCC_ULONG64 MmExtendedCommit; - GCC_ULONG64 MmZeroedPageListHead; - GCC_ULONG64 MmFreePageListHead; - GCC_ULONG64 MmStandbyPageListHead; - GCC_ULONG64 MmModifiedPageListHead; - GCC_ULONG64 MmModifiedNoWritePageListHead; - GCC_ULONG64 MmAvailablePages; - GCC_ULONG64 MmResidentAvailablePages; - GCC_ULONG64 PoolTrackTable; - GCC_ULONG64 NonPagedPoolDescriptor; - GCC_ULONG64 MmHighestUserAddress; - GCC_ULONG64 MmSystemRangeStart; - GCC_ULONG64 MmUserProbeAddress; - GCC_ULONG64 KdPrintCircularBuffer; - GCC_ULONG64 KdPrintCircularBufferEnd; - GCC_ULONG64 KdPrintWritePointer; - GCC_ULONG64 KdPrintRolloverCount; - GCC_ULONG64 MmLoadedUserImageList; + ULPTR64 MmSizeOfPagedPoolInBytes; + ULPTR64 MmTotalCommitLimit; + ULPTR64 MmTotalCommittedPages; + ULPTR64 MmSharedCommit; + ULPTR64 MmDriverCommit; + ULPTR64 MmProcessCommit; + ULPTR64 MmPagedPoolCommit; + ULPTR64 MmExtendedCommit; + ULPTR64 MmZeroedPageListHead; + ULPTR64 MmFreePageListHead; + ULPTR64 MmStandbyPageListHead; + ULPTR64 MmModifiedPageListHead; + ULPTR64 MmModifiedNoWritePageListHead; + ULPTR64 MmAvailablePages; + ULPTR64 MmResidentAvailablePages; + ULPTR64 PoolTrackTable; + ULPTR64 NonPagedPoolDescriptor; + ULPTR64 MmHighestUserAddress; + ULPTR64 MmSystemRangeStart; + ULPTR64 MmUserProbeAddress; + ULPTR64 KdPrintCircularBuffer; + ULPTR64 KdPrintCircularBufferEnd; + ULPTR64 KdPrintWritePointer; + ULPTR64 KdPrintRolloverCount; + ULPTR64 MmLoadedUserImageList; #if (NTDDI_VERSION >= NTDDI_WINXP) - GCC_ULONG64 NtBuildLab; - GCC_ULONG64 KiNormalSystemCall; + ULPTR64 NtBuildLab; + ULPTR64 KiNormalSystemCall; #endif /* NOTE: Documented as "NT 5.0 hotfix (QFE) addition" */ #if (NTDDI_VERSION >= NTDDI_WIN2KSP4) - GCC_ULONG64 KiProcessorBlock; - GCC_ULONG64 MmUnloadedDrivers; - GCC_ULONG64 MmLastUnloadedDriver; - GCC_ULONG64 MmTriageActionTaken; - GCC_ULONG64 MmSpecialPoolTag; - GCC_ULONG64 KernelVerifier; - GCC_ULONG64 MmVerifierData; - GCC_ULONG64 MmAllocatedNonPagedPool; - GCC_ULONG64 MmPeakCommitment; - GCC_ULONG64 MmTotalCommitLimitMaximum; - GCC_ULONG64 CmNtCSDVersion; + ULPTR64 KiProcessorBlock; + ULPTR64 MmUnloadedDrivers; + ULPTR64 MmLastUnloadedDriver; + ULPTR64 MmTriageActionTaken; + ULPTR64 MmSpecialPoolTag; + ULPTR64 KernelVerifier; + ULPTR64 MmVerifierData; + ULPTR64 MmAllocatedNonPagedPool; + ULPTR64 MmPeakCommitment; + ULPTR64 MmTotalCommitLimitMaximum; + ULPTR64 CmNtCSDVersion; #endif #if (NTDDI_VERSION >= NTDDI_WINXP) - GCC_ULONG64 MmPhysicalMemoryBlock; - GCC_ULONG64 MmSessionBase; - GCC_ULONG64 MmSessionSize; - GCC_ULONG64 MmSystemParentTablePage; + ULPTR64 MmPhysicalMemoryBlock; + ULPTR64 MmSessionBase; + ULPTR64 MmSessionSize; + ULPTR64 MmSystemParentTablePage; #endif #if (NTDDI_VERSION >= NTDDI_WS03) - GCC_ULONG64 MmVirtualTranslationBase; + ULPTR64 MmVirtualTranslationBase; USHORT OffsetKThreadNextProcessor; USHORT OffsetKThreadTeb; USHORT OffsetKThreadKernelStack; @@ -299,9 +305,9 @@ typedef struct _KDDEBUGGER_DATA64 USHORT OffsetPrcbProcStateContext; USHORT OffsetPrcbNumber; USHORT SizeEThread; - GCC_ULONG64 KdPrintCircularBufferPtr; - GCC_ULONG64 KdPrintBufferSize; - GCC_ULONG64 KeLoaderBlock; + ULPTR64 KdPrintCircularBufferPtr; + ULPTR64 KdPrintBufferSize; + ULPTR64 KeLoaderBlock; USHORT SizePcr; USHORT OffsetPcrSelfPcr; USHORT OffsetPcrCurrentPrcb; @@ -322,18 +328,18 @@ typedef struct _KDDEBUGGER_DATA64 USHORT GdtTss; USHORT Gdt64R3CmCode; USHORT Gdt64R3CmTeb; - GCC_ULONG64 IopNumTriageDumpDataBlocks; - GCC_ULONG64 IopTriageDumpDataBlocks; + ULPTR64 IopNumTriageDumpDataBlocks; + ULPTR64 IopTriageDumpDataBlocks; #endif #if (NTDDI_VERSION >= NTDDI_LONGHORN) - GCC_ULONG64 VfCrashDataBlock; - GCC_ULONG64 MmBadPagesDetected; - GCC_ULONG64 MmZeroedPageSingleBitErrorsDetected; + ULPTR64 VfCrashDataBlock; + ULPTR64 MmBadPagesDetected; + ULPTR64 MmZeroedPageSingleBitErrorsDetected; #endif #if (NTDDI_VERSION >= NTDDI_WIN7) - GCC_ULONG64 EtwpDebuggerData; + ULPTR64 EtwpDebuggerData; USHORT OffsetPrcbContext; #endif @@ -358,11 +364,11 @@ typedef struct _KDDEBUGGER_DATA64 #if (NTDDI_VERSION >= NTDDI_WIN10_RS1) USHORT Padding; - GCC_ULONG64 PteBase; + ULPTR64 PteBase; #endif #if (NTDDI_VERSION >= NTDDI_WIN10_RS5) - GCC_ULONG64 RetpolineStubFunctionTable; + ULPTR64 RetpolineStubFunctionTable; ULONG RetpolineStubFunctionTableSize; ULONG RetpolineStubOffset; ULONG RetpolineStubSize;

2 years, 1 month

[reactos] 02/05: [PSDK][NTOS:KD64] Update the KDDEBUGGER_DATA64 structure with new fields.

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=1c0950b557b1f5070ac2b… commit 1c0950b557b1f5070ac2b2d3ebed9af24d9f48a2 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Wed Nov 23 06:16:17 2022 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Thu Nov 24 01:18:15 2022 +0100 [PSDK][NTOS:KD64] Update the KDDEBUGGER_DATA64 structure with new fields. Information from the Windows 10 SDK and from https://github.com/DarthTon/Blackbone/blob/master/src/BlackBoneDrv/NativeSt… --- ntoskrnl/kd64/kddata.c | 9 +++++++ sdk/include/psdk/wdbgexts.h | 62 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 70 insertions(+), 1 deletion(-) diff --git a/ntoskrnl/kd64/kddata.c b/ntoskrnl/kd64/kddata.c index 46254df19a2..40a42fb01ba 100644 --- a/ntoskrnl/kd64/kddata.c +++ b/ntoskrnl/kd64/kddata.c @@ -513,6 +513,11 @@ DBGKD_GET_VERSION64 KdVersionBlock = 0, 0 }; + +#if (NTDDI_VERSION >= NTDDI_WS03) +C_ASSERT(sizeof(KDDEBUGGER_DATA64) >= 0x318); +#endif + KDDEBUGGER_DATA64 KdDebuggerDataBlock = { {{0}}, @@ -690,4 +695,8 @@ KDDEBUGGER_DATA64 KdDebuggerDataBlock = #endif {(ULONG_PTR)&IopNumTriageDumpDataBlocks}, {(ULONG_PTR)IopTriageDumpDataBlocks}, + +#if (NTDDI_VERSION >= NTDDI_LONGHORN) +#error KdDebuggerDataBlock requires other fields for this NT version! +#endif }; diff --git a/sdk/include/psdk/wdbgexts.h b/sdk/include/psdk/wdbgexts.h index e00427f92d9..9664ec201be 100644 --- a/sdk/include/psdk/wdbgexts.h +++ b/sdk/include/psdk/wdbgexts.h @@ -1,6 +1,12 @@ #ifndef _WDBGEXTS_ #define _WDBGEXTS_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + enum { DBGKD_SIMULATION_NONE, @@ -242,8 +248,14 @@ typedef struct _KDDEBUGGER_DATA64 GCC_ULONG64 KdPrintWritePointer; GCC_ULONG64 KdPrintRolloverCount; GCC_ULONG64 MmLoadedUserImageList; + +#if (NTDDI_VERSION >= NTDDI_WINXP) GCC_ULONG64 NtBuildLab; GCC_ULONG64 KiNormalSystemCall; +#endif + +/* NOTE: Documented as "NT 5.0 hotfix (QFE) addition" */ +#if (NTDDI_VERSION >= NTDDI_WIN2KSP4) GCC_ULONG64 KiProcessorBlock; GCC_ULONG64 MmUnloadedDrivers; GCC_ULONG64 MmLastUnloadedDriver; @@ -255,10 +267,16 @@ typedef struct _KDDEBUGGER_DATA64 GCC_ULONG64 MmPeakCommitment; GCC_ULONG64 MmTotalCommitLimitMaximum; GCC_ULONG64 CmNtCSDVersion; +#endif + +#if (NTDDI_VERSION >= NTDDI_WINXP) GCC_ULONG64 MmPhysicalMemoryBlock; GCC_ULONG64 MmSessionBase; GCC_ULONG64 MmSessionSize; GCC_ULONG64 MmSystemParentTablePage; +#endif + +#if (NTDDI_VERSION >= NTDDI_WS03) GCC_ULONG64 MmVirtualTranslationBase; USHORT OffsetKThreadNextProcessor; USHORT OffsetKThreadTeb; @@ -306,11 +324,53 @@ typedef struct _KDDEBUGGER_DATA64 USHORT Gdt64R3CmTeb; GCC_ULONG64 IopNumTriageDumpDataBlocks; GCC_ULONG64 IopTriageDumpDataBlocks; -#if 0 // Longhorn/Vista and later +#endif + +#if (NTDDI_VERSION >= NTDDI_LONGHORN) GCC_ULONG64 VfCrashDataBlock; GCC_ULONG64 MmBadPagesDetected; GCC_ULONG64 MmZeroedPageSingleBitErrorsDetected; #endif + +#if (NTDDI_VERSION >= NTDDI_WIN7) + GCC_ULONG64 EtwpDebuggerData; + USHORT OffsetPrcbContext; +#endif + +#if (NTDDI_VERSION >= NTDDI_WIN8) + USHORT OffsetPrcbMaxBreakpoints; + USHORT OffsetPrcbMaxWatchpoints; + ULONG OffsetKThreadStackLimit; + ULONG OffsetKThreadStackBase; + ULONG OffsetKThreadQueueListEntry; + ULONG OffsetEThreadIrpList; + USHORT OffsetPrcbIdleThread; + USHORT OffsetPrcbNormalDpcState; + USHORT OffsetPrcbDpcStack; + USHORT OffsetPrcbIsrStack; + USHORT SizeKDPC_STACK_FRAME; +#endif + +#if (NTDDI_VERSION >= NTDDI_WINBLUE) // NTDDI_WIN81 + USHORT OffsetKPriQueueThreadListHead; + USHORT OffsetKThreadWaitReason; +#endif + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS1) + USHORT Padding; + GCC_ULONG64 PteBase; +#endif + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS5) + GCC_ULONG64 RetpolineStubFunctionTable; + ULONG RetpolineStubFunctionTableSize; + ULONG RetpolineStubOffset; + ULONG RetpolineStubSize; +#endif } KDDEBUGGER_DATA64, *PKDDEBUGGER_DATA64; +#ifdef __cplusplus +} #endif + +#endif // _WDBGEXTS_

2 years, 1 month

[reactos] 01/05: [PSDK] Clarify the FIXME comment about this mysterious warning.h (here for WDK compatibility).

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=1847474aaa1fbfd438607… commit 1847474aaa1fbfd438607c78cefba2ee3d4085e5 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Wed Nov 23 06:02:13 2022 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Thu Nov 24 01:18:11 2022 +0100 [PSDK] Clarify the FIXME comment about this mysterious warning.h (here for WDK compatibility). --- sdk/include/psdk/warning.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sdk/include/psdk/warning.h b/sdk/include/psdk/warning.h index 0d60f0f834b..60b5b15a78f 100644 --- a/sdk/include/psdk/warning.h +++ b/sdk/include/psdk/warning.h @@ -1,5 +1,5 @@ -/* FIXME - here we putting #pragma warning and disable or enable them - I known gcc and msvc using diffent pragma and I do not known - the gcc pragma well to achive msvs and gcc compatible with this */ \ No newline at end of file +/* FIXME - For WDK compatibility. + Here #pragma warning are placed and are disabled or enabled. + GCC and MSVC use different pragmas so a compatible list for + these remains to be found. */

2 years, 1 month

[reactos] 01/01: [NTOS:KE/x64] Implement KeDisconnectInterrupt() for amd64 (#4883)

by Marcin Jabłoński

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=edb7575faa0be6c9f19a2… commit edb7575faa0be6c9f19a2632f15e95f96ab2f54d Author: Marcin Jabłoński <nnxcomputing(a)gmail.com> AuthorDate: Tue Nov 22 21:52:18 2022 +0100 Commit: GitHub <noreply(a)github.com> CommitDate: Tue Nov 22 23:52:18 2022 +0300 [NTOS:KE/x64] Implement KeDisconnectInterrupt() for amd64 (#4883) Choose the correct element of the KiUnexpectedRange array, depending on the interrupt vector, the same way as here: https://github.com/reactos/reactos/blob/a2c6af0da4acbba9c254d003e9d9f4ea6e0… And guard KeConnectInterrupt() execution with dispatcher lock. CORE-14922 --- ntoskrnl/ke/amd64/interrupt.c | 86 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 76 insertions(+), 10 deletions(-) diff --git a/ntoskrnl/ke/amd64/interrupt.c b/ntoskrnl/ke/amd64/interrupt.c index a1e66da4dde..bf74eb2722c 100644 --- a/ntoskrnl/ke/amd64/interrupt.c +++ b/ntoskrnl/ke/amd64/interrupt.c @@ -17,8 +17,8 @@ #include <debug.h> extern UCHAR KiInterruptDispatchTemplate[16]; -extern UCHAR KiUnexpectedRange[]; -extern UCHAR KiUnexpectedRangeEnd[]; +extern KI_INTERRUPT_DISPATCH_ENTRY KiUnexpectedRange[256]; +extern KI_INTERRUPT_DISPATCH_ENTRY KiUnexpectedRangeEnd[]; void KiInterruptDispatch(void); @@ -82,6 +82,7 @@ KeConnectInterrupt(IN PKINTERRUPT Interrupt) { PVOID CurrentHandler; PKINTERRUPT ConnectedInterrupt; + KIRQL OldIrql; ASSERT(Interrupt->Vector >= PRIMARY_VECTOR_BASE); ASSERT(Interrupt->Vector <= MAXIMUM_IDTVECTOR); @@ -93,6 +94,10 @@ KeConnectInterrupt(IN PKINTERRUPT Interrupt) /* Check if its already connected */ if (Interrupt->Connected) return TRUE; + /* Set the system affinity and acquire the dispatcher lock */ + KeSetSystemAffinityThread(1ULL << Interrupt->Number); + OldIrql = KiAcquireDispatcherLock(); + /* Query the current handler */ CurrentHandler = KeQueryInterruptHandler(Interrupt->Vector); @@ -118,7 +123,7 @@ KeConnectInterrupt(IN PKINTERRUPT Interrupt) /* Didn't work, restore old handler */ DPRINT1("HalEnableSystemInterrupt failed\n"); KeRegisterInterruptHandler(Interrupt->Vector, CurrentHandler); - return FALSE; + goto Cleanup; } } else @@ -131,7 +136,7 @@ KeConnectInterrupt(IN PKINTERRUPT Interrupt) (ConnectedInterrupt->ShareVector == 0) || (Interrupt->Mode != ConnectedInterrupt->Mode)) { - return FALSE; + goto Cleanup; } /* Insert the new interrupt into the connected interrupt's list */ @@ -142,21 +147,82 @@ KeConnectInterrupt(IN PKINTERRUPT Interrupt) /* Mark as connected */ Interrupt->Connected = TRUE; - return TRUE; +Cleanup: + /* Release the dispatcher lock and restore the thread affinity */ + KiReleaseDispatcherLock(OldIrql); + KeRevertToUserAffinityThread(); + return Interrupt->Connected; } BOOLEAN NTAPI KeDisconnectInterrupt(IN PKINTERRUPT Interrupt) { - /* If the interrupt wasn't connected, there's nothing to do */ - if (!Interrupt->Connected) + KIRQL OldIrql; + PVOID VectorHandler, UnexpectedHandler; + PKINTERRUPT VectorFirstInterrupt, NextInterrupt; + PLIST_ENTRY HandlerHead; + + /* Set the system affinity and acquire the dispatcher lock */ + KeSetSystemAffinityThread(1ULL << Interrupt->Number); + OldIrql = KiAcquireDispatcherLock(); + + /* Check if the interrupt was connected - otherwise there's nothing to do */ + if (Interrupt->Connected) { - return FALSE; + /* Get the handler for this interrupt vector */ + VectorHandler = KeQueryInterruptHandler(Interrupt->Vector); + + /* Get the first interrupt for this handler */ + VectorFirstInterrupt = CONTAINING_RECORD(VectorHandler, KINTERRUPT, DispatchCode); + + /* The first interrupt list entry is the interrupt list head */ + HandlerHead = &VectorFirstInterrupt->InterruptListEntry; + + /* If the list is empty, this is the only interrupt for this vector */ + if (IsListEmpty(HandlerHead)) + { + /* If the list is empty, and the head is not from this interrupt, + * this interrupt is somehow incorrectly connected */ + ASSERT(VectorFirstInterrupt == Interrupt); + + UnexpectedHandler = &KiUnexpectedRange[Interrupt->Vector]._Op_push; + + /* This is the only interrupt, the handler can be disconnected */ + HalDisableSystemInterrupt(Interrupt->Vector, Interrupt->Irql); + KeRegisterInterruptHandler(Interrupt->Vector, UnexpectedHandler); + } + /* If the interrupt to be disconnected is the list head, but some others follow */ + else if (VectorFirstInterrupt == Interrupt) + { + /* Relocate the head to the next element */ + HandlerHead = HandlerHead->Flink; + RemoveTailList(HandlerHead); + + /* Get the next interrupt from the list head */ + NextInterrupt = CONTAINING_RECORD(HandlerHead, + KINTERRUPT, + InterruptListEntry); + + /* Set the next interrupt as the handler for this vector */ + KeRegisterInterruptHandler(Interrupt->Vector, + NextInterrupt->DispatchCode); + } + /* If the interrupt to be disconnected is not the list head */ + else + { + /* Remove the to be disconnected interrupt from the interrupt list */ + RemoveEntryList(&Interrupt->InterruptListEntry); + } + + /* Mark as not connected */ + Interrupt->Connected = FALSE; } - UNIMPLEMENTED; - __debugbreak(); + /* Release the dispatcher lock and restore the thread affinity */ + KiReleaseDispatcherLock(OldIrql); + KeRevertToUserAffinityThread(); + return TRUE; }

2 years, 1 month

[reactos] 03/03: [NTOS:KDBG] Fix the ANSI escape sequences used to get terminal characteristics when printing with paging.

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d15f12614397d14264e67… commit d15f12614397d14264e676aed343d1b56937efcd Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Tue Nov 22 01:49:16 2022 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Nov 22 02:10:55 2022 +0100 [NTOS:KDBG] Fix the ANSI escape sequences used to get terminal characteristics when printing with paging. - Line-wrapping is enabled with 'ESC[?7h' (the '?' was forgotten). Notice that the following reference also shows it wrong: https://www.cse.psu.edu/~kxc104/class/cse472/09s/hw/hw7/vt100ansi.htm - Terminal type is actually queried with 'ESC Z' (VT52-compatible), or with 'ESC[c' (VT100-compatible). The antediluvian CTRL-E ('\x05') control code gives instead a user-configurable (usually empty) string, so it's not reliable. Also, we don't really care about the returned result, we just need to know that one has been sent. Cross-checked with online documentation: * "Digital VT100 User Guide" (EK-VT100-UG-001) (1st edition, August 1978, reviewed November 1978). * https://www.real-world-systems.com/docs/ANSIcode.html * https://geoffg.net/Downloads/Terminal/TerminalEscapeCodes.pdf * https://invisible-island.net/xterm/ctlseqs/ctlseqs.html * https://en.wikipedia.org/wiki/Enquiry_character - Retrieve the size of the *controlling terminal* with escape sequences only when it's a serial one: serial output is enabled *and* KDSERIAL is set (i.e. user input through serial). See code for the actual logic (the corresponding truth table is left as an exercise for the reader). - Fix also a "Buffer" vs. "InBuffer" mismatch, that caused the whole code to fail. - For fallback terminal size values, use meaningful ones when SCREEN is instead the controlling "terminal" (based on full-size BOOTVID values). - When echoing read characters during line-cooking, do direct output by using KdpDprintf() instead of going through the heavy KdbpPrint() function. This fixes some input artifacts like: 1. extra slowdowns due to querying terminal size at each keypress, and 2. getting obnoxious "--- Press q to abort ..." prompts in the middle of typing a long comamnd because you are at the very bottom of the screen. --- ntoskrnl/kdbg/kdb_cli.c | 85 +++++++++++++++++++++++++++++-------------------- 1 file changed, 51 insertions(+), 34 deletions(-) diff --git a/ntoskrnl/kdbg/kdb_cli.c b/ntoskrnl/kdbg/kdb_cli.c index 806ace30fb2..ac4e70b7fbc 100644 --- a/ntoskrnl/kdbg/kdb_cli.c +++ b/ntoskrnl/kdbg/kdb_cli.c @@ -2923,27 +2923,28 @@ KdbpPagerInternal( { TerminalInitialized = TRUE; - KdpDprintf("\x1b[7h"); /* Enable linewrap */ + /* Enable line-wrap */ + KdpDprintf("\x1b[?7h"); - /* Query terminal type */ - /*DbgPrint("\x1b[Z");*/ - KdpDprintf("\x05"); - - Length = 0; + /* + * Query terminal type. + * Historically it was done with CTRL-E ('\x05'), however nowadays + * terminals respond to it with an empty (or a user-configurable) + * string. Instead, use the VT52-compatible 'ESC Z' sequence or the + * VT100-compatible 'ESC[c' one. + */ + KdpDprintf("\x1b[c"); KeStallExecutionProcessor(100000); + Length = 0; for (;;) { + /* Verify we get an answer, but don't care about it */ c = KdbpTryGetCharSerial(5000); if (c == -1) break; - - InBuffer[Length++] = c; - if (Length >= (sizeof(InBuffer) - 1)) - break; + ++Length; } - - InBuffer[Length] = '\0'; if (Length > 0) TerminalConnected = TRUE; } @@ -2953,21 +2954,34 @@ KdbpPagerInternal( /* Refresh terminal size each time when number of rows printed is 0 */ (KdbNumberOfRowsPrinted) == 0) { - if ((KdbDebugState & KD_DEBUG_KDSERIAL) && TerminalConnected && TerminalReportsSize) + /* Retrieve the size of the serial terminal only when it is the + * controlling terminal: serial output is enabled *and* KDSERIAL + * is set (i.e. user input through serial). */ + BOOLEAN SerialTerminal = +#if 0 + // Old logic where KDSERIAL also enables serial output. + (KdbDebugState & KD_DEBUG_KDSERIAL) || + (KdpDebugMode.Serial && !KdpDebugMode.Screen); +#else + // New logic where KDSERIAL does not necessarily enable serial output. + KdpDebugMode.Serial && + ((KdbDebugState & KD_DEBUG_KDSERIAL) || !KdpDebugMode.Screen); +#endif + + if (SerialTerminal && TerminalConnected && TerminalReportsSize) { /* Try to query number of rows from terminal. A reply looks like "\x1b[8;24;80t" */ TerminalReportsSize = FALSE; - KeStallExecutionProcessor(100000); KdpDprintf("\x1b[18t"); - c = KdbpTryGetCharSerial(5000); + KeStallExecutionProcessor(100000); + c = KdbpTryGetCharSerial(5000); if (c == KEY_ESC) { c = KdbpTryGetCharSerial(5000); if (c == '[') { Length = 0; - for (;;) { c = KdbpTryGetCharSerial(5000); @@ -2978,15 +2992,15 @@ KdbpPagerInternal( if (isalpha(c) || Length >= (sizeof(InBuffer) - 1)) break; } - InBuffer[Length] = '\0'; + if (InBuffer[0] == '8' && InBuffer[1] == ';') { for (i = 2; (i < Length) && (InBuffer[i] != ';'); i++); - if (Buffer[i] == ';') + if (InBuffer[i] == ';') { - Buffer[i++] = '\0'; + InBuffer[i++] = '\0'; /* Number of rows is now at Buffer + 2 and number of cols at Buffer + i */ KdbNumberOfRowsTerminal = strtoul(InBuffer + 2, NULL, 0); @@ -3003,19 +3017,22 @@ KdbpPagerInternal( if (KdbNumberOfRowsTerminal <= 0) { /* Set number of rows to the default */ - if (!DoPage) - KdbNumberOfRowsTerminal = 23; //Mna.: for SCREEN debugport + if (KdpDebugMode.Screen && !SerialTerminal) + KdbNumberOfRowsTerminal = (SCREEN_HEIGHT / (13 /*BOOTCHAR_HEIGHT*/ + 1)); else KdbNumberOfRowsTerminal = 24; } - else if (KdbNumberOfColsTerminal <= 0) + if (KdbNumberOfColsTerminal <= 0) { /* Set number of cols to the default */ - if (!DoPage) - KdbNumberOfColsTerminal = 75; //Mna.: for SCREEN debugport + if (KdpDebugMode.Screen && !SerialTerminal) + KdbNumberOfColsTerminal = (SCREEN_WIDTH / 8 /*BOOTCHAR_WIDTH*/); else KdbNumberOfColsTerminal = 80; } + + // KdpDprintf("Cols/Rows: %dx%d\n", + // KdbNumberOfColsTerminal, KdbNumberOfRowsTerminal); } /* Loop through the strings */ @@ -3398,7 +3415,7 @@ KdbpReadCommand( if (NextKey == '\n' || NextKey == -1) /* \n or no response at all */ NextKey = '\0'; - KdbpPrint("\n"); + KdpDprintf("\n"); /* * Repeat the last command if the user presses enter. Reduces the @@ -3425,9 +3442,9 @@ KdbpReadCommand( *Buffer = 0; if (EchoOn) - KdbpPrint("%c %c", KEY_BS, KEY_BS); + KdpDprintf("%c %c", KEY_BS, KEY_BS); else - KdbpPrint(" %c", KEY_BS); + KdpDprintf(" %c", KEY_BS); } } else if (ScanCode == KEY_SCAN_UP) @@ -3459,16 +3476,16 @@ KdbpReadCommand( *Buffer = 0; if (EchoOn) - KdbpPrint("%c %c", KEY_BS, KEY_BS); + KdpDprintf("%c %c", KEY_BS, KEY_BS); else - KdbpPrint(" %c", KEY_BS); + KdpDprintf(" %c", KEY_BS); } i = min(strlen(KdbCommandHistory[CmdHistIndex]), Size - 1); memcpy(Orig, KdbCommandHistory[CmdHistIndex], i); Orig[i] = '\0'; Buffer = Orig + i; - KdbpPrint("%s", Orig); + KdpDprintf("%s", Orig); } } else if (ScanCode == KEY_SCAN_DOWN) @@ -3488,23 +3505,23 @@ KdbpReadCommand( *Buffer = 0; if (EchoOn) - KdbpPrint("%c %c", KEY_BS, KEY_BS); + KdpDprintf("%c %c", KEY_BS, KEY_BS); else - KdbpPrint(" %c", KEY_BS); + KdpDprintf(" %c", KEY_BS); } i = min(strlen(KdbCommandHistory[CmdHistIndex]), Size - 1); memcpy(Orig, KdbCommandHistory[CmdHistIndex], i); Orig[i] = '\0'; Buffer = Orig + i; - KdbpPrint("%s", Orig); + KdpDprintf("%s", Orig); } } } else { if (EchoOn) - KdbpPrint("%c", Key); + KdpDprintf("%c", Key); *Buffer = Key; Buffer++;

2 years, 1 month

[reactos] 02/03: [NTOS:KD] Remove last remnant of KdpDetectConflicts, deprecated since 2007.

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c29d6806b8f80a84558d4… commit c29d6806b8f80a84558d48653c7642fa02c0bd12 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Mon Nov 21 17:48:02 2022 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Nov 22 02:10:54 2022 +0100 [NTOS:KD] Remove last remnant of KdpDetectConflicts, deprecated since 2007. Addendum to commit be2645ad8 (r25987). --- ntoskrnl/include/internal/kd.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/ntoskrnl/include/internal/kd.h b/ntoskrnl/include/internal/kd.h index 96862d1ef7e..87f0854693d 100644 --- a/ntoskrnl/include/internal/kd.h +++ b/ntoskrnl/include/internal/kd.h @@ -92,10 +92,6 @@ KdpKdbgInit( /* KD ROUTINES ***************************************************************/ -BOOLEAN -NTAPI -KdpDetectConflicts(PCM_RESOURCE_LIST DriverList); - BOOLEAN NTAPI KdpSafeReadMemory(

2 years, 1 month

[reactos] 01/03: [NTOS:KDBG] Deduplicate code between KdbpPrint() and KdbpPager().

by Hermès Bélusca-Maïto

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9337ea6a3c6b93837a02c… commit 9337ea6a3c6b93837a02ca83dd2d8899d40d7072 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Mon Nov 21 16:35:47 2022 +0100 Commit: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> CommitDate: Tue Nov 22 02:10:54 2022 +0100 [NTOS:KDBG] Deduplicate code between KdbpPrint() and KdbpPager(). --- ntoskrnl/kdbg/kdb.h | 9 +- ntoskrnl/kdbg/kdb_cli.c | 548 ++++++++++++++++++------------------------------ 2 files changed, 207 insertions(+), 350 deletions(-) diff --git a/ntoskrnl/kdbg/kdb.h b/ntoskrnl/kdbg/kdb.h index 542cc398f11..d78e2696cdd 100644 --- a/ntoskrnl/kdbg/kdb.h +++ b/ntoskrnl/kdbg/kdb.h @@ -98,10 +98,15 @@ KdbpCliMainLoop( VOID KdbpCliInterpretInitFile(VOID); +VOID +KdbpPager( + _In_ PCHAR Buffer, + _In_ ULONG BufLength); + VOID KdbpPrint( - IN PCHAR Format, - IN ... OPTIONAL); + _In_ PSTR Format, + _In_ ...); VOID KdbpPrintUnicodeString( diff --git a/ntoskrnl/kdbg/kdb_cli.c b/ntoskrnl/kdbg/kdb_cli.c index e044572691d..806ace30fb2 100644 --- a/ntoskrnl/kdbg/kdb_cli.c +++ b/ntoskrnl/kdbg/kdb_cli.c @@ -2526,12 +2526,6 @@ KdbpCmdReboot( return FALSE; } - -VOID -KdbpPager( - IN PCHAR Buffer, - IN ULONG BufLength); - /*!\brief Display debug messages on screen, with paging. * * Keys for per-page view: Home, End, PageUp, Arrow Up, PageDown, @@ -2787,266 +2781,9 @@ KdbpCmdHelp( return TRUE; } -/*!\brief Prints the given string with printf-like formatting. - * - * \param Format Format of the string/arguments. - * \param ... Variable number of arguments matching the format specified in \a Format. - * - * \note Doesn't correctly handle \\t and terminal escape sequences when calculating the - * number of lines required to print a single line from the Buffer in the terminal. - * Prints maximum 4096 chars, because of its buffer size. - * Uses KdpDPrintf internally (NOT DbgPrint!). Callers must already hold the debugger lock. - */ -VOID -KdbpPrint( - IN PCHAR Format, - IN ... OPTIONAL) -{ - static CHAR Buffer[4096]; - static BOOLEAN TerminalInitialized = FALSE; - static BOOLEAN TerminalConnected = FALSE; - static BOOLEAN TerminalReportsSize = TRUE; - CHAR c = '\0'; - PCHAR p, p2; - ULONG Length; - SIZE_T i, j; - LONG RowsPrintedByTerminal; - ULONG ScanCode; - va_list ap; - - /* Check if the user has aborted output of the current command */ - if (KdbOutputAborted) - return; - - /* Initialize the terminal */ - if (!TerminalInitialized) - { - KdpDprintf("\x1b[7h"); /* Enable linewrap */ - - /* Query terminal type */ - /*DbgPrint("\x1b[Z");*/ - KdpDprintf("\x05"); - - TerminalInitialized = TRUE; - Length = 0; - KeStallExecutionProcessor(100000); - - for (;;) - { - c = KdbpTryGetCharSerial(5000); - if (c == -1) - break; - - Buffer[Length++] = c; - if (Length >= (sizeof(Buffer) - 1)) - break; - } - - Buffer[Length] = '\0'; - if (Length > 0) - TerminalConnected = TRUE; - } - - /* Get number of rows and columns in terminal */ - if ((KdbNumberOfRowsTerminal < 0) || (KdbNumberOfColsTerminal < 0) || - (KdbNumberOfRowsPrinted) == 0) /* Refresh terminal size each time when number of rows printed is 0 */ - { - if ((KdbDebugState & KD_DEBUG_KDSERIAL) && TerminalConnected && TerminalReportsSize) - { - /* Try to query number of rows from terminal. A reply looks like "\x1b[8;24;80t" */ - TerminalReportsSize = FALSE; - KeStallExecutionProcessor(100000); - KdpDprintf("\x1b[18t"); - c = KdbpTryGetCharSerial(5000); - - if (c == KEY_ESC) - { - c = KdbpTryGetCharSerial(5000); - if (c == '[') - { - Length = 0; - - for (;;) - { - c = KdbpTryGetCharSerial(5000); - if (c == -1) - break; - - Buffer[Length++] = c; - if (isalpha(c) || Length >= (sizeof(Buffer) - 1)) - break; - } - - Buffer[Length] = '\0'; - if (Buffer[0] == '8' && Buffer[1] == ';') - { - for (i = 2; (i < Length) && (Buffer[i] != ';'); i++); - - if (Buffer[i] == ';') - { - Buffer[i++] = '\0'; - - /* Number of rows is now at Buffer + 2 and number of cols at Buffer + i */ - KdbNumberOfRowsTerminal = strtoul(Buffer + 2, NULL, 0); - KdbNumberOfColsTerminal = strtoul(Buffer + i, NULL, 0); - TerminalReportsSize = TRUE; - } - } - } - /* Clear further characters */ - while ((c = KdbpTryGetCharSerial(5000)) != -1); - } - } - - if (KdbNumberOfRowsTerminal <= 0) - { - /* Set number of rows to the default. */ - KdbNumberOfRowsTerminal = 23; //24; //Mna.: 23 for SCREEN debugport - } - else if (KdbNumberOfColsTerminal <= 0) - { - /* Set number of cols to the default. */ - KdbNumberOfColsTerminal = 75; //80; //Mna.: 75 for SCREEN debugport - } - } - - /* Get the string */ - va_start(ap, Format); - Length = _vsnprintf(Buffer, sizeof(Buffer) - 1, Format, ap); - Buffer[Length] = '\0'; - va_end(ap); - - p = Buffer; - while (p[0] != '\0') - { - i = strcspn(p, "\n"); - - /* Calculate the number of lines which will be printed in the terminal - * when outputting the current line - */ - if (i > 0) - RowsPrintedByTerminal = (i + KdbNumberOfColsPrinted - 1) / KdbNumberOfColsTerminal; - else - RowsPrintedByTerminal = 0; - - if (p[i] == '\n') - RowsPrintedByTerminal++; - - /*DbgPrint("!%d!%d!%d!%d!", KdbNumberOfRowsPrinted, KdbNumberOfColsPrinted, i, RowsPrintedByTerminal);*/ - - /* Display a prompt if we printed one screen full of text */ - if (KdbNumberOfRowsTerminal > 0 && - (LONG)(KdbNumberOfRowsPrinted + RowsPrintedByTerminal) >= KdbNumberOfRowsTerminal) - { - KdbRepeatLastCommand = FALSE; - - if (KdbNumberOfColsPrinted > 0) - KdpDprintf("\n"); - - KdpDprintf("--- Press q to abort, any other key to continue ---"); - RowsPrintedByTerminal++; /* added by Mna. */ - - if (KdbDebugState & KD_DEBUG_KDSERIAL) - c = KdbpGetCharSerial(); - else - c = KdbpGetCharKeyboard(&ScanCode); - - if (c == '\r') - { - /* Try to read '\n' which might follow '\r' - if \n is not received here - * it will be interpreted as "return" when the next command should be read. - */ - if (KdbDebugState & KD_DEBUG_KDSERIAL) - c = KdbpTryGetCharSerial(5); - else - c = KdbpTryGetCharKeyboard(&ScanCode, 5); - } - - KdpDprintf("\n"); - if (c == 'q') - { - KdbOutputAborted = TRUE; - return; - } - - KdbNumberOfRowsPrinted = 0; - KdbNumberOfColsPrinted = 0; - } - - /* Insert a NUL after the line and print only the current line. */ - if (p[i] == '\n' && p[i + 1] != '\0') - { - c = p[i + 1]; - p[i + 1] = '\0'; - } - else - { - c = '\0'; - } - - /* Remove escape sequences from the line if there's no terminal connected */ - if (!TerminalConnected) - { - while ((p2 = strrchr(p, '\x1b'))) /* Look for escape character */ - { - size_t len = strlen(p2); - if (p2[1] == '[') - { - j = 2; - while (!isalpha(p2[j++])); - memmove(p2, p2 + j, len + 1 - j); - } - else - { - memmove(p2, p2 + 1, len); - } - } - } - - KdpDprintf("%s", p); - - if (c != '\0') - p[i + 1] = c; - - /* Set p to the start of the next line and - * remember the number of rows/cols printed - */ - p += i; - if (p[0] == '\n') - { - p++; - KdbNumberOfColsPrinted = 0; - } - else - { - ASSERT(p[0] == '\0'); - KdbNumberOfColsPrinted += i; - } - - KdbNumberOfRowsPrinted += RowsPrintedByTerminal; - } -} - -VOID -KdbpPrintUnicodeString( - _In_ PCUNICODE_STRING String) -{ - ULONG i; - - if ((String == NULL) || (String->Buffer == NULL)) - { - KdbpPrint("<NULL>"); - return; - } - - for (i = 0; i < String->Length / sizeof(WCHAR); i++) - { - KdbpPrint("%c", (CHAR)String->Buffer[i]); - } -} -/** memrchr(), explicitly defined, since was absent in MinGW of RosBE. */ /* + * memrchr(), explicitly defined, since absent in the CRT. * Reverse memchr() * Find the last occurrence of 'c' in the buffer 's' of size 'n'. */ @@ -3078,14 +2815,17 @@ memrchr(const void *s, int c, size_t n) * Used by KdbpPager(). * Now N lines count is hardcoded to KdbNumberOfRowsTerminal. */ -PCHAR -CountOnePageUp(PCHAR Buffer, ULONG BufLength, PCHAR pCurPos) +static PCHAR +CountOnePageUp( + _In_ PCCH Buffer, + _In_ ULONG BufLength, + _In_ PCCH pCurPos) { - PCHAR p; + PCCH p; // p0 is initial guess of Page Start ULONG p0len = KdbNumberOfRowsTerminal * KdbNumberOfColsTerminal; - PCHAR p0 = pCurPos - p0len; - PCHAR prev_p = p0, p1; + PCCH p0 = pCurPos - p0len; + PCCH prev_p = p0, p1; ULONG j; if (pCurPos < Buffer) @@ -3093,7 +2833,7 @@ CountOnePageUp(PCHAR Buffer, ULONG BufLength, PCHAR pCurPos) ASSERT(pCurPos <= Buffer + BufLength); p = memrchr(p0, '\n', p0len); - if (NULL == p) + if (!p) p = p0; for (j = KdbNumberOfRowsTerminal; j--; ) { @@ -3101,10 +2841,10 @@ CountOnePageUp(PCHAR Buffer, ULONG BufLength, PCHAR pCurPos) p1 = memrchr(p0, '\n', p-p0); prev_p = p; p = p1; - if (NULL == p) + if (!p) { p = prev_p; - if (NULL == p) + if (!p) p = p0; break; } @@ -3113,9 +2853,33 @@ CountOnePageUp(PCHAR Buffer, ULONG BufLength, PCHAR pCurPos) j -= linesCnt-1; } - ASSERT(p != 0); + ASSERT(p != NULL); ++p; - return p; + return (PCHAR)p; +} + +static VOID +KdpFilterEscapes( + _Inout_ PSTR String) +{ + PCHAR p; + SIZE_T i; + size_t len; + + while ((p = strrchr(String, '\x1b'))) /* Look for escape character */ + { + len = strlen(p); + if (p[1] == '[') + { + i = 2; + while (!isalpha(p[i++])); + memmove(p, p + i, len + 1 - i); + } + else + { + memmove(p, p + 1, len); + } + } } /*!\brief Prints the given string with, page by page. @@ -3126,27 +2890,28 @@ CountOnePageUp(PCHAR Buffer, ULONG BufLength, PCHAR pCurPos) * \note Doesn't correctly handle \\t and terminal escape sequences when calculating the * number of lines required to print a single line from the Buffer in the terminal. * Maximum length of buffer is limited only by memory size. + * Uses KdpDprintf internally (NOT DbgPrint!). Callers must already hold the debugger lock. * * Note: BufLength should be greater then (KdbNumberOfRowsTerminal * KdbNumberOfColsTerminal). - * */ VOID -KdbpPager( - IN PCHAR Buffer, - IN ULONG BufLength) +KdbpPagerInternal( + _In_ PCHAR Buffer, + _In_ ULONG BufLength, + _In_ BOOLEAN DoPage) { - static CHAR InBuffer[4096]; + static CHAR InBuffer[128]; static BOOLEAN TerminalInitialized = FALSE; static BOOLEAN TerminalConnected = FALSE; static BOOLEAN TerminalReportsSize = TRUE; - CHAR c = '\0'; - PCHAR p, p2; + CHAR c; + ULONG ScanCode; + PCHAR p; ULONG Length; - SIZE_T i, j; + SIZE_T i; LONG RowsPrintedByTerminal; - ULONG ScanCode; - if( BufLength == 0) + if (BufLength == 0) return; /* Check if the user has aborted output of the current command */ @@ -3156,13 +2921,14 @@ KdbpPager( /* Initialize the terminal */ if (!TerminalInitialized) { + TerminalInitialized = TRUE; + KdpDprintf("\x1b[7h"); /* Enable linewrap */ /* Query terminal type */ /*DbgPrint("\x1b[Z");*/ KdpDprintf("\x05"); - TerminalInitialized = TRUE; Length = 0; KeStallExecutionProcessor(100000); @@ -3184,7 +2950,8 @@ KdbpPager( /* Get number of rows and columns in terminal */ if ((KdbNumberOfRowsTerminal < 0) || (KdbNumberOfColsTerminal < 0) || - (KdbNumberOfRowsPrinted) == 0) /* Refresh terminal size each time when number of rows printed is 0 */ + /* Refresh terminal size each time when number of rows printed is 0 */ + (KdbNumberOfRowsPrinted) == 0) { if ((KdbDebugState & KD_DEBUG_KDSERIAL) && TerminalConnected && TerminalReportsSize) { @@ -3235,36 +3002,45 @@ KdbpPager( if (KdbNumberOfRowsTerminal <= 0) { - /* Set number of rows to the default. */ - KdbNumberOfRowsTerminal = 24; + /* Set number of rows to the default */ + if (!DoPage) + KdbNumberOfRowsTerminal = 23; //Mna.: for SCREEN debugport + else + KdbNumberOfRowsTerminal = 24; } else if (KdbNumberOfColsTerminal <= 0) { - /* Set number of cols to the default. */ - KdbNumberOfColsTerminal = 80; + /* Set number of cols to the default */ + if (!DoPage) + KdbNumberOfColsTerminal = 75; //Mna.: for SCREEN debugport + else + KdbNumberOfColsTerminal = 80; } } - /* Get the string */ + /* Loop through the strings */ p = Buffer; - while (p[0] != '\0') { - if ( p > Buffer+BufLength) + if (DoPage) { - KdpDprintf("Dmesg: error, p > Buffer+BufLength,d=%d", p - (Buffer+BufLength)); - return; + if (p > Buffer + BufLength) + { + KdpDprintf("Dmesg: error, p > Buffer+BufLength,d=%d", p - (Buffer + BufLength)); + return; + } } i = strcspn(p, "\n"); - // Are we out of buffer? - if (p + i > Buffer + BufLength) - // Leaving pager function: - break; + if (DoPage) + { + /* Are we out of buffer? */ + if (p + i > Buffer + BufLength) + break; // Leaving pager function + } - /* Calculate the number of lines which will be printed in the terminal - * when outputting the current line. - */ + /* Calculate the number of lines which will be printed in + * the terminal when outputting the current line. */ if (i > 0) RowsPrintedByTerminal = (i + KdbNumberOfColsPrinted - 1) / KdbNumberOfColsTerminal; else @@ -3273,7 +3049,7 @@ KdbpPager( if (p[i] == '\n') RowsPrintedByTerminal++; - /*DbgPrint("!%d!%d!%d!%d!", KdbNumberOfRowsPrinted, KdbNumberOfColsPrinted, i, RowsPrintedByTerminal);*/ + //KdpDprintf("!%d!%d!%d!%d!", KdbNumberOfRowsPrinted, KdbNumberOfColsPrinted, i, RowsPrintedByTerminal); /* Display a prompt if we printed one screen full of text */ if (KdbNumberOfRowsTerminal > 0 && @@ -3284,7 +3060,14 @@ KdbpPager( if (KdbNumberOfColsPrinted > 0) KdpDprintf("\n"); - KdpDprintf("--- Press q to abort, e/End,h/Home,u/PgUp, other key/PgDn ---"); + if (DoPage) + { + KdpDprintf("--- Press q to abort, e/End,h/Home,u/PgUp, other key/PgDn ---"); + } + else + { + KdpDprintf("--- Press q to abort, any other key to continue ---"); + } RowsPrintedByTerminal++; if (KdbDebugState & KD_DEBUG_KDSERIAL) @@ -3303,41 +3086,52 @@ KdbpPager( c = KdbpTryGetCharKeyboard(&ScanCode, 5); } - //DbgPrint("\n"); //Consize version: don't show pressed key - KdpDprintf(" '%c'/scan=%04x\n", c, ScanCode); // Shows pressed key - - if (c == 'q') - { - KdbOutputAborted = TRUE; - return; - } - if ( ScanCode == KEYSC_END || c=='e') + if (DoPage) { - PCHAR pBufEnd = Buffer + BufLength; - p = CountOnePageUp(Buffer, BufLength, pBufEnd); - i = strcspn(p, "\n"); + //KdpDprintf("\n"); // Concise version: don't show pressed key + KdpDprintf(" '%c'/scan=%04x\n", c, ScanCode); // Shows pressed key } - else if (ScanCode == KEYSC_PAGEUP || c=='u') + else { - p = CountOnePageUp(Buffer, BufLength, p); - i = strcspn(p, "\n"); + KdpDprintf("\n"); } - else if (ScanCode == KEYSC_HOME || c=='h') + + if (c == 'q') { - p = Buffer; - i = strcspn(p, "\n"); + KdbOutputAborted = TRUE; + return; } - else if (ScanCode == KEYSC_ARROWUP) + + if (DoPage) { - p = CountOnePageUp(Buffer, BufLength, p); - i = strcspn(p, "\n"); + if (ScanCode == KEYSC_END || c == 'e') + { + PCHAR pBufEnd = Buffer + BufLength; + p = CountOnePageUp(Buffer, BufLength, pBufEnd); + i = strcspn(p, "\n"); + } + else if (ScanCode == KEYSC_PAGEUP || c == 'u') + { + p = CountOnePageUp(Buffer, BufLength, p); + i = strcspn(p, "\n"); + } + else if (ScanCode == KEYSC_HOME || c == 'h') + { + p = Buffer; + i = strcspn(p, "\n"); + } + else if (ScanCode == KEYSC_ARROWUP) + { + p = CountOnePageUp(Buffer, BufLength, p); + i = strcspn(p, "\n"); + } } KdbNumberOfRowsPrinted = 0; KdbNumberOfColsPrinted = 0; } - /* Insert a NUL after the line and print only the current line. */ + /* Insert a NUL after the line and print only the current line */ if (p[i] == '\n' && p[i + 1] != '\0') { c = p[i + 1]; @@ -3348,35 +3142,21 @@ KdbpPager( c = '\0'; } - /* Remove escape sequences from the line if there's no terminal connected */ + /* Remove escape sequences from the line if there is no terminal connected */ + // FIXME: Dangerous operation since we modify the source string!! if (!TerminalConnected) - { - while ((p2 = strrchr(p, '\x1b'))) /* Look for escape character */ - { - size_t len = strlen(p2); - if (p2[1] == '[') - { - j = 2; - while (!isalpha(p2[j++])); - memmove(p2, p2 + j, len + 1 - j); - } - else - { - memmove(p2, p2 + 1, len); - } - } - } + KdpFilterEscapes(p); - // The main printing of the current line: - KdpDprintf(p); + /* Print the current line */ + // KdpDprintf(p); + KdpDprintf("%s", p); - // restore not null char with saved: + /* Restore not null char with saved */ if (c != '\0') p[i + 1] = c; /* Set p to the start of the next line and - * remember the number of rows/cols printed - */ + * remember the number of rows/cols printed */ p += i; if (p[0] == '\n') { @@ -3393,6 +3173,78 @@ KdbpPager( } } +/*!\brief Prints the given string with, page by page. + * + * \param Buffer Characters buffer to print. + * \param BufferLen Buffer size. + * + * \note Doesn't correctly handle \\t and terminal escape sequences when calculating the + * number of lines required to print a single line from the Buffer in the terminal. + * Maximum length of buffer is limited only by memory size. + * Uses KdpDprintf internally (NOT DbgPrint!). Callers must already hold the debugger lock. + * + * Note: BufLength should be greater then (KdbNumberOfRowsTerminal * KdbNumberOfColsTerminal). + */ +VOID +KdbpPager( + _In_ PCHAR Buffer, + _In_ ULONG BufLength) +{ + /* Call the internal function */ + KdbpPagerInternal(Buffer, BufLength, TRUE); +} + +/*!\brief Prints the given string with printf-like formatting. + * + * \param Format Format of the string/arguments. + * \param ... Variable number of arguments matching the format specified in \a Format. + * + * \note Doesn't correctly handle \\t and terminal escape sequences when calculating the + * number of lines required to print a single line from the Buffer in the terminal. + * Prints maximum 4096 chars, because of its buffer size. + */ +VOID +KdbpPrint( + _In_ PSTR Format, + _In_ ...) +{ + static CHAR Buffer[4096]; + ULONG Length; + va_list ap; + + /* Check if the user has aborted output of the current command */ + if (KdbOutputAborted) + return; + + /* Build the string */ + va_start(ap, Format); + Length = _vsnprintf(Buffer, sizeof(Buffer) - 1, Format, ap); + Buffer[Length] = '\0'; + va_end(ap); + + /* Actually print it */ + KdbpPagerInternal(Buffer, Length, FALSE); +} + +VOID +KdbpPrintUnicodeString( + _In_ PCUNICODE_STRING String) +{ + ULONG i; + + if ((String == NULL) || (String->Buffer == NULL)) + { + KdbpPrint("<NULL>"); + return; + } + + for (i = 0; i < String->Length / sizeof(WCHAR); i++) + { + KdbpPrint("%c", (CHAR)String->Buffer[i]); + } +} + + /*!\brief Appends a command to the command history * * \param Command Pointer to the command to append to the history.

2 years, 1 month

[reactos] 05/05: [LIBXML2] Update to version 2.9.14. CORE-17766

by Thomas Faber

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=8940614a78009668dcf86… commit 8940614a78009668dcf86d3641aea6485b147432 Author: Thomas Faber <thomas.faber(a)reactos.org> AuthorDate: Sat Nov 19 15:10:55 2022 -0500 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Mon Nov 21 19:46:12 2022 -0500 [LIBXML2] Update to version 2.9.14. CORE-17766 --- media/doc/3rd Party Files.txt | 2 +- sdk/include/reactos/libs/libxml/xmlversion.h | 10 ++-- sdk/lib/3rdparty/libxml2/HTMLparser.c | 47 ++++++++------- sdk/lib/3rdparty/libxml2/NEWS | 36 ++++++++++-- sdk/lib/3rdparty/libxml2/buf.c | 86 +++++++++++----------------- sdk/lib/3rdparty/libxml2/config.h | 2 +- sdk/lib/3rdparty/libxml2/encoding.c | 4 ++ sdk/lib/3rdparty/libxml2/globals.c | 30 +++++----- sdk/lib/3rdparty/libxml2/libxml.h | 7 ++- sdk/lib/3rdparty/libxml2/parser.c | 7 ++- sdk/lib/3rdparty/libxml2/tree.c | 72 +++++++++-------------- sdk/lib/3rdparty/libxml2/valid.c | 59 +++++++++---------- sdk/lib/3rdparty/libxml2/xinclude.c | 5 +- sdk/lib/3rdparty/libxml2/xmlregexp.c | 19 +++--- sdk/lib/3rdparty/libxml2/xpath.c | 71 +++++++++++------------ sdk/lib/3rdparty/libxml2/xpointer.c | 1 + 16 files changed, 226 insertions(+), 232 deletions(-) diff --git a/media/doc/3rd Party Files.txt b/media/doc/3rd Party Files.txt index 4d781121fa0..68c6ab5a0e1 100644 --- a/media/doc/3rd Party Files.txt +++ b/media/doc/3rd Party Files.txt @@ -239,7 +239,7 @@ URL: https://github.com/win-iconv/win-iconv Title: LibXML Path: sdk/lib/3rdparty/libxml2 -Used Version: 2.9.13 +Used Version: 2.9.14 License: MIT (https://spdx.org/licenses/MIT.htmlf) URL: http://xmlsoft.org, ftp://xmlsoft.org/libxml2/ diff --git a/sdk/include/reactos/libs/libxml/xmlversion.h b/sdk/include/reactos/libs/libxml/xmlversion.h index 1c8a8558ca6..9cd054df70e 100644 --- a/sdk/include/reactos/libs/libxml/xmlversion.h +++ b/sdk/include/reactos/libs/libxml/xmlversion.h @@ -29,28 +29,28 @@ XMLPUBFUN void XMLCALL xmlCheckVersion(int version); * * the version string like "1.2.3" */ -#define LIBXML_DOTTED_VERSION "2.9.13" +#define LIBXML_DOTTED_VERSION "2.9.14" /** * LIBXML_VERSION: * * the version number: 1.2.3 value is 10203 */ -#define LIBXML_VERSION 20913 +#define LIBXML_VERSION 20914 /** * LIBXML_VERSION_STRING: * * the version number string, 1.2.3 value is "10203" */ -#define LIBXML_VERSION_STRING "20913" +#define LIBXML_VERSION_STRING "20914" /** * LIBXML_VERSION_EXTRA: * * extra version information, used to show a git commit description */ -#define LIBXML_VERSION_EXTRA "-GITv2.9.12-115-ga075d256f" +#define LIBXML_VERSION_EXTRA "-GITv2.9.13-22-g7846b0a67" /** * LIBXML_TEST_VERSION: @@ -58,7 +58,7 @@ XMLPUBFUN void XMLCALL xmlCheckVersion(int version); * Macro to check that the libxml version in use is compatible with * the version the software has been compiled against */ -#define LIBXML_TEST_VERSION xmlCheckVersion(20913); +#define LIBXML_TEST_VERSION xmlCheckVersion(20914); #ifndef VMS #if 0 diff --git a/sdk/lib/3rdparty/libxml2/HTMLparser.c b/sdk/lib/3rdparty/libxml2/HTMLparser.c index 3e8a1657400..e720bb2013d 100644 --- a/sdk/lib/3rdparty/libxml2/HTMLparser.c +++ b/sdk/lib/3rdparty/libxml2/HTMLparser.c @@ -614,7 +614,8 @@ htmlSkipBlankChars(xmlParserCtxtPtr ctxt) { if (*ctxt->input->cur == 0) xmlParserInputGrow(ctxt->input, INPUT_CHUNK); } - res++; + if (res < INT_MAX) + res++; } return(res); } @@ -3960,26 +3961,6 @@ htmlParseStartTag(htmlParserCtxtPtr ctxt) { htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED, "htmlParseStartTag: invalid element name\n", NULL, NULL); - /* - * The recovery code is disabled for now as it can result in - * quadratic behavior with the push parser. htmlParseStartTag - * must consume all content up to the final '>' in order to avoid - * rescanning for this terminator. - * - * For a proper fix in line with HTML5, htmlParseStartTag and - * htmlParseElement should only be called when there's an ASCII - * alpha character following the initial '<'. Otherwise, the '<' - * should be emitted as text (unless followed by '!', '/' or '?'). - */ -#if 0 - /* if recover preserve text on classic misconstructs */ - if ((ctxt->recovery) && ((IS_BLANK_CH(CUR)) || (CUR == '<') || - (CUR == '=') || (CUR == '>') || (((CUR >= '0') && (CUR <= '9'))))) { - htmlParseCharDataInternal(ctxt, '<'); - return(-1); - } -#endif - /* Dump the bogus tag like browsers do */ while ((CUR != 0) && (CUR != '>') && (ctxt->instate != XML_PARSER_EOF)) @@ -4432,9 +4413,15 @@ htmlParseContent(htmlParserCtxtPtr ctxt) { /* * Third case : a sub-element. */ - else if (CUR == '<') { + else if ((CUR == '<') && IS_ASCII_LETTER(NXT(1))) { htmlParseElement(ctxt); } + else if (CUR == '<') { + if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && + (ctxt->sax->characters != NULL)) + ctxt->sax->characters(ctxt->userData, BAD_CAST "<", 1); + NEXT; + } /* * Fourth case : a reference. If if has not been resolved, @@ -4831,13 +4818,19 @@ htmlParseContentInternal(htmlParserCtxtPtr ctxt) { /* * Third case : a sub-element. */ - else if (CUR == '<') { + else if ((CUR == '<') && IS_ASCII_LETTER(NXT(1))) { htmlParseElementInternal(ctxt); if (currentNode != NULL) xmlFree(currentNode); currentNode = xmlStrdup(ctxt->name); depth = ctxt->nameNr; } + else if (CUR == '<') { + if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && + (ctxt->sax->characters != NULL)) + ctxt->sax->characters(ctxt->userData, BAD_CAST "<", 1); + NEXT; + } /* * Fourth case : a reference. If if has not been resolved, @@ -6004,7 +5997,7 @@ htmlParseTryOrFinish(htmlParserCtxtPtr ctxt, int terminate) { "HPP: entering END_TAG\n"); #endif break; - } else if (cur == '<') { + } else if ((cur == '<') && IS_ASCII_LETTER(next)) { if ((!terminate) && (next == 0)) goto done; ctxt->instate = XML_PARSER_START_TAG; @@ -6014,6 +6007,12 @@ htmlParseTryOrFinish(htmlParserCtxtPtr ctxt, int terminate) { "HPP: entering START_TAG\n"); #endif break; + } else if (cur == '<') { + if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && + (ctxt->sax->characters != NULL)) + ctxt->sax->characters(ctxt->userData, + BAD_CAST "<", 1); + NEXT; } else { /* * check that the text sequence is complete diff --git a/sdk/lib/3rdparty/libxml2/NEWS b/sdk/lib/3rdparty/libxml2/NEWS index 2ccdc10a9d2..c33d32a1727 100644 --- a/sdk/lib/3rdparty/libxml2/NEWS +++ b/sdk/lib/3rdparty/libxml2/NEWS @@ -1,12 +1,36 @@ NEWS file for libxml2 -The change log at -ChangeLog.html - describes the recents commits -to the GIT at -https://gitlab.gnome.org/GNOME/libxml2 - code base.Here is the list of public releases: +v2.9.14: May 02 2022: + - Security: + [CVE-2022-29824] Integer overflow in xmlBuf and xmlBuffer + Fix potential double-free in xmlXPtrStringRangeFunction + Fix memory leak in xmlFindCharEncodingHandler + Normalize XPath strings in-place + Prevent integer-overflow in htmlSkipBlankChars() and xmlSkipBlankChars() + (David Kilzer) + Fix leak of xmlElementContent (David Kilzer) + + - Bug fixes: + Fix parsing of subtracted regex character classes + Fix recursion check in xinclude.c + Reset last error in xmlCleanupGlobals + Fix certain combinations of regex range quantifiers + Fix range quantifier on subregex + + - Improvements: + Fix recovery from invalid HTML start tags + + - Build system, portability: + Define LFS macros before including system headers + Initialize XPath floating-point globals + configure: check for icu DEFS (James Hilliard) + configure.ac: produce tar.xz only (GNOME policy) (David Seifert) + CMakeLists.txt: Fix LIBXML_VERSION_NUMBER + Fix build with older Python versions + Fix --without-valid build + + v2.9.13: Feb 19 2022: - Security: [CVE-2022-23308] Use-after-free of ID and IDREF attributes diff --git a/sdk/lib/3rdparty/libxml2/buf.c b/sdk/lib/3rdparty/libxml2/buf.c index 24368d379f8..40a5ee068b1 100644 --- a/sdk/lib/3rdparty/libxml2/buf.c +++ b/sdk/lib/3rdparty/libxml2/buf.c @@ -30,6 +30,10 @@ #include <libxml/parserInternals.h> /* for XML_MAX_TEXT_LENGTH */ #include "buf.h" +#ifndef SIZE_MAX +#define SIZE_MAX ((size_t) -1) +#endif + #define WITH_BUFFER_COMPAT /** @@ -156,6 +160,8 @@ xmlBufPtr xmlBufCreateSize(size_t size) { xmlBufPtr ret; + if (size == SIZE_MAX) + return(NULL); ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf)); if (ret == NULL) { xmlBufMemoryError(NULL, "creating buffer"); @@ -166,8 +172,8 @@ xmlBufCreateSize(size_t size) { ret->error = 0; ret->buffer = NULL; ret->alloc = xmlBufferAllocScheme; - ret->size = (size ? size+2 : 0); /* +1 for ending null */ - ret->compat_size = (int) ret->size; + ret->size = (size ? size + 1 : 0); /* +1 for ending null */ + ret->compat_size = (ret->size > INT_MAX ? INT_MAX : ret->size); if (ret->size){ ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar)); if (ret->content == NULL) { @@ -442,23 +448,17 @@ xmlBufGrowInternal(xmlBufPtr buf, size_t len) { CHECK_COMPAT(buf) if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0); - if (buf->use + len < buf->size) + if (len < buf->size - buf->use) return(buf->size - buf->use); + if (len > SIZE_MAX - buf->use) + return(0); - /* - * Windows has a BIG problem on realloc timing, so we try to double - * the buffer size (if that's enough) (bug 146697) - * Apparently BSD too, and it's probably best for linux too - * On an embedded system this may be something to change - */ -#if 1 - if (buf->size > (size_t) len) - size = buf->size * 2; - else - size = buf->use + len + 100; -#else - size = buf->use + len + 100; -#endif + if (buf->size > (size_t) len) { + size = buf->size > SIZE_MAX / 2 ? SIZE_MAX : buf->size * 2; + } else { + size = buf->use + len; + size = size > SIZE_MAX - 100 ? SIZE_MAX : size + 100; + } if (buf->alloc == XML_BUFFER_ALLOC_BOUNDED) { /* @@ -744,7 +744,7 @@ xmlBufIsEmpty(const xmlBufPtr buf) int xmlBufResize(xmlBufPtr buf, size_t size) { - unsigned int newSize; + size_t newSize; xmlChar* rebuf = NULL; size_t start_buf; @@ -772,9 +772,13 @@ xmlBufResize(xmlBufPtr buf, size_t size) case XML_BUFFER_ALLOC_IO: case XML_BUFFER_ALLOC_DOUBLEIT: /*take care of empty case*/ - newSize = (buf->size ? buf->size*2 : size + 10); + if (buf->size == 0) { + newSize = (size > SIZE_MAX - 10 ? SIZE_MAX : size + 10); + } else { + newSize = buf->size; + } while (size > newSize) { - if (newSize > UINT_MAX / 2) { + if (newSize > SIZE_MAX / 2) { xmlBufMemoryError(buf, "growing buffer"); return 0; } @@ -782,15 +786,15 @@ xmlBufResize(xmlBufPtr buf, size_t size) } break; case XML_BUFFER_ALLOC_EXACT: - newSize = size+10; + newSize = (size > SIZE_MAX - 10 ? SIZE_MAX : size + 10); break; case XML_BUFFER_ALLOC_HYBRID: if (buf->use < BASE_BUFFER_SIZE) newSize = size; else { - newSize = buf->size * 2; + newSize = buf->size; while (size > newSize) { - if (newSize > UINT_MAX / 2) { + if (newSize > SIZE_MAX / 2) { xmlBufMemoryError(buf, "growing buffer"); return 0; } @@ -800,7 +804,7 @@ xmlBufResize(xmlBufPtr buf, size_t size) break; default: - newSize = size+10; + newSize = (size > SIZE_MAX - 10 ? SIZE_MAX : size + 10); break; } @@ -866,7 +870,7 @@ xmlBufResize(xmlBufPtr buf, size_t size) */ int xmlBufAdd(xmlBufPtr buf, const xmlChar *str, int len) { - unsigned int needSize; + size_t needSize; if ((str == NULL) || (buf == NULL) || (buf->error)) return -1; @@ -888,8 +892,10 @@ xmlBufAdd(xmlBufPtr buf, const xmlChar *str, int len) { if (len < 0) return -1; if (len == 0) return 0; - needSize = buf->use + len + 2; - if (needSize > buf->size){ + if ((size_t) len >= buf->size - buf->use) { + if ((size_t) len >= SIZE_MAX - buf->use) + return(-1); + needSize = buf->use + len + 1; if (buf->alloc == XML_BUFFER_ALLOC_BOUNDED) { /* * Used to provide parsing limits @@ -1025,31 +1031,7 @@ xmlBufCat(xmlBufPtr buf, const xmlChar *str) { */ int xmlBufCCat(xmlBufPtr buf, const char *str) { - const char *cur; - - if ((buf == NULL) || (buf->error)) - return(-1); - CHECK_COMPAT(buf) - if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1; - if (str == NULL) { -#ifdef DEBUG_BUFFER - xmlGenericError(xmlGenericErrorContext, - "xmlBufCCat: str == NULL\n"); -#endif - return -1; - } - for (cur = str;*cur != 0;cur++) { - if (buf->use + 10 >= buf->size) { - if (!xmlBufResize(buf, buf->use+10)){ - xmlBufMemoryError(buf, "growing buffer"); - return XML_ERR_NO_MEMORY; - } - } - buf->content[buf->use++] = *cur; - } - buf->content[buf->use] = 0; - UPDATE_COMPAT(buf) - return 0; + return xmlBufCat(buf, (const xmlChar *) str); } /** diff --git a/sdk/lib/3rdparty/libxml2/config.h b/sdk/lib/3rdparty/libxml2/config.h index ef0b883226d..596556c11d3 100644 --- a/sdk/lib/3rdparty/libxml2/config.h +++ b/sdk/lib/3rdparty/libxml2/config.h @@ -265,7 +265,7 @@ /* #undef VA_LIST_IS_ARRAY */ /* Version number of package */ -#define VERSION "2.9.13" +#define VERSION "2.9.14" /* Determine what socket length (socklen_t) data type is */ #define XML_SOCKLEN_T int diff --git a/sdk/lib/3rdparty/libxml2/encoding.c b/sdk/lib/3rdparty/libxml2/encoding.c index 3741c94ec48..c14c9ff6991 100644 --- a/sdk/lib/3rdparty/libxml2/encoding.c +++ b/sdk/lib/3rdparty/libxml2/encoding.c @@ -1738,6 +1738,10 @@ xmlFindCharEncodingHandler(const char *name) { } else if ((icv_in != (iconv_t) -1) || icv_out != (iconv_t) -1) { xmlEncodingErr(XML_ERR_INTERNAL_ERROR, "iconv : problems with filters for '%s'\n", name); + if (icv_in != (iconv_t) -1) + iconv_close(icv_in); + else + iconv_close(icv_out); } #endif /* LIBXML_ICONV_ENABLED */ #ifdef LIBXML_ICU_ENABLED diff --git a/sdk/lib/3rdparty/libxml2/globals.c b/sdk/lib/3rdparty/libxml2/globals.c index 0c0bdb44a83..893fb73a714 100644 --- a/sdk/lib/3rdparty/libxml2/globals.c +++ b/sdk/lib/3rdparty/libxml2/globals.c @@ -50,20 +50,6 @@ void xmlInitGlobals(void) xmlThrDefMutex = xmlNewMutex(); } -/** - * xmlCleanupGlobals: - * - * Additional cleanup for multi-threading - */ -void xmlCleanupGlobals(void) -{ - if (xmlThrDefMutex != NULL) { - xmlFreeMutex(xmlThrDefMutex); - xmlThrDefMutex = NULL; - } - __xmlGlobalInitMutexDestroy(); -} - /************************************************************************ * * * All the user accessible global variables of the library * @@ -577,6 +563,22 @@ xmlInitializeGlobalState(xmlGlobalStatePtr gs) xmlMutexUnlock(xmlThrDefMutex); } +/** + * xmlCleanupGlobals: + * + * Additional cleanup for multi-threading + */ +void xmlCleanupGlobals(void) +{ + xmlResetError(&xmlLastError); + + if (xmlThrDefMutex != NULL) { + xmlFreeMutex(xmlThrDefMutex); + xmlThrDefMutex = NULL; + } + __xmlGlobalInitMutexDestroy(); +} + /** * DOC_DISABLE : we ignore missing doc for the xmlThrDef functions, * those are really internal work diff --git a/sdk/lib/3rdparty/libxml2/libxml.h b/sdk/lib/3rdparty/libxml2/libxml.h index 1090729c65e..d40fcf86323 100644 --- a/sdk/lib/3rdparty/libxml2/libxml.h +++ b/sdk/lib/3rdparty/libxml2/libxml.h @@ -9,8 +9,10 @@ #ifndef __XML_LIBXML_H__ #define __XML_LIBXML_H__ -#include <libxml/xmlstring.h> - +/* + * These macros must be defined before including system headers. + * Do not add any #include directives above this block. + */ #ifndef NO_LARGEFILE_SOURCE #ifndef _LARGEFILE_SOURCE #define _LARGEFILE_SOURCE @@ -39,6 +41,7 @@ #include "config.h" #include <libxml/xmlversion.h> #endif +#include <libxml/xmlstring.h> #if defined(__Lynx__) #include <stdio.h> /* pull definition of size_t */ diff --git a/sdk/lib/3rdparty/libxml2/parser.c b/sdk/lib/3rdparty/libxml2/parser.c index 8ca9b2ddcf1..1bc37137f19 100644 --- a/sdk/lib/3rdparty/libxml2/parser.c +++ b/sdk/lib/3rdparty/libxml2/parser.c @@ -2208,7 +2208,8 @@ xmlSkipBlankChars(xmlParserCtxtPtr ctxt) { ctxt->input->col++; } cur++; - res++; + if (res < INT_MAX) + res++; if (*cur == 0) { ctxt->input->cur = cur; xmlParserInputGrow(ctxt->input, INPUT_CHUNK); @@ -2244,7 +2245,8 @@ xmlSkipBlankChars(xmlParserCtxtPtr ctxt) { * by the attachment of one leading and one following space (#x20) * character." */ - res++; + if (res < INT_MAX) + res++; } } return(res); @@ -14749,7 +14751,6 @@ xmlCleanupParser(void) { xmlSchemaCleanupTypes(); xmlRelaxNGCleanupTypes(); #endif - xmlResetLastError(); xmlCleanupGlobals(); xmlCleanupThreads(); /* must be last if called not from the main thread */ xmlCleanupMemory(); diff --git a/sdk/lib/3rdparty/libxml2/tree.c b/sdk/lib/3rdparty/libxml2/tree.c index 9d94aa42ae7..86afb7d6b1a 100644 --- a/sdk/lib/3rdparty/libxml2/tree.c +++ b/sdk/lib/3rdparty/libxml2/tree.c @@ -7104,6 +7104,8 @@ xmlBufferPtr xmlBufferCreateSize(size_t size) { xmlBufferPtr ret; + if (size >= UINT_MAX) + return(NULL); ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer)); if (ret == NULL) { xmlTreeErrMemory("creating buffer"); @@ -7111,7 +7113,7 @@ xmlBufferCreateSize(size_t size) { } ret->use = 0; ret->alloc = xmlBufferAllocScheme; - ret->size = (size ? size+2 : 0); /* +1 for ending null */ + ret->size = (size ? size + 1 : 0); /* +1 for ending null */ if (ret->size){ ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar)); if (ret->content == NULL) { @@ -7171,6 +7173,8 @@ xmlBufferCreateStatic(void *mem, size_t size) { if ((mem == NULL) || (size == 0)) return(NULL); + if (size > UINT_MAX) + return(NULL); ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer)); if (ret == NULL) { @@ -7318,28 +7322,23 @@ xmlBufferShrink(xmlBufferPtr buf, unsigned int len) { */ int xmlBufferGrow(xmlBufferPtr buf, unsigned int len) { - int size; + unsigned int size; xmlChar *newbuf; if (buf == NULL) return(-1); if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0); - if (len + buf->use < buf->size) return(0); + if (len < buf->size - buf->use) + return(0); + if (len > UINT_MAX - buf->use) + return(-1); - /* - * Windows has a BIG problem on realloc timing, so we try to double - * the buffer size (if that's enough) (bug 146697) - * Apparently BSD too, and it's probably best for linux too - * On an embedded system this may be something to change - */ -#if 1 - if (buf->size > len) - size = buf->size * 2; - else - size = buf->use + len + 100; -#else - size = buf->use + len + 100; -#endif + if (buf->size > (size_t) len) { + size = buf->size > UINT_MAX / 2 ? UINT_MAX : buf->size * 2; + } else { + size = buf->use + len; + size = size > UINT_MAX - 100 ? UINT_MAX : size + 100; + } if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) { size_t start_buf = buf->content - buf->contentIO; @@ -7466,7 +7465,10 @@ xmlBufferResize(xmlBufferPtr buf, unsigned int size) case XML_BUFFER_ALLOC_IO: case XML_BUFFER_ALLOC_DOUBLEIT: /*take care of empty case*/ - newSize = (buf->size ? buf->size : size + 10); + if (buf->size == 0) + newSize = (size > UINT_MAX - 10 ? UINT_MAX : size + 10); + else + newSize = buf->size; while (size > newSize) { if (newSize > UINT_MAX / 2) { xmlTreeErrMemory("growing buffer"); @@ -7476,7 +7478,7 @@ xmlBufferResize(xmlBufferPtr buf, unsigned int size) } break; case XML_BUFFER_ALLOC_EXACT: - newSize = size+10; + newSize = (size > UINT_MAX - 10 ? UINT_MAX : size + 10);; break; case XML_BUFFER_ALLOC_HYBRID: if (buf->use < BASE_BUFFER_SIZE) @@ -7494,7 +7496,7 @@ xmlBufferResize(xmlBufferPtr buf, unsigned int size) break; default: - newSize = size+10; + newSize = (size > UINT_MAX - 10 ? UINT_MAX : size + 10);; break; } @@ -7580,8 +7582,10 @@ xmlBufferAdd(xmlBufferPtr buf, const xmlChar *str, int len) { if (len < 0) return -1; if (len == 0) return 0; - needSize = buf->use + len + 2; - if (needSize > buf->size){ + if ((unsigned) len >= buf->size - buf->use) { + if ((unsigned) len >= UINT_MAX - buf->use) + return XML_ERR_NO_MEMORY; + needSize = buf->use + len + 1; if (!xmlBufferResize(buf, needSize)){ xmlTreeErrMemory("growing buffer"); return XML_ERR_NO_MEMORY; @@ -7694,29 +7698,7 @@ xmlBufferCat(xmlBufferPtr buf, const xmlChar *str) { */ int xmlBufferCCat(xmlBufferPtr buf, const char *str) { - const char *cur; - - if (buf == NULL) - return(-1); - if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1; - if (str == NULL) { -#ifdef DEBUG_BUFFER - xmlGenericError(xmlGenericErrorContext, - "xmlBufferCCat: str == NULL\n"); -#endif - return -1; - } - for (cur = str;*cur != 0;cur++) { - if (buf->use + 10 >= buf->size) { - if (!xmlBufferResize(buf, buf->use+10)){ - xmlTreeErrMemory("growing buffer"); - return XML_ERR_NO_MEMORY; - } - } - buf->content[buf->use++] = *cur; - } - buf->content[buf->use] = 0; - return 0; + return xmlBufferCat(buf, (const xmlChar *) str); } /** diff --git a/sdk/lib/3rdparty/libxml2/valid.c b/sdk/lib/3rdparty/libxml2/valid.c index 8e596f1db3d..ed3c8503057 100644 --- a/sdk/lib/3rdparty/libxml2/valid.c +++ b/sdk/lib/3rdparty/libxml2/valid.c @@ -479,35 +479,6 @@ nodeVPop(xmlValidCtxtPtr ctxt) return (ret); } -/** - * xmlValidNormalizeString: - * @str: a string - * - * Normalize a string in-place. - */ -static void -xmlValidNormalizeString(xmlChar *str) { - xmlChar *dst; - const xmlChar *src; - - if (str == NULL) - return; - src = str; - dst = str; - - while (*src == 0x20) src++; - while (*src != 0) { - if (*src == 0x20) { - while (*src == 0x20) src++; - if (*src != 0) - *dst++ = 0x20; - } else { - *dst++ = *src++; - } - } - *dst = 0; -} - #ifdef DEBUG_VALID_ALGO static void xmlValidPrintNode(xmlNodePtr cur) { @@ -1081,6 +1052,7 @@ xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur) { tmp->type = cur->type; tmp->ocur = cur->ocur; prev->c2 = tmp; + tmp->parent = prev; if (cur->name != NULL) { if (dict) tmp->name = xmlDictLookup(dict, cur->name, -1); @@ -2636,6 +2608,35 @@ xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table) { (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ xmlFree((char *)(str)); +/** + * xmlValidNormalizeString: + * @str: a string + * + * Normalize a string in-place. + */ +static void +xmlValidNormalizeString(xmlChar *str) { + xmlChar *dst; + const xmlChar *src; + + if (str == NULL) + return; + src = str; + dst = str; + + while (*src == 0x20) src++; + while (*src != 0) { + if (*src == 0x20) { + while (*src == 0x20) src++; + if (*src != 0) + *dst++ = 0x20; + } else { + *dst++ = *src++; + } + } + *dst = 0; +} + static int xmlIsStreaming(xmlValidCtxtPtr ctxt) { xmlParserCtxtPtr pctxt; diff --git a/sdk/lib/3rdparty/libxml2/xinclude.c b/sdk/lib/3rdparty/libxml2/xinclude.c index 2a0614d737a..e5fdf0fe8fa 100644 --- a/sdk/lib/3rdparty/libxml2/xinclude.c +++ b/sdk/lib/3rdparty/libxml2/xinclude.c @@ -525,8 +525,6 @@ xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) { if (href == NULL) return(-1); } - if ((href[0] == '#') || (href[0] == 0)) - local = 1; parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE); if (parse != NULL) { if (xmlStrEqual(parse, XINCLUDE_PARSE_XML)) @@ -623,6 +621,9 @@ xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) { return(-1); } + if (xmlStrEqual(URL, ctxt->doc->URL)) + local = 1; + /* * If local and xml then we need a fragment */ diff --git a/sdk/lib/3rdparty/libxml2/xmlregexp.c b/sdk/lib/3rdparty/libxml2/xmlregexp.c index 8d01c2ba32c..657912e0698 100644 --- a/sdk/lib/3rdparty/libxml2/xmlregexp.c +++ b/sdk/lib/3rdparty/libxml2/xmlregexp.c @@ -1693,12 +1693,12 @@ xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from, counter = xmlRegGetCounter(ctxt); ctxt->counters[counter].min = atom->min - 1; ctxt->counters[counter].max = atom->max - 1; - /* count the number of times we see it again */ - xmlFAGenerateCountedEpsilonTransition(ctxt, atom->stop, - atom->start, counter); /* allow a way out based on the count */ xmlFAGenerateCountedTransition(ctxt, atom->stop, newstate, counter); + /* count the number of times we see it again */ + xmlFAGenerateCountedEpsilonTransition(ctxt, atom->stop, + atom->start, counter); /* and if needed allow a direct exit for 0 */ if (atom->min == 0) xmlFAGenerateEpsilonTransition(ctxt, atom->start0, @@ -3364,7 +3364,6 @@ xmlFARegExec(xmlRegexpPtr comp, const xmlChar *content) { /* * this is a multiple input sequence * If there is a counter associated increment it now. - * before potentially saving and rollback * do not increment if the counter is already over the * maximum limit in which case get to next transition */ @@ -3380,15 +3379,17 @@ xmlFARegExec(xmlRegexpPtr comp, const xmlChar *content) { counter = &exec->comp->counters[trans->counter]; if (exec->counts[trans->counter] >= counter->max) continue; /* for loop on transitions */ - + } + /* Save before incrementing */ + if (exec->state->nbTrans > exec->transno + 1) { + xmlFARegExecSave(exec); + } + if (trans->counter >= 0) { #ifdef DEBUG_REGEXP_EXEC printf("Increasing count %d\n", trans->counter); #endif exec->counts[trans->counter]++; } - if (exec->state->nbTrans > exec->transno + 1) { - xmlFARegExecSave(exec); - } exec->transcount = 1; do { /* @@ -5107,7 +5108,7 @@ xmlFAParseCharRange(xmlRegParserCtxtPtr ctxt) { } NEXTL(len); cur = CUR; - if ((cur != '-') || (NXT(1) == ']')) { + if ((cur != '-') || (NXT(1) == '[') || (NXT(1) == ']')) { xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg, XML_REGEXP_CHARVAL, start, end, NULL); return; diff --git a/sdk/lib/3rdparty/libxml2/xpath.c b/sdk/lib/3rdparty/libxml2/xpath.c index 2da591cee94..c2d84588877 100644 --- a/sdk/lib/3rdparty/libxml2/xpath.c +++ b/sdk/lib/3rdparty/libxml2/xpath.c @@ -488,9 +488,9 @@ int wrap_cmp( xmlNodePtr x, xmlNodePtr y ); * * ************************************************************************/ -double xmlXPathNAN; -double xmlXPathPINF; -double xmlXPathNINF; +double xmlXPathNAN = 0.0; +double xmlXPathPINF = 0.0; +double xmlXPathNINF = 0.0; /** * xmlXPathInit: @@ -9260,52 +9260,45 @@ xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) { */ void xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) { - xmlXPathObjectPtr obj = NULL; - xmlChar *source = NULL; - xmlBufPtr target; - xmlChar blank; - - if (ctxt == NULL) return; - if (nargs == 0) { - /* Use current context node */ - valuePush(ctxt, - xmlXPathCacheWrapString(ctxt->context, - xmlXPathCastNodeToString(ctxt->context->node))); - nargs = 1; - } + xmlChar *source, *target; + int blank; - CHECK_ARITY(1); - CAST_TO_STRING; - CHECK_TYPE(XPATH_STRING); - obj = valuePop(ctxt); - source = obj->stringval; + if (ctxt == NULL) return; + if (nargs == 0) { + /* Use current context node */ + valuePush(ctxt, + xmlXPathCacheWrapString(ctxt->context, + xmlXPathCastNodeToString(ctxt->context->node))); + nargs = 1; + } - target = xmlBufCreate(); - if (target && source) { + CHECK_ARITY(1); + CAST_TO_STRING; + CHECK_TYPE(XPATH_STRING); + source = ctxt->value->stringval; + if (source == NULL) + return; + target = source; /* Skip leading whitespaces */ while (IS_BLANK_CH(*source)) - source++; + source++; /* Collapse intermediate whitespaces, and skip trailing whitespaces */ blank = 0; while (*source) { - if (IS_BLANK_CH(*source)) { - blank = 0x20; - } else { - if (blank) { - xmlBufAdd(target, &blank, 1); - blank = 0; - } - xmlBufAdd(target, source, 1); - } - source++; + if (IS_BLANK_CH(*source)) { + blank = 1; + } else { + if (blank) { + *target++ = 0x20; + blank = 0; + } + *target++ = *source; + } + source++; } - valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, - xmlBufContent(target))); - xmlBufFree(target); - } - xmlXPathReleaseObject(ctxt->context, obj); + *target = 0; } /** diff --git a/sdk/lib/3rdparty/libxml2/xpointer.c b/sdk/lib/3rdparty/libxml2/xpointer.c index afeaa2ecf99..e9c783cd66d 100644 --- a/sdk/lib/3rdparty/libxml2/xpointer.c +++ b/sdk/lib/3rdparty/libxml2/xpointer.c @@ -2756,6 +2756,7 @@ xmlXPtrStringRangeFunction(xmlXPathParserContextPtr ctxt, int nargs) { */ tmp = xmlXPtrNewLocationSetNodeSet(set->nodesetval); xmlXPathFreeObject(set); + set = NULL; if (tmp == NULL) { xmlXPathErr(ctxt, XPATH_MEMORY_ERROR); goto error;

2 years, 1 month

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

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs November 2022