November 2019 - Wine-devel - list.winehq.org

Re: widl: Set name return value (passed by reference) in the alias case alias case in get_user_type.
by Alexandre Julliard 22 Nov '20

22 Nov '20

Gerald Pfeifer <gerald(a)pfeifer.com> writes: > So, I admit I don't really know this code, but looking at it (triggered > by a warning issued by GCC development versions), I noticed that this > variable passed by reference is not initialized here. It's initialized when we return a type, and it doesn't need to be initialized on NULL return. The code is correct, but you could probably set the variable to NULL in the caller to silence the warning. -- Alexandre Julliard julliard(a)winehq.org

2 1

Error handling in RpcBindingVectorFree (dlls/rpcrt4/rpc_binding.c)
by Gerald Pfeifer 22 Nov '20

22 Nov '20

Looking at RPC_STATUS WINAPI RpcBindingVectorFree( RPC_BINDING_VECTOR** BindingVector ) { RPC_STATUS status; ULONG c; TRACE("(%p)\n", BindingVector); for (c=0; c<(*BindingVector)->Count; c++) { status = RpcBindingFree(&(*BindingVector)->BindingH[c]); } HeapFree(GetProcessHeap(), 0, *BindingVector); *BindingVector = NULL; return RPC_S_OK; } we currently always ignore the outcome of RpcBindingFree and return RPC_S_OK. However, there is one case where RpcBindingFree returns something different (which is if *Binding is null when RPC_S_INVALID_BINDING is returned). What is the proper way of handling this? Just keeping the code as is and removing the unused status variable? Breaking the loop once RpcBindingFree returns something different from RPC_S_OK? Continuing and returning the first / the last status different from RPC_S_OK? Gerald

1 1

TestBot and graphics tests
by Francois Gouget 24 Aug '20

24 Aug '20

Here are some things I've learned about PCI-passthrough recently, which would be one way (probably the best) to add "real hardware" to the TestBot. I don't want to give anyone false hopes though: this just went from "this is a mysterious thing I need to learn about" to "I think I know how to do it but have not tried it yet". So graphics card PCI-passthrough is now relatively well documented on the Internet and seems to have seen some use-cases that would indicate it may even be reasonably usable. * There are two machines intended to run real GPU tests for Wine: cw1-hd6800 and cw2-gtx560. For now they are only used to run WineTest daily on Windows 8.1, Windows 10 1507, 1709, 1809 and Linux. That's quite a bunch but it would be much better if they were integrated with the TestBot as that would allow developers to submit their own tests. So I had a look at what it would imply to convert them to VM hosts using QEmu + PCI-passthrough. * First one needs a processor with hardware virtualisation support. For Intel that's VT-d. Both machines have an Intel Core 2600 which supports VT-d. Good. * Second the motherboard too needs to support VT-d. Both machines have an ASRock P67 Extreme4 motherboard. Unfortunately UEFI says "unsupported" next to the "VT-d" setting for the motherboard :-( It looks like there was some confusion as to whether the P67 chipset supported VT-d initially. From what I gathered it's only Q67 that does but this caused some manufacturers, among which ASRock, to initially claim support and later retract it. * Then one needs to add the intel_iommu=on option to the kernel command line (resp. amd_iommu). This is should make all the PCI devices appear in /sys/kernel/iommu_groups. But that folder remains empty which confirms that full VT-d support is missing. * Another important aspect is to have a graphics card which is hot-restartable. In some cases when a VM's graphics card is crashed the only way to reset it is to reboot the host. The TestBot is likely to crash the graphics card, particularly if we do a hard-power off on the VMs like we currently do, and it would relaly be annoying to have to reboot the host everytime the graphics card goes belly up. I don't know if the AMD HD6800 and Nvidia GTX560 are suitable but it's quite possible they are not. All I know for now is that we should avoid AMD's R9 line of graphics cards. I still need to find a couple of suitable reasonably lower power graphics cards: one AMD and one Nvidia. * Then one needs to prevent the host from using the graphics card. Usually that's done by having the host use the processor's IGP and dedicating the discrete GPU to the VMs. Unfortunately the 2600's IGP cannot be active when there's a discrete card so that route is denied to us. Fortunately there's quite a bit of documentation on how to shut down not just X but also the Linux virtual consoles to free the GPU and hand it over to the VMs after boot. Doing so means losing KVM access to the host which is a bit annoying in case something goes wrong. So ideally we'd make sure this does not happen in grub's "safe mode" boot option. * Although I have not done any test yet I'm reasonably certain that PCI-passthrough rules out live snapshots: QEmu would have no way to restore the graphics card's internal state. - For Windows VMs that's not an issue: if we provide a power off snapshot the TestBot already knows how to power on the VM and wait for it to boot (as long as the boot is shorter than the connection timeout but it works out usually). - For Linux VM's that's more of an issue: the TestBot will power on the VM as usual. The problem is when it updates Wine: after recompiling everything it deletes the old snapshot and creates a new one from the current state of the VM, which means a live snapshot. So the TestBot will need to be modified so it knows when and how to power off the VM and take a powered off snapshot. * Since the VM has full control of the graphics card QEmu has no access to the content of the screen. That's not an issue for the normal TestBot operation, just for the initial VM setup. Fortunately the graphics card is connected to a KVM so the screen can be accessed through that means. It does mean assigning the mouse and keyboard to the VM too. Should that prove impractical there are a bunch of other options too: VNC, LookingGlass, Synergy, etc. But the less needs to be installed in the VMs the better. * Also the TestBot uses QEmu to take the screenshots. But QEmu does not have access to the content of the screen. The fix is to use a tool to take the screenshots from within the VM and use TestAgent to retrieve them. On Linux there are standard tools we can use. On Windows there's code floating around we can use. So the next steps would be: * Maybe test on my box using the builtin IGP. But that likely won't be very conclusive beyond confirming the snapshot issues, screen access, etc. * Find a suitable AMD or Nvidia graphics card and test that on my box. That would allow me to fully test integration with the TestBot, check for stability issues, etc. * Then see what can be done with the existing cw1 and cw2 boxes. -- Francois Gouget <fgouget(a)codeweavers.com>

4 10

About GSoC
by Alex 03 Mar '20

03 Mar '20

So, I have this idea of replacing Winetricks with something more beautiful, responsive and functional. I have been developing Wineglass independently as an elementaryOS app (https://github.com/aggalex/Wineglass) and I want to expand it and integrate it with wine in a much better way. If possible, could you inform me about wine's GSoC program? Do you believe such a project is suitable for wine and GSoC?

3 3

[PATCH v2 1/4] d3dcompiler: Get rid of the "node" field from struct hlsl_ir_function_decl.
by Zebediah Figura 05 Feb '20

05 Feb '20

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/d3dcompiler_43/d3dcompiler_private.h | 4 ++-- dlls/d3dcompiler_43/hlsl.y | 20 ++++++++++---------- dlls/d3dcompiler_43/utils.c | 4 +--- 3 files changed, 13 insertions(+), 15 deletions(-) diff --git a/dlls/d3dcompiler_43/d3dcompiler_private.h b/dlls/d3dcompiler_43/d3dcompiler_private.h index 1ab343de2d8..01f6ce0e60a 100644 --- a/dlls/d3dcompiler_43/d3dcompiler_private.h +++ b/dlls/d3dcompiler_43/d3dcompiler_private.h @@ -712,7 +712,6 @@ enum hlsl_ir_node_type HLSL_IR_CONSTRUCTOR, HLSL_IR_DEREF, HLSL_IR_EXPR, - HLSL_IR_FUNCTION_DECL, HLSL_IR_IF, HLSL_IR_LOOP, HLSL_IR_JUMP, @@ -776,7 +775,8 @@ struct hlsl_ir_function struct hlsl_ir_function_decl { - struct hlsl_ir_node node; + struct hlsl_type *return_type; + struct source_location loc; struct wine_rb_entry entry; struct hlsl_ir_function *func; const char *semantic; diff --git a/dlls/d3dcompiler_43/hlsl.y b/dlls/d3dcompiler_43/hlsl.y index 5585b899463..7c14ad0091c 100644 --- a/dlls/d3dcompiler_43/hlsl.y +++ b/dlls/d3dcompiler_43/hlsl.y @@ -1084,28 +1084,28 @@ hlsl_prog: /* empty */ { if (decl->body && $2.decl->body) { - hlsl_report_message($2.decl->node.loc.file, $2.decl->node.loc.line, - $2.decl->node.loc.col, HLSL_LEVEL_ERROR, + hlsl_report_message($2.decl->loc.file, $2.decl->loc.line, + $2.decl->loc.col, HLSL_LEVEL_ERROR, "redefinition of function %s", debugstr_a($2.name)); YYABORT; } - else if (!compare_hlsl_types(decl->node.data_type, $2.decl->node.data_type)) + else if (!compare_hlsl_types(decl->return_type, $2.decl->return_type)) { - hlsl_report_message($2.decl->node.loc.file, $2.decl->node.loc.line, - $2.decl->node.loc.col, HLSL_LEVEL_ERROR, + hlsl_report_message($2.decl->loc.file, $2.decl->loc.line, + $2.decl->loc.col, HLSL_LEVEL_ERROR, "redefining function %s with a different return type", debugstr_a($2.name)); - hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_NOTE, + hlsl_report_message(decl->loc.file, decl->loc.line, decl->loc.col, HLSL_LEVEL_NOTE, "%s previously declared here", debugstr_a($2.name)); YYABORT; } } - if ($2.decl->node.data_type->base_type == HLSL_TYPE_VOID && $2.decl->semantic) + if ($2.decl->return_type->base_type == HLSL_TYPE_VOID && $2.decl->semantic) { - hlsl_report_message($2.decl->node.loc.file, $2.decl->node.loc.line, - $2.decl->node.loc.col, HLSL_LEVEL_ERROR, + hlsl_report_message($2.decl->loc.file, $2.decl->loc.line, + $2.decl->loc.col, HLSL_LEVEL_ERROR, "void function with a semantic"); } @@ -1280,7 +1280,7 @@ func_prototype: var_modifiers type var_identifier '(' parameters ')' c } $$.name = $3; $$.decl->semantic = $7.semantic; - set_location(&$$.decl->node.loc, &@3); + set_location(&$$.decl->loc, &@3); } compound_statement: '{' '}' diff --git a/dlls/d3dcompiler_43/utils.c b/dlls/d3dcompiler_43/utils.c index 5ecbbc9dc1d..ad2d02e1452 100644 --- a/dlls/d3dcompiler_43/utils.c +++ b/dlls/d3dcompiler_43/utils.c @@ -1577,8 +1577,7 @@ struct hlsl_ir_function_decl *new_func_decl(struct hlsl_type *return_type, struc ERR("Out of memory.\n"); return NULL; } - decl->node.type = HLSL_IR_FUNCTION_DECL; - decl->node.data_type = return_type; + decl->return_type = return_type; decl->parameters = parameters; return decl; @@ -1775,7 +1774,6 @@ static const char *debug_node_type(enum hlsl_ir_node_type type) "HLSL_IR_CONSTRUCTOR", "HLSL_IR_DEREF", "HLSL_IR_EXPR", - "HLSL_IR_FUNCTION_DECL", "HLSL_IR_IF", "HLSL_IR_JUMP", "HLSL_IR_SWIZZLE", -- 2.20.1

2 5

[PATCH v3 1/2] ntdll: Try mapping free memory region outside of reserved regions.
by Rémi Bernon 17 Dec '19

17 Dec '19

We assumed that all mapped regions are known by Wine view tree, which is obviously not the case with external allocations. This could lead to memory corruption when find_free_area returns an expected free region which is already mapped. Using MAP_FIXED forces mmap to succeed and corrupts the mapping. This patch uses safe mmap calls to check if the expected free memory is actually free, and iterates over the expected free ranges until it succeeds. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/ntdll/virtual.c | 64 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 53 insertions(+), 11 deletions(-) diff --git a/dlls/ntdll/virtual.c b/dlls/ntdll/virtual.c index 68249de902e..60838c68a55 100644 --- a/dlls/ntdll/virtual.c +++ b/dlls/ntdll/virtual.c @@ -496,6 +496,35 @@ static struct file_view *find_view_range( const void *addr, size_t size ) return NULL; } +/*********************************************************************** + * try_map_free_area + * + * Try mmaping some expected free memory region, eventually stepping and + * retrying inside it, and return where it actually succeeded, or NULL. + */ +static void* try_map_free_area( void *base, void *end, ptrdiff_t step, + void *start, size_t size, int unix_prot ) +{ + void *ptr; + + while (start && base <= start && (char*)start + size <= (char*)end) + { + if ((ptr = wine_anon_mmap( start, size, unix_prot, 0 )) == start) + return start; + TRACE( "Found free area is already mapped, start %p.\n", start ); + + if (ptr != (void *)-1) + munmap( ptr, size ); + + if ((step > 0 && (char *)end - (char *)start < step) || + (step < 0 && (char *)start - (char *)base < -step) || + step == 0) + break; + start = (char *)start + step; + } + + return NULL; +} /*********************************************************************** * find_free_area @@ -503,9 +532,11 @@ static struct file_view *find_view_range( const void *addr, size_t size ) * Find a free area between views inside the specified range. * The csVirtual section must be held by caller. */ -static void *find_free_area( void *base, void *end, size_t size, size_t mask, int top_down ) +static void *find_free_area( void *base, void *end, size_t size, size_t mask, int top_down, + int map_area, int unix_prot ) { struct wine_rb_entry *first = NULL, *ptr = views_tree.root; + ptrdiff_t step = top_down ? -(mask + 1) : (mask + 1); void *start; /* find the first (resp. last) view inside the range */ @@ -538,7 +569,10 @@ static void *find_free_area( void *base, void *end, size_t size, size_t mask, in { struct file_view *view = WINE_RB_ENTRY_VALUE( first, struct file_view, entry ); - if ((char *)view->base + view->size <= (char *)start) break; + if (!map_area && (char *)view->base + view->size <= (char *)start) break; + if (map_area && (start = try_map_free_area( (char *)view->base + view->size, + (char *)start + size, step, + start, size, unix_prot ))) break; start = ROUND_ADDR( (char *)view->base - size, mask ); /* stop if remaining space is not large enough */ if (!start || start >= end || start < base) return NULL; @@ -554,13 +588,17 @@ static void *find_free_area( void *base, void *end, size_t size, size_t mask, in { struct file_view *view = WINE_RB_ENTRY_VALUE( first, struct file_view, entry ); - if ((char *)view->base >= (char *)start + size) break; + if (!map_area && (char *)view->base >= (char *)start + size) break; + if (map_area && (start = try_map_free_area( start, view->base, step, + start, size, unix_prot ))) break; start = ROUND_ADDR( (char *)view->base + view->size + mask, mask ); /* stop if remaining space is not large enough */ if (!start || start >= end || (char *)end - (char *)start < size) return NULL; first = wine_rb_next( first ); } } + + if (!first && map_area) return try_map_free_area( base, end, step, start, size, unix_prot ); return start; } @@ -1054,13 +1092,13 @@ static int alloc_reserved_area_callback( void *start, size_t size, void *arg ) { /* range is split in two by the preloader reservation, try first part */ if ((alloc->result = find_free_area( start, preload_reserve_start, alloc->size, - alloc->mask, alloc->top_down ))) + alloc->mask, alloc->top_down, FALSE, 0 ))) return 1; /* then fall through to try second part */ start = preload_reserve_end; } } - if ((alloc->result = find_free_area( start, end, alloc->size, alloc->mask, alloc->top_down ))) + if ((alloc->result = find_free_area( start, end, alloc->size, alloc->mask, alloc->top_down, FALSE, 0 ))) return 1; return 0; @@ -1148,6 +1186,7 @@ static NTSTATUS map_view( struct file_view **view_ret, void *base, size_t size, { size_t view_size = size + mask + 1; struct alloc_area alloc; + int unix_prot = VIRTUAL_GetUnixProt(vprot); alloc.size = size; alloc.mask = mask; @@ -1158,19 +1197,22 @@ static NTSTATUS map_view( struct file_view **view_ret, void *base, size_t size, { ptr = alloc.result; TRACE( "got mem in reserved area %p-%p\n", ptr, (char *)ptr + size ); - if (wine_anon_mmap( ptr, size, VIRTUAL_GetUnixProt(vprot), MAP_FIXED ) != ptr) + if (wine_anon_mmap( ptr, size, unix_prot, MAP_FIXED ) != ptr) return STATUS_INVALID_PARAMETER; goto done; } - for (;;) + if (zero_bits_64) { - if (!zero_bits_64) - ptr = NULL; - else if (!(ptr = find_free_area( (void*)0, alloc.limit, view_size, mask, top_down ))) + if (!(ptr = find_free_area( (void*)0, alloc.limit, size, mask, top_down, TRUE, unix_prot ))) return STATUS_NO_MEMORY; + TRACE( "got mem with find_free_area %p-%p\n", ptr, (char *)ptr + size ); + goto done; + } - if ((ptr = wine_anon_mmap( ptr, view_size, VIRTUAL_GetUnixProt(vprot), ptr ? MAP_FIXED : 0 )) == (void *)-1) + for (;;) + { + if ((ptr = wine_anon_mmap( NULL, view_size, unix_prot, 0 )) == (void *)-1) { if (errno == ENOMEM) return STATUS_NO_MEMORY; return STATUS_INVALID_PARAMETER; -- 2.24.0.rc2

1 2

[PATCH v2 1/6] ddraw: Track some more render states in the primary stateblock.
by Zebediah Figura 10 Dec '19

10 Dec '19

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ddraw/device.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/dlls/ddraw/device.c b/dlls/ddraw/device.c index 51576c81e28..def3e7c2a43 100644 --- a/dlls/ddraw/device.c +++ b/dlls/ddraw/device.c @@ -3555,6 +3555,7 @@ static void setup_lighting(const struct d3d_device *device, DWORD fvf, DWORD fla if (!device->material || !(fvf & D3DFVF_NORMAL) || (flags & D3DDP_DONOTLIGHT)) enable = FALSE; + wined3d_stateblock_set_render_state(device->state, WINED3D_RS_LIGHTING, enable); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_LIGHTING, enable); } @@ -7033,11 +7034,18 @@ static HRESULT d3d_device_init(struct d3d_device *device, struct ddraw *ddraw, wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_ZENABLE, d3d_device_update_depth_stencil(device)); if (version == 1) /* Color keying is initially enabled for version 1 devices. */ + { + wined3d_stateblock_set_render_state(ddraw->state, WINED3D_RS_COLORKEYENABLE, TRUE); wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_COLORKEYENABLE, TRUE); + } else if (version == 2) + { + wined3d_stateblock_set_render_state(ddraw->state, WINED3D_RS_SPECULARENABLE, TRUE); wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_SPECULARENABLE, TRUE); + } if (version < 7) { + wined3d_stateblock_set_render_state(ddraw->state, WINED3D_RS_NORMALIZENORMALS, TRUE); wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_NORMALIZENORMALS, TRUE); IDirect3DDevice3_SetRenderState(&device->IDirect3DDevice3_iface, D3DRENDERSTATE_TEXTUREMAPBLEND, D3DTBLEND_MODULATE); -- 2.23.0

4 17

Wine staging 4.21 release
by Alistair Leslie-Hughes 04 Dec '19

04 Dec '19

Binary packages for various distributions will be available from: https://www.winehq.org/download Summary since last release * Rebased to current wine 4.21 (833 patches are applied to wine vanilla) Upstreamed (Either directly from staging or fixed with a similar patch). * none Added: * [47668] kernelbase: Improve stub for ReOpenFile and add small test * [48138] League of Legends 9.23: Crash after champ select * [47970] Legends of Runeterra crashes at launch * [40334] AION - Wine /Unhandled exception: page fault on read access to 0x00000000 in 64-bit code (0x0000000000000000). * [48175] AION (64 bit) - crashes in crysystem.dll.CryFree() due to high memory pointers allocated * [46568] 64-bit msxml6.dll from Microsoft Core XML Services 6.0 redist package fails to load (Wine doesn't respect 44-bit user-mode VA limitation from Windows < 8.1) Updated: * d3d9-Direct3DShaderValidatorCreate9 * winecfg-Staging Where can you help * Run Steam/Battle.net/GOG/UPlay/Epic * Test your favorite game. * Test your favorite applications. * Improve staging patches and get them accepted upstream. As always, if you find a bug, please report it via https://bugs.winehq.org Best Regards Alistair.

2 1

LONG_PTR and friends
by Zebediah Figura 04 Dec '19

04 Dec '19

Moving modules to use msvcrt has had the unfortunate side effect that tracing LONG_PTR/DWORD_PTR/etc. using %ld no longer works—since a long is 32 bits wide as far as msvcrt is concerned, it cuts off top 32 bits on 64-bit platforms. This has already caused me some grief while debugging. I'm not sure what we can use in its place, though: * Our msvcrt supports the standard %z, %j, %t. I originally assumed this would work, but unfortunately it seems native msvcrt only supports this on 64-bit and only in very recent versions of Windows. mingw-w64 accordingly spits out warnings if we try to use it in 32-bit code. I think ucrtbase always supports them, but only some modules use ucrtbase (and especially considering e.g. tests I doubt that converting everything else to use ucrtbase is a good idea). * Both builtin and native msvcrt always support %I, but it's nonstandard and it spits out warnings when you try to use it when not compiling with mingw. * PRIxPTR (etc.) almost works, except that on 32-bit both mingw and the native compiler spit out warnings because it expands to "x" while the type is defined as "long int". * Along those lines I guess we could define our own PRI-type macro... * We could also cast to (void *), or cast to a 64-bit type and use wine_dbgstr_longlong(), though this has the unfortunate side effect of forcing us to trace in hexadecimal.

2 2

[PATCH] wininet/tests: Increase the maximum expected available data value.
by Francois Gouget 04 Dec '19

04 Dec '19

With each Windows version InternetQueryDataAvailable() reports a different value. 8192 from XP/2003 to Vista/2008; then 1460 from Windows 7 to Windows 10 1709; and 24000 starting with Windows 10 1809. Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- This fixes a failure on Windows 10 1809. I'm not entirely sure it makes sense to check for this value. If we do, maybe we should leave a bigger margin? Like < 31000? Not that it did us much good last time... Also, shouldn't we check that it is greater than some minimum value? Like at least 1000? References: https://test.winehq.org/data/190fb605c34ac1365076dff0a6560ddb42ca1ef2/index… Look for the entries with 4 failures. https://testbot.winehq.org/JobDetails.pl?Key=60767 Look for the 'avail=' traces. dlls/wininet/tests/http.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/wininet/tests/http.c b/dlls/wininet/tests/http.c index c7472c7ea09..a72c9ed0518 100644 --- a/dlls/wininet/tests/http.c +++ b/dlls/wininet/tests/http.c @@ -5549,9 +5549,9 @@ static void test_http_read(int port) readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "123", 0); readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); - send_response_len_and_wait(20000, TRUE, &ib); + send_response_len_and_wait(32000, TRUE, &ib); avail = expect_data_available(req.request, -1); - ok(avail < 17000, "avail = %u\n", avail); + ok(avail < 25000, "avail = %u\n", avail); SET_WINE_ALLOW(INTERNET_STATUS_CLOSING_CONNECTION); SET_WINE_ALLOW(INTERNET_STATUS_CONNECTION_CLOSED); -- 2.20.1

3 2