- Wine-Devel - list.winehq.org

[PATCH 2/4] dsound: Use nameless unions.
by Jacek Caban March 30, 2021

March 30, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/dsound/Makefile.in | 1 - dlls/dsound/dsound_main.c | 6 +++--- dlls/dsound/primary.c | 2 +- dlls/dsound/propset.c | 2 +- 4 files changed, 5 insertions(+), 6 deletions(-)

2 1

[PATCH 1/2] ntdll/tests: Add committed / reserved thread stack sizes tests.
by Rémi Bernon March 30, 2021

March 30, 2021

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- I'm not sure at all about the layout of things in PATCH 2, or the safe stack size to clear, but the idea is to avoid touching all the pages. Dragon Quest Builder 2 uses a default stack reserve size of 2G, and it quickly exhaust memory, especially with all the internal threads being created. I also have some draft implementation of growing stacks on page fault instead, but I figured it was going to be a pain for debugging with all the additional signals being received. Also is seems like that some unix libraries are reserving stack pages very far away from the current stack pointer, and it overflows the usual number of guard pages. We would then have to grow stack on uncommitted page faults too, or to mark all reserved pages as page guard (to the contrary to what the tests are showing). dlls/ntdll/tests/virtual.c | 264 +++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) diff --git a/dlls/ntdll/tests/virtual.c b/dlls/ntdll/tests/virtual.c index 546a7d83bbd..112be80c01e 100644 --- a/dlls/ntdll/tests/virtual.c +++ b/dlls/ntdll/tests/virtual.c @@ -237,14 +237,266 @@ static void test_NtAllocateVirtualMemory(void) ok(status == STATUS_INVALID_PARAMETER, "NtAllocateVirtualMemoryEx returned %08x\n", status); } +struct test_stack_size_thread_args +{ + DWORD expect_committed; + DWORD expect_reserved; +}; + +static void force_stack_grow(void) +{ + volatile int buffer[0x2000]; + buffer[0] = 0xdeadbeef; + (void)buffer[0]; +} + +#ifdef _WIN64 +static void force_stack_grow_small(void) +{ + volatile int buffer[0x400]; + buffer[0] = 0xdeadbeef; + (void)buffer[0]; +} +#endif + +static DWORD WINAPI test_stack_size_thread(void *ptr) +{ + struct test_stack_size_thread_args *args = ptr; + MEMORY_BASIC_INFORMATION mbi; + NTSTATUS status; + SIZE_T size, guard_size; + DWORD committed, reserved; + void *addr; +#ifdef _WIN64 + DWORD prot; + void *tmp; +#endif + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + reserved = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->DeallocationStack; + todo_wine ok( committed == args->expect_committed || broken(committed == 0x1000), "unexpected stack committed size %x, expected %x\n", committed, args->expect_committed ); + ok( reserved == args->expect_reserved, "unexpected stack reserved size %x, expected %x\n", reserved, args->expect_reserved ); + + addr = (char *)NtCurrentTeb()->DeallocationStack; + status = NtQueryVirtualMemory( NtCurrentProcess(), addr, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.AllocationBase == NtCurrentTeb()->DeallocationStack, "unexpected AllocationBase %p, expected %p\n", mbi.AllocationBase, NtCurrentTeb()->DeallocationStack ); + ok( mbi.AllocationProtect == PAGE_READWRITE, "unexpected AllocationProtect %#x, expected %#x\n", mbi.AllocationProtect, PAGE_READWRITE ); + ok( mbi.BaseAddress == addr, "unexpected BaseAddress %p, expected %p\n", mbi.BaseAddress, addr ); + todo_wine ok( mbi.State == MEM_RESERVE, "unexpected State %#x, expected %#x\n", mbi.State, MEM_RESERVE ); + todo_wine ok( mbi.Protect == 0, "unexpected Protect %#x, expected %#x\n", mbi.Protect, 0 ); + ok( mbi.Type == MEM_PRIVATE, "unexpected Type %#x, expected %#x\n", mbi.Type, MEM_PRIVATE ); + + + force_stack_grow(); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + reserved = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->DeallocationStack; + todo_wine ok( committed == 0x9000, "unexpected stack committed size %x, expected 9000\n", committed ); + ok( reserved == args->expect_reserved, "unexpected stack reserved size %x, expected %x\n", reserved, args->expect_reserved ); + + + /* reserved area shrinks whenever stack grows */ + + addr = (char *)NtCurrentTeb()->DeallocationStack; + status = NtQueryVirtualMemory( NtCurrentProcess(), addr, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.AllocationBase == NtCurrentTeb()->DeallocationStack, "unexpected AllocationBase %p, expected %p\n", mbi.AllocationBase, NtCurrentTeb()->DeallocationStack ); + ok( mbi.AllocationProtect == PAGE_READWRITE, "unexpected AllocationProtect %#x, expected %#x\n", mbi.AllocationProtect, PAGE_READWRITE ); + ok( mbi.BaseAddress == addr, "unexpected BaseAddress %p, expected %p\n", mbi.BaseAddress, addr ); + todo_wine ok( mbi.State == MEM_RESERVE, "unexpected State %#x, expected %#x\n", mbi.State, MEM_RESERVE ); + todo_wine ok( mbi.Protect == 0, "unexpected Protect %#x, expected %#x\n", mbi.Protect, 0 ); + ok( mbi.Type == MEM_PRIVATE, "unexpected Type %#x, expected %#x\n", mbi.Type, MEM_PRIVATE ); + + guard_size = reserved - committed - mbi.RegionSize; + ok( guard_size == 0x1000 || guard_size == 0x2000 || guard_size == 0x3000, "unexpected guard_size %I64x, expected 1000, 2000 or 3000\n", (UINT64)guard_size ); + + /* the commit area is initially preceded by guard pages */ + + addr = (char *)NtCurrentTeb()->DeallocationStack + mbi.RegionSize; + status = NtQueryVirtualMemory( NtCurrentProcess(), addr, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.AllocationBase == NtCurrentTeb()->DeallocationStack, "unexpected AllocationBase %p, expected %p\n", mbi.AllocationBase, NtCurrentTeb()->DeallocationStack ); + ok( mbi.AllocationProtect == PAGE_READWRITE, "unexpected AllocationProtect %#x, expected %#x\n", mbi.AllocationProtect, PAGE_READWRITE ); + ok( mbi.BaseAddress == addr, "unexpected BaseAddress %p, expected %p\n", mbi.BaseAddress, addr ); + ok( mbi.RegionSize == guard_size, "unexpected RegionSize %I64x, expected 3000\n", (UINT64)mbi.RegionSize ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + ok( mbi.Protect == (PAGE_READWRITE|PAGE_GUARD), "unexpected Protect %#x, expected %#x\n", mbi.Protect, PAGE_READWRITE|PAGE_GUARD ); + ok( mbi.Type == MEM_PRIVATE, "unexpected Type %#x, expected %#x\n", mbi.Type, MEM_PRIVATE ); + + addr = (char *)NtCurrentTeb()->Tib.StackLimit; + status = NtQueryVirtualMemory( NtCurrentProcess(), addr, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.AllocationBase == NtCurrentTeb()->DeallocationStack, "unexpected AllocationBase %p, expected %p\n", mbi.AllocationBase, NtCurrentTeb()->DeallocationStack ); + ok( mbi.AllocationProtect == PAGE_READWRITE, "unexpected AllocationProtect %#x, expected %#x\n", mbi.AllocationProtect, PAGE_READWRITE ); + ok( mbi.BaseAddress == addr, "unexpected BaseAddress %p, expected %p\n", mbi.BaseAddress, addr ); + ok( mbi.RegionSize == committed, "unexpected RegionSize %I64x, expected %I64x\n", (UINT64)mbi.RegionSize, (UINT64)committed ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + ok( mbi.Protect == PAGE_READWRITE, "unexpected Protect %#x, expected %#x\n", mbi.Protect, PAGE_READWRITE ); + ok( mbi.Type == MEM_PRIVATE, "unexpected Type %#x, expected %#x\n", mbi.Type, MEM_PRIVATE ); + + +#ifdef _WIN64 + /* setting a guard page shrinks stack automatically */ + + addr = (char *)NtCurrentTeb()->Tib.StackLimit + 0x2000; + size = 0x1000; + status = NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 0, &size, MEM_COMMIT, PAGE_READWRITE | PAGE_GUARD ); + ok( !status, "NtAllocateVirtualMemory returned %08x\n", status ); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + todo_wine ok( committed == 0x6000, "unexpected stack committed size %x, expected 6000\n", committed ); + + status = NtQueryVirtualMemory( NtCurrentProcess(), (char *)addr - 0x2000, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.RegionSize == 0x2000, "unexpected RegionSize %I64x, expected 2000\n", (UINT64)mbi.RegionSize ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + ok( mbi.Protect == PAGE_READWRITE, "unexpected Protect %#x, expected %#x\n", mbi.Protect, PAGE_READWRITE ); + + status = NtQueryVirtualMemory( NtCurrentProcess(), addr, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.RegionSize == 0x1000, "unexpected RegionSize %I64x, expected 1000\n", (UINT64)mbi.RegionSize ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + ok( mbi.Protect == (PAGE_READWRITE|PAGE_GUARD), "unexpected Protect %#x, expected %#x\n", mbi.Protect, (PAGE_READWRITE|PAGE_GUARD) ); + + addr = (char *)NtCurrentTeb()->Tib.StackLimit; + status = NtQueryVirtualMemory( NtCurrentProcess(), addr, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + todo_wine ok( mbi.RegionSize == 0x6000, "unexpected RegionSize %I64x, expected 6000\n", (UINT64)mbi.RegionSize ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + ok( mbi.Protect == PAGE_READWRITE, "unexpected Protect %#x, expected %#x\n", mbi.Protect, PAGE_READWRITE ); + + + /* guard pages are restored as the stack grows back */ + + addr = (char *)NtCurrentTeb()->Tib.StackLimit + 0x4000; + tmp = (char *)addr - guard_size - 0x1000; + size = 0x1000; + status = NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 0, &size, MEM_COMMIT, PAGE_READWRITE | PAGE_GUARD ); + ok( !status, "NtAllocateVirtualMemory returned %08x\n", status ); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + todo_wine ok( committed == 0x1000, "unexpected stack committed size %x, expected 1000\n", committed ); + + status = NtQueryVirtualMemory( NtCurrentProcess(), tmp, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + todo_wine ok( mbi.RegionSize == guard_size + 0x1000, "unexpected RegionSize %I64x, expected %I64x\n", (UINT64)mbi.RegionSize, (UINT64)(guard_size + 0x1000) ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + todo_wine ok( mbi.Protect == PAGE_READWRITE, "unexpected Protect %#x, expected %#x\n", mbi.Protect, PAGE_READWRITE ); + + force_stack_grow_small(); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + todo_wine ok( committed == 0x2000, "unexpected stack committed size %x, expected 2000\n", committed ); + + status = NtQueryVirtualMemory( NtCurrentProcess(), tmp, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.RegionSize == 0x1000, "unexpected RegionSize %I64x, expected 1000\n", (UINT64)mbi.RegionSize ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + todo_wine ok( mbi.Protect == PAGE_READWRITE, "unexpected Protect %#x, expected %#x\n", mbi.Protect, PAGE_READWRITE ); + + status = NtQueryVirtualMemory( NtCurrentProcess(), (char *)tmp + 0x1000, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.RegionSize == guard_size, "unexpected RegionSize %I64x, expected %I64x\n", (UINT64)mbi.RegionSize, (UINT64)guard_size ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + todo_wine ok( mbi.Protect == (PAGE_READWRITE|PAGE_GUARD), "unexpected Protect %#x, expected %#x\n", mbi.Protect, (PAGE_READWRITE|PAGE_GUARD) ); + + + /* forcing stack limit over guard pages still shrinks the stack on page fault */ + + addr = (char *)tmp + guard_size + 0x1000; + size = 0x1000; + status = NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 0, &size, MEM_COMMIT, PAGE_READWRITE | PAGE_GUARD ); + ok( !status, "NtAllocateVirtualMemory returned %08x\n", status ); + + NtCurrentTeb()->Tib.StackLimit = (char *)tmp; + + status = NtQueryVirtualMemory( NtCurrentProcess(), (char *)tmp + 0x1000, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + todo_wine ok( mbi.RegionSize == guard_size + 0x1000, "unexpected RegionSize %I64x, expected %I64x\n", (UINT64)mbi.RegionSize, (UINT64)(guard_size + 0x1000) ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + todo_wine ok( mbi.Protect == (PAGE_READWRITE|PAGE_GUARD), "unexpected Protect %#x, expected %#x\n", mbi.Protect, (PAGE_READWRITE|PAGE_GUARD) ); + + force_stack_grow_small(); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + todo_wine ok( committed == 0x2000, "unexpected stack committed size %x, expected 2000\n", committed ); + + + /* it works with NtProtectVirtualMemory as well */ + + force_stack_grow(); + + addr = (char *)NtCurrentTeb()->Tib.StackLimit + 0x2000; + size = 0x1000; + status = NtProtectVirtualMemory( NtCurrentProcess(), &addr, &size, PAGE_READWRITE | PAGE_GUARD, &prot ); + ok( !status, "NtProtectVirtualMemory returned %08x\n", status ); + todo_wine ok( prot == PAGE_READWRITE, "unexpected prot %#x, expected %#x\n", prot, PAGE_READWRITE ); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + todo_wine ok( committed == 0x6000, "unexpected stack committed size %x, expected 6000\n", committed ); + + status = NtQueryVirtualMemory( NtCurrentProcess(), (char *)addr - 0x2000, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + todo_wine ok( mbi.RegionSize == 0x2000, "unexpected RegionSize %I64x, expected 2000\n", (UINT64)mbi.RegionSize ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + todo_wine ok( mbi.Protect == PAGE_READWRITE, "unexpected Protect %#x, expected %#x\n", mbi.Protect, PAGE_READWRITE ); + + status = NtQueryVirtualMemory( NtCurrentProcess(), addr, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + ok( mbi.RegionSize == 0x1000, "unexpected RegionSize %I64x, expected 1000\n", (UINT64)mbi.RegionSize ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + ok( mbi.Protect == (PAGE_READWRITE|PAGE_GUARD), "unexpected Protect %#x, expected %#x\n", mbi.Protect, (PAGE_READWRITE|PAGE_GUARD) ); + + addr = (char *)NtCurrentTeb()->Tib.StackLimit; + status = NtQueryVirtualMemory( NtCurrentProcess(), addr, MemoryBasicInformation, &mbi, sizeof(mbi), &size ); + ok( !status, "NtQueryVirtualMemory returned %08x\n", status ); + todo_wine ok( mbi.RegionSize == 0x6000, "unexpected RegionSize %I64x, expected 6000\n", (UINT64)mbi.RegionSize ); + ok( mbi.State == MEM_COMMIT, "unexpected State %#x, expected %#x\n", mbi.State, MEM_COMMIT ); + todo_wine ok( mbi.Protect == PAGE_READWRITE, "unexpected Protect %#x, expected %#x\n", mbi.Protect, PAGE_READWRITE ); + + + /* clearing the guard pages doesn't change StackLimit back */ + + force_stack_grow(); + + addr = (char *)NtCurrentTeb()->Tib.StackLimit + 0x2000; + size = 0x1000; + status = NtProtectVirtualMemory( NtCurrentProcess(), &addr, &size, PAGE_READWRITE | PAGE_GUARD, &prot ); + ok( !status, "NtProtectVirtualMemory returned %08x\n", status ); + todo_wine ok( prot == PAGE_READWRITE, "unexpected prot %#x, expected %#x\n", prot, PAGE_READWRITE ); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + todo_wine ok( committed == 0x6000, "unexpected stack committed size %x, expected 6000\n", committed ); + + status = NtProtectVirtualMemory( NtCurrentProcess(), &addr, &size, PAGE_READWRITE, &prot ); + ok( !status, "NtProtectVirtualMemory returned %08x\n", status ); + ok( prot == (PAGE_READWRITE | PAGE_GUARD), "unexpected prot %#x, expected %#x\n", prot, (PAGE_READWRITE | PAGE_GUARD) ); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + todo_wine ok( committed == 0x6000, "unexpected stack committed size %x, expected 6000\n", committed ); + + /* and as we messed with it and it now doesn't fault, it doesn't grow back either */ + + force_stack_grow(); + + committed = (char *)NtCurrentTeb()->Tib.StackBase - (char *)NtCurrentTeb()->Tib.StackLimit; + todo_wine ok( committed == 0x6000, "unexpected stack committed size %x, expected 6000\n", committed ); +#endif + + return 0; +} + static void test_RtlCreateUserStack(void) { IMAGE_NT_HEADERS *nt = RtlImageNtHeader( NtCurrentTeb()->Peb->ImageBaseAddress ); + struct test_stack_size_thread_args args; SIZE_T default_commit = nt->OptionalHeader.SizeOfStackCommit; SIZE_T default_reserve = nt->OptionalHeader.SizeOfStackReserve; INITIAL_TEB stack = {0}; unsigned int i; NTSTATUS ret; + HANDLE thread; struct { @@ -298,6 +550,18 @@ static void test_RtlCreateUserStack(void) ret = pRtlCreateUserStack(0x11000, 0x110000, 0, 0, 1, &stack); ok(ret == STATUS_INVALID_PARAMETER, "got %#x\n", ret); + + args.expect_committed = 0x4000; + args.expect_reserved = default_reserve; + thread = CreateThread(NULL, 0x3f00, test_stack_size_thread, &args, 0, NULL); + WaitForSingleObject(thread, INFINITE); + CloseHandle(thread); + + args.expect_committed = default_commit < 0x2000 ? 0x2000 : default_commit; + args.expect_reserved = 0x400000; + thread = CreateThread(NULL, 0x3ff000, test_stack_size_thread, &args, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL); + WaitForSingleObject(thread, INFINITE); + CloseHandle(thread); } static void test_NtMapViewOfSection(void) -- 2.30.2

2 4

Wine 5.0.4 regression: build failure in dlls/qcap/v4l.c
by Gerald Pfeifer March 30, 2021

March 30, 2021

The following patch (full version at the end) commit cb8e15a64307e580123b459e4c5964dc7b0d73d9 Author: Huw D. M. Davies <huw(a)codeweavers.com> Date: Tue Dec 22 14:26:36 2020 +0000 qcap: Avoid unused variable warning if v4l is absent. broke builds of Wine 5.0.4 where v4l is not present, specifically when the header <linux/videodev2.h> is not available. Configuring with --without-v4l2 does not trigger this; it really is about the presence of the header. The failure mode is In file included from v4l.c:60: v4l.c: In function 'qcap_driver_destroy': ../../include/wine/debug.h:485:56: error: '__wine_dbch___default' undeclared (first use in this function) : v4l.c:602:5: note: in expansion of macro 'ERR' 602 | ERR("v4l absent: shouldn't be called\n"); \ | ^~~ v4l.c:607:5: note: in expansion of macro 'FAIL_WITH_ERR' 607 | FAIL_WITH_ERR; | ^~~~~~~~~~~~~ and the straightforward fix is simply reverting this patch. https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=254601 has more details. Gerald commit cb8e15a64307e580123b459e4c5964dc7b0d73d9 jAuthor: Huw D. M. Davies <huw(a)codeweavers.com> Date: Tue Dec 22 14:26:36 2020 +0000 qcap: Avoid unused variable warning if v4l is absent. Signed-off-by: Huw Davies <huw(a)codeweavers.com> Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> (cherry picked from commit 73281bf132e1dad9aebf3410b21616727438fb63) Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> diff --git a/dlls/qcap/v4l.c b/dlls/qcap/v4l.c index 0d7e176d3da..e548000187f 100644 --- a/dlls/qcap/v4l.c +++ b/dlls/qcap/v4l.c @@ -63,10 +63,9 @@ #include "qcap_main.h" #include "capture.h" -WINE_DEFAULT_DEBUG_CHANNEL(qcap); - #ifdef HAVE_LINUX_VIDEODEV2_H +WINE_DEFAULT_DEBUG_CHANNEL(qcap); WINE_DECLARE_DEBUG_CHANNEL(winediag); static typeof(open) *video_open = open;

4 3

[PATCH] conhost: Delay window refresh on output update.
by Jacek Caban March 30, 2021

March 30, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- programs/conhost/conhost.c | 8 ++++---- programs/conhost/conhost.h | 2 +- programs/conhost/window.c | 15 +++++++++++---- 3 files changed, 16 insertions(+), 9 deletions(-)

1 0

[PATCH 1/4] dxdiagn: Use nameless unions.
by Jacek Caban March 30, 2021

March 30, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/dxdiagn/Makefile.in | 1 - dlls/dxdiagn/provider.c | 8 ++++---- 2 files changed, 4 insertions(+), 5 deletions(-)

1 0

[PATCH 1/3] server: Do not cancel process sigkill in kill_process().
by Paul Gofman March 30, 2021

March 30, 2021

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- The series avoids process being left alive on normal process termination if some of the native exit handlers hang. I hope it might fix https://bugs.winehq.org/show_bug.cgi?id=49897 but I am mostly unable to reproduce that here so cannot verify. server/process.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/server/process.c b/server/process.c index 7bc096a7b1f..9a647e7eddc 100644 --- a/server/process.c +++ b/server/process.c @@ -946,12 +946,7 @@ void kill_process( struct process *process, int violent_death ) } if (process->sigkill_timeout) /* already waiting for it to die */ - { - remove_timeout_user( process->sigkill_timeout ); - process->sigkill_timeout = NULL; - process_died( process ); return; - } if (violent_death) terminate_process( process, NULL, 1 ); else -- 2.30.2

1 2

[PATCH v2] msvcrt/tests: Add a test for wcsncpy().
by Piotr Caban March 30, 2021

March 30, 2021

From: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- v2: - test whole output buffer dlls/msvcrt/tests/string.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)

1 0

[PATCH 2/2] ole32: Always initialize storage header before writing it.
by Dmitry Timoshkov March 30, 2021

March 30, 2021

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/ole32/storage32.c | 33 ++++----------------------------- dlls/ole32/tests/storage32.c | 1 - 2 files changed, 4 insertions(+), 30 deletions(-) diff --git a/dlls/ole32/storage32.c b/dlls/ole32/storage32.c index 3d372af83f5..980b6c8d9f6 100644 --- a/dlls/ole32/storage32.c +++ b/dlls/ole32/storage32.c @@ -3016,20 +3016,10 @@ static void StorageImpl_SaveFileHeader( { BYTE headerBigBlock[HEADER_SIZE]; int index; - HRESULT hr; ULARGE_INTEGER offset; - DWORD bytes_read, bytes_written; + DWORD bytes_written; DWORD major_version, dirsectorcount; - /* - * Get a pointer to the big block of data containing the header. - */ - offset.u.HighPart = 0; - offset.u.LowPart = 0; - hr = StorageImpl_ReadAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_read); - if (SUCCEEDED(hr) && bytes_read != HEADER_SIZE) - hr = STG_E_FILENOTFOUND; - if (This->bigBlockSizeBits == 0x9) major_version = 3; else if (This->bigBlockSizeBits == 0xc) @@ -3040,21 +3030,8 @@ static void StorageImpl_SaveFileHeader( major_version = 4; } - /* - * If the block read failed, the file is probably new. - */ - if (FAILED(hr)) - { - /* - * Initialize for all unknown fields. - */ - memset(headerBigBlock, 0, HEADER_SIZE); - - /* - * Initialize the magic number. - */ - memcpy(headerBigBlock, STORAGE_magic, sizeof(STORAGE_magic)); - } + memset(headerBigBlock, 0, HEADER_SIZE); + memcpy(headerBigBlock, STORAGE_magic, sizeof(STORAGE_magic)); /* * Write the information to the header. @@ -3150,9 +3127,7 @@ static void StorageImpl_SaveFileHeader( (This->bigBlockDepotStart[index])); } - /* - * Write the big block back to the file. - */ + offset.QuadPart = 0; StorageImpl_WriteAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_written); } diff --git a/dlls/ole32/tests/storage32.c b/dlls/ole32/tests/storage32.c index da2e411eea4..3dc63ed1b12 100644 --- a/dlls/ole32/tests/storage32.c +++ b/dlls/ole32/tests/storage32.c @@ -4060,7 +4060,6 @@ todo_wine IStorage_Release(stg); p = GlobalLock(This->mem); -todo_wine ok(*p == 0xe011cfd0, "got %#x\n", *p); GlobalUnlock(This->mem); -- 2.30.2

1 0

[PATCH 1/5] wined3d: Pass a wined3d_device_context to wined3d_cs_emit_draw().
by Zebediah Figura March 30, 2021

March 30, 2021

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/wined3d/cs.c | 15 ++++++++------- dlls/wined3d/device.c | 8 ++++---- dlls/wined3d/wined3d_private.h | 7 ++++--- 3 files changed, 16 insertions(+), 14 deletions(-) diff --git a/dlls/wined3d/cs.c b/dlls/wined3d/cs.c index 390a97a64d3..cbc97d3614a 100644 --- a/dlls/wined3d/cs.c +++ b/dlls/wined3d/cs.c @@ -1046,15 +1046,16 @@ static void acquire_graphics_pipeline_resources(const struct wined3d_state *stat state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]); } -void wined3d_cs_emit_draw(struct wined3d_cs *cs, enum wined3d_primitive_type primitive_type, - unsigned int patch_vertex_count, int base_vertex_idx, unsigned int start_idx, - unsigned int index_count, unsigned int start_instance, unsigned int instance_count, bool indexed) +void wined3d_device_context_emit_draw(struct wined3d_device_context *context, + enum wined3d_primitive_type primitive_type, unsigned int patch_vertex_count, int base_vertex_idx, + unsigned int start_idx, unsigned int index_count, unsigned int start_instance, unsigned int instance_count, + bool indexed) { - const struct wined3d_d3d_info *d3d_info = &cs->c.device->adapter->d3d_info; - const struct wined3d_state *state = cs->c.state; + const struct wined3d_d3d_info *d3d_info = &context->device->adapter->d3d_info; + const struct wined3d_state *state = context->state; struct wined3d_cs_draw *op; - op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT); + op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT); op->opcode = WINED3D_CS_OP_DRAW; op->primitive_type = primitive_type; op->patch_vertex_count = patch_vertex_count; @@ -1068,7 +1069,7 @@ void wined3d_cs_emit_draw(struct wined3d_cs *cs, enum wined3d_primitive_type pri acquire_graphics_pipeline_resources(state, indexed, d3d_info); - wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT); + wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT); } void wined3d_cs_emit_draw_indirect(struct wined3d_cs *cs, enum wined3d_primitive_type primitive_type, diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 7e123661cdb..a683f4096f6 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -4445,7 +4445,7 @@ HRESULT CDECL wined3d_device_draw_primitive(struct wined3d_device *device, UINT TRACE("device %p, start_vertex %u, vertex_count %u.\n", device, start_vertex, vertex_count); - wined3d_cs_emit_draw(device->cs, state->primitive_type, + wined3d_device_context_emit_draw(&device->cs->c, state->primitive_type, state->patch_vertex_count, 0, start_vertex, vertex_count, 0, 0, false); return WINED3D_OK; @@ -4459,7 +4459,7 @@ void CDECL wined3d_device_draw_primitive_instanced(struct wined3d_device *device TRACE("device %p, start_vertex %u, vertex_count %u, start_instance %u, instance_count %u.\n", device, start_vertex, vertex_count, start_instance, instance_count); - wined3d_cs_emit_draw(device->cs, state->primitive_type, state->patch_vertex_count, + wined3d_device_context_emit_draw(&device->cs->c, state->primitive_type, state->patch_vertex_count, 0, start_vertex, vertex_count, start_instance, instance_count, false); } @@ -4490,7 +4490,7 @@ HRESULT CDECL wined3d_device_draw_indexed_primitive(struct wined3d_device *devic return WINED3DERR_INVALIDCALL; } - wined3d_cs_emit_draw(device->cs, state->primitive_type, state->patch_vertex_count, + wined3d_device_context_emit_draw(&device->cs->c, state->primitive_type, state->patch_vertex_count, state->base_vertex_index, start_idx, index_count, 0, 0, true); return WINED3D_OK; @@ -4504,7 +4504,7 @@ void CDECL wined3d_device_draw_indexed_primitive_instanced(struct wined3d_device TRACE("device %p, start_idx %u, index_count %u, start_instance %u, instance_count %u.\n", device, start_idx, index_count, start_instance, instance_count); - wined3d_cs_emit_draw(device->cs, state->primitive_type, state->patch_vertex_count, + wined3d_device_context_emit_draw(&device->cs->c, state->primitive_type, state->patch_vertex_count, state->base_vertex_index, start_idx, index_count, start_instance, instance_count, true); } diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index f0205a41c7e..a60c3691c82 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4735,9 +4735,6 @@ void wined3d_cs_emit_clear_unordered_access_view_uint(struct wined3d_cs *cs, struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value) DECLSPEC_HIDDEN; void wined3d_cs_emit_copy_uav_counter(struct wined3d_cs *cs, struct wined3d_buffer *dst_buffer, unsigned int offset, struct wined3d_unordered_access_view *uav) DECLSPEC_HIDDEN; -void wined3d_cs_emit_draw(struct wined3d_cs *cs, enum wined3d_primitive_type primitive_type, - unsigned int patch_vertex_count, int base_vertex_idx, unsigned int start_idx, unsigned int index_count, - unsigned int start_instance, unsigned int instance_count, bool indexed) DECLSPEC_HIDDEN; void wined3d_cs_emit_draw_indirect(struct wined3d_cs *cs, enum wined3d_primitive_type primitive_type, unsigned int patch_vertex_count, struct wined3d_buffer *buffer, unsigned int offset, bool indexed) DECLSPEC_HIDDEN; @@ -4789,6 +4786,10 @@ static inline void wined3d_cs_push_constants(struct wined3d_cs *cs, enum wined3d cs->c.ops->push_constants(&cs->c, p, start_idx, count, constants); } +void wined3d_device_context_emit_draw(struct wined3d_device_context *context, + enum wined3d_primitive_type primitive_type, unsigned int patch_vertex_count, int base_vertex_idx, + unsigned int start_idx, unsigned int index_count, unsigned int start_instance, unsigned int instance_count, + bool indexed) DECLSPEC_HIDDEN; void wined3d_device_context_emit_set_blend_state(struct wined3d_device_context *context, struct wined3d_blend_state *state, const struct wined3d_color *blend_factor, unsigned int sample_mask) DECLSPEC_HIDDEN; -- 2.30.2

4 12

[PATCH v3 1/2] ntdll: Implement NtQuerySystemInformationEx(SystemCpuSetInformation).
by Paul Gofman March 30, 2021

March 30, 2021

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- v3: - also remove is_win64 from tests. dlls/ntdll/tests/info.c | 85 +++++++++++++++++++++++++++ dlls/ntdll/unix/system.c | 120 +++++++++++++++++++++++++++++++++++++++ include/winnt.h | 41 +++++++++++++ include/winternl.h | 1 + 4 files changed, 247 insertions(+) diff --git a/dlls/ntdll/tests/info.c b/dlls/ntdll/tests/info.c index 85c523881ef..2c0b95d34c6 100644 --- a/dlls/ntdll/tests/info.c +++ b/dlls/ntdll/tests/info.c @@ -21,6 +21,7 @@ #include "ntdll_test.h" #include <winnls.h> #include <stdio.h> +#include "wine/heap.h" static NTSTATUS (WINAPI * pNtQuerySystemInformation)(SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG); static NTSTATUS (WINAPI * pNtSetSystemInformation)(SYSTEM_INFORMATION_CLASS, PVOID, ULONG); @@ -1099,6 +1100,89 @@ static void test_query_logicalprocex(void) HeapFree(GetProcessHeap(), 0, infoex_group); } +static void test_query_cpusetinfo(void) +{ + SYSTEM_CPU_SET_INFORMATION *info; + unsigned int i, cpu_count; + ULONG len, expected_len; + NTSTATUS status; + SYSTEM_INFO si; + HANDLE process; + + if (!pNtQuerySystemInformationEx) + return; + + GetSystemInfo(&si); + cpu_count = si.dwNumberOfProcessors; + expected_len = cpu_count * sizeof(*info); + + process = GetCurrentProcess(); + + status = pNtQuerySystemInformationEx(SystemCpuSetInformation, &process, sizeof(process), NULL, 0, &len); + if (status == STATUS_INVALID_INFO_CLASS) + { + win_skip("SystemCpuSetInformation is not supported\n"); + return; + } + + ok(status == STATUS_BUFFER_TOO_SMALL, "Got unexpected status %#x.\n", status); + ok(len == expected_len, "Got unexpected length %u.\n", len); + + len = 0xdeadbeef; + status = pNtQuerySystemInformation(SystemCpuSetInformation, NULL, 0, &len); + ok(status == STATUS_INVALID_PARAMETER || status == STATUS_INVALID_INFO_CLASS, + "Got unexpected status %#x.\n", status); + ok(len == 0xdeadbeef, "Got unexpected len %u.\n", len); + + len = 0xdeadbeef; + process = (HANDLE)0xdeadbeef; + status = pNtQuerySystemInformationEx(SystemCpuSetInformation, &process, sizeof(process), NULL, 0, &len); + ok(status == STATUS_INVALID_HANDLE, "Got unexpected status %#x.\n", status); + ok(len == 0xdeadbeef, "Got unexpected length %u.\n", len); + + len = 0xdeadbeef; + process = NULL; + status = pNtQuerySystemInformationEx(SystemCpuSetInformation, &process, 4 * sizeof(process), NULL, 0, &len); + ok((status == STATUS_INVALID_PARAMETER && len == 0xdeadbeef) + || (status == STATUS_BUFFER_TOO_SMALL && len == expected_len), + "Got unexpected status %#x, length %u.\n", status, len); + + len = 0xdeadbeef; + status = pNtQuerySystemInformationEx(SystemCpuSetInformation, NULL, sizeof(process), NULL, 0, &len); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected status %#x.\n", status); + ok(len == 0xdeadbeef, "Got unexpected length %u.\n", len); + + status = pNtQuerySystemInformationEx(SystemCpuSetInformation, &process, sizeof(process), NULL, 0, &len); + ok(status == STATUS_BUFFER_TOO_SMALL, "Got unexpected status %#x.\n", status); + ok(len == expected_len, "Got unexpected length %u.\n", len); + + len = 0xdeadbeef; + status = pNtQuerySystemInformationEx(SystemCpuSetInformation, &process, sizeof(process), NULL, + expected_len, &len); + ok(status == STATUS_ACCESS_VIOLATION, "Got unexpected status %#x.\n", status); + ok(len == 0xdeadbeef, "Got unexpected length %u.\n", len); + + info = heap_alloc(expected_len); + len = 0; + status = pNtQuerySystemInformationEx(SystemCpuSetInformation, &process, sizeof(process), info, expected_len, &len); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); + ok(len == expected_len, "Got unexpected length %u.\n", len); + + for (i = 0; i < cpu_count; ++i) + { + SYSTEM_CPU_SET_INFORMATION *d = &info[i]; + + ok(d->Size == sizeof(*d), "Got unexpected size %u, i %u.\n", d->Size, i); + ok(d->Type == CpuSetInformation, "Got unexpected type %u, i %u.\n", d->Type, i); + ok(d->CpuSet.Id == 0x100 + i, "Got unexpected Id %#x, i %u.\n", d->CpuSet.Id, i); + ok(!d->CpuSet.Group, "Got unexpected Group %u, i %u.\n", d->CpuSet.Group, i); + ok(d->CpuSet.LogicalProcessorIndex == i, "Got unexpected LogicalProcessorIndex %u, i %u.\n", + d->CpuSet.LogicalProcessorIndex, i); + ok(!d->CpuSet.AllFlags, "Got unexpected AllFlags %#x, i %u.\n", d->CpuSet.AllFlags, i); + } + heap_free(info); +} + static void test_query_firmware(void) { static const ULONG min_sfti_len = FIELD_OFFSET(SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer); @@ -3059,6 +3143,7 @@ START_TEST(info) test_query_regquota(); test_query_logicalproc(); test_query_logicalprocex(); + test_query_cpusetinfo(); test_query_firmware(); test_query_data_alignment(); diff --git a/dlls/ntdll/unix/system.c b/dlls/ntdll/unix/system.c index 6fa71ddfb91..a9cd686ed62 100644 --- a/dlls/ntdll/unix/system.c +++ b/dlls/ntdll/unix/system.c @@ -1166,6 +1166,98 @@ static NTSTATUS create_logical_proc_info( SYSTEM_LOGICAL_PROCESSOR_INFORMATION * } #endif +static NTSTATUS create_cpuset_info(SYSTEM_CPU_SET_INFORMATION *info) +{ + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *proc_info; + BYTE core_index, cache_index, max_cache_level; + unsigned int i, j, count; + BYTE *proc_info_buffer; + DWORD cpu_info_size; + ULONG64 cpu_mask; + NTSTATUS status; + + count = NtCurrentTeb()->Peb->NumberOfProcessors; + + cpu_info_size = 3 * sizeof(*proc_info); + if (!(proc_info_buffer = malloc(cpu_info_size))) + return STATUS_NO_MEMORY; + + if ((status = create_logical_proc_info(NULL, (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX **)&proc_info_buffer, + &cpu_info_size, RelationAll))) + { + free(proc_info_buffer); + return status; + } + + max_cache_level = 0; + proc_info = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)proc_info_buffer; + for (i = 0; (BYTE *)proc_info != proc_info_buffer + cpu_info_size; ++i) + { + if (proc_info->Relationship == RelationCache) + { + if (max_cache_level < proc_info->u.Cache.Level) + max_cache_level = proc_info->u.Cache.Level; + } + proc_info = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)((BYTE *)proc_info + proc_info->Size); + } + + memset(info, 0, count * sizeof(*info)); + + core_index = 0; + cache_index = 0; + proc_info = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)proc_info_buffer; + for (i = 0; i < count; ++i) + { + info[i].Size = sizeof(*info); + info[i].Type = CpuSetInformation; + info[i].u.CpuSet.Id = 0x100 + i; + info[i].u.CpuSet.LogicalProcessorIndex = i; + } + + for (i = 0; (BYTE *)proc_info != (BYTE *)proc_info_buffer + cpu_info_size; ++i) + { + if (proc_info->Relationship == RelationProcessorCore) + { + if (proc_info->u.Processor.GroupCount != 1) + { + FIXME("Unsupported group count %u.\n", proc_info->u.Processor.GroupCount); + continue; + } + cpu_mask = proc_info->u.Processor.GroupMask[0].Mask; + for (j = 0; j < count; ++j) + if (((ULONG64)1 << j) & cpu_mask) + { + info[j].u.CpuSet.CoreIndex = core_index; + info[j].u.CpuSet.EfficiencyClass = proc_info->u.Processor.EfficiencyClass; + } + ++core_index; + } + else if (proc_info->Relationship == RelationCache) + { + if (proc_info->u.Cache.Level == max_cache_level) + { + cpu_mask = proc_info->u.Cache.GroupMask.Mask; + for (j = 0; j < count; ++j) + if (((ULONG64)1 << j) & cpu_mask) + info[j].u.CpuSet.LastLevelCacheIndex = cache_index; + } + ++cache_index; + } + else if (proc_info->Relationship == RelationNumaNode) + { + cpu_mask = proc_info->u.NumaNode.GroupMask.Mask; + for (j = 0; j < count; ++j) + if (((ULONG64)1 << j) & cpu_mask) + info[j].u.CpuSet.NumaNodeIndex = proc_info->u.NumaNode.NodeNumber; + } + proc_info = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)((BYTE *)proc_info + proc_info->Size); + } + + free(proc_info_buffer); + + return STATUS_SUCCESS; +} + #ifdef linux static void copy_smbios_string( char **buffer, char *s, size_t len ) @@ -2651,6 +2743,9 @@ NTSTATUS WINAPI NtQuerySystemInformation( SYSTEM_INFORMATION_CLASS class, break; } + case SystemCpuSetInformation: + return NtQuerySystemInformationEx(class, NULL, 0, info, size, ret_size); + case SystemRecommendedSharedDataAlignment: { len = sizeof(DWORD); @@ -2773,6 +2868,31 @@ NTSTATUS WINAPI NtQuerySystemInformationEx( SYSTEM_INFORMATION_CLASS class, break; } + case SystemCpuSetInformation: + { + unsigned int cpu_count = NtCurrentTeb()->Peb->NumberOfProcessors; + PROCESS_BASIC_INFORMATION pbi; + HANDLE process; + + if (!query || query_len < sizeof(HANDLE)) + return STATUS_INVALID_PARAMETER; + + process = *(HANDLE *)query; + if (process && (ret = NtQueryInformationProcess(process, ProcessBasicInformation, &pbi, sizeof(pbi), NULL))) + return ret; + + if (size < (len = cpu_count * sizeof(SYSTEM_CPU_SET_INFORMATION))) + { + ret = STATUS_BUFFER_TOO_SMALL; + break; + } + if (!info) + return STATUS_ACCESS_VIOLATION; + + if ((ret = create_cpuset_info(info))) + return ret; + break; + } default: FIXME( "(0x%08x,%p,%u,%p,%u,%p) stub\n", class, query, query_len, info, size, ret_size ); break; diff --git a/include/winnt.h b/include/winnt.h index 0a6027118fe..840966f657b 100644 --- a/include/winnt.h +++ b/include/winnt.h @@ -6726,6 +6726,47 @@ typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX } DUMMYUNIONNAME; } SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX; +typedef enum _CPU_SET_INFORMATION_TYPE +{ + CpuSetInformation, +} CPU_SET_INFORMATION_TYPE, *PCPU_SET_INFORMATION_TYPE; + +typedef struct _SYSTEM_CPU_SET_INFORMATION +{ + DWORD Size; + CPU_SET_INFORMATION_TYPE Type; + union + { + struct + { + DWORD Id; + WORD Group; + BYTE LogicalProcessorIndex; + BYTE CoreIndex; + BYTE LastLevelCacheIndex; + BYTE NumaNodeIndex; + BYTE EfficiencyClass; + union + { + BYTE AllFlags; + struct + { + BYTE Parked : 1; + BYTE Allocated : 1; + BYTE AllocatedToTargetProcess : 1; + BYTE RealTime : 1; + BYTE ReservedFlags : 4; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME2; + union { + DWORD Reserved; + BYTE SchedulingClass; + }; + DWORD64 AllocationTag; + } CpuSet; + } DUMMYUNIONNAME; +} SYSTEM_CPU_SET_INFORMATION, *PSYSTEM_CPU_SET_INFORMATION; + /* Threadpool things */ typedef DWORD TP_VERSION,*PTP_VERSION; diff --git a/include/winternl.h b/include/winternl.h index fcdedaec8aa..c8fb7031d91 100644 --- a/include/winternl.h +++ b/include/winternl.h @@ -1551,6 +1551,7 @@ typedef enum _SYSTEM_INFORMATION_CLASS { SystemFileCacheInformationEx = 81, SystemDynamicTimeZoneInformation = 102, SystemLogicalProcessorInformationEx = 107, + SystemCpuSetInformation = 175, SystemHypervisorSharedPageInformation = 197, SystemInformationClassMax } SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS; -- 2.30.2

2 2