wine-commits March 2022

wine-commits@winehq.org

2 participants
1138 discussions

Jinoh Kang : server: Replace redundant send_socket status fields with force_async boolean field.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: 731a96800308ff9f4a1616c948bb58f6d5ecef9c URL: https://source.winehq.org/git/wine.git/?a=commit;h=731a96800308ff9f4a1616c9… Author: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Date: Thu Mar 24 02:25:28 2022 +0900 server: Replace redundant send_socket status fields with force_async boolean field. The 'status' field of send_socket_request is always either STATUS_PENDING or STATUS_DEVICE_NOT_READY, and the 'total' field is always zero. Replace the 'status' field with 'force_async' boolean field, and get rid of the 'total' field entirely. Also, clean up the send_socket handler code a bit. Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/ntdll/unix/socket.c | 8 ++------ include/wine/server_protocol.h | 6 +++--- server/protocol.def | 3 +-- server/request.h | 3 +-- server/sock.c | 41 +++++++++++------------------------------ server/trace.c | 3 +-- 6 files changed, 19 insertions(+), 45 deletions(-) diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index 8e5a1825181..351028d4983 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -908,12 +908,9 @@ static NTSTATUS sock_send( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi async->iov_cursor = 0; async->sent_len = 0; - status = force_async ? STATUS_PENDING : STATUS_DEVICE_NOT_READY; - SERVER_START_REQ( send_socket ) { - req->status = status; - req->total = 0; + req->force_async = force_async; req->async = server_async( handle, &async->io, event, apc, apc_user, iosb_client_ptr(io) ); status = wine_server_call( req ); wait_handle = wine_server_ptr_handle( reply->wait ); @@ -1116,8 +1113,7 @@ static NTSTATUS sock_transmit( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, SERVER_START_REQ( send_socket ) { - req->status = STATUS_PENDING; - req->total = 0; + req->force_async = 1; req->async = server_async( handle, &async->io, event, apc, apc_user, iosb_client_ptr(io) ); status = wine_server_call( req ); wait_handle = wine_server_ptr_handle( reply->wait ); diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index b3a5d3ef3d5..6cd901f1e56 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -1783,8 +1783,8 @@ struct send_socket_request struct request_header __header; char __pad_12[4]; async_data_t async; - unsigned int status; - unsigned int total; + int force_async; + char __pad_60[4]; }; struct send_socket_reply { @@ -6286,7 +6286,7 @@ union generic_reply /* ### protocol_version begin ### */ -#define SERVER_PROTOCOL_VERSION 748 +#define SERVER_PROTOCOL_VERSION 749 /* ### protocol_version end ### */ diff --git a/server/protocol.def b/server/protocol.def index 81b44aefd7c..d9bed6855e9 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -1462,8 +1462,7 @@ enum server_fd_type /* Perform a send on a socket */ @REQ(send_socket) async_data_t async; /* async I/O parameters */ - unsigned int status; /* status of initial call */ - unsigned int total; /* number of bytes already sent */ + int force_async; /* Force asynchronous mode? */ @REPLY obj_handle_t wait; /* handle to wait on for blocking send */ unsigned int options; /* device open options */ diff --git a/server/request.h b/server/request.h index 32929c146a0..ca99acbdbf6 100644 --- a/server/request.h +++ b/server/request.h @@ -1051,8 +1051,7 @@ C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, options) == 12 ); C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, nonblocking) == 16 ); C_ASSERT( sizeof(struct recv_socket_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct send_socket_request, async) == 16 ); -C_ASSERT( FIELD_OFFSET(struct send_socket_request, status) == 56 ); -C_ASSERT( FIELD_OFFSET(struct send_socket_request, total) == 60 ); +C_ASSERT( FIELD_OFFSET(struct send_socket_request, force_async) == 56 ); C_ASSERT( sizeof(struct send_socket_request) == 64 ); C_ASSERT( FIELD_OFFSET(struct send_socket_reply, wait) == 8 ); C_ASSERT( FIELD_OFFSET(struct send_socket_reply, options) == 12 ); diff --git a/server/sock.c b/server/sock.c index e3779940174..b403541fcbf 100644 --- a/server/sock.c +++ b/server/sock.c @@ -3508,10 +3508,11 @@ static void send_socket_completion_callback( void *private ) DECL_HANDLER(send_socket) { struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops ); - unsigned int status = req->status; + unsigned int status = STATUS_PENDING; timeout_t timeout = 0; struct async *async; struct fd *fd; + int bind_errno = 0; if (!sock) return; fd = sock->fd; @@ -3520,7 +3521,6 @@ DECL_HANDLER(send_socket) { union unix_sockaddr unix_addr; socklen_t unix_len; - int bind_errno = 0; int unix_fd = get_unix_fd( fd ); unix_len = get_unix_sockaddr_any( &unix_addr, sock->family ); @@ -3532,36 +3532,15 @@ DECL_HANDLER(send_socket) sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) ); sock->bound = 1; } - else if (status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) - status = sock_get_ntstatus( bind_errno ? bind_errno : errno ); + else if (!bind_errno) bind_errno = errno; } - /* If we had a short write and the socket is nonblocking (and the client is - * not trying to force the operation to be asynchronous), return success. - * Windows actually refuses to send any data in this case, and returns - * EWOULDBLOCK, but we have no way of doing that. */ - if (status == STATUS_DEVICE_NOT_READY && req->total && sock->nonblocking) - status = STATUS_SUCCESS; - - /* send() returned EWOULDBLOCK or a short write, i.e. cannot send all data yet */ - if (status == STATUS_DEVICE_NOT_READY && !sock->nonblocking) - { - /* Set a timeout on the async if necessary. - * - * We want to do this *only* if the client gave us STATUS_DEVICE_NOT_READY. - * If the client gave us STATUS_PENDING, it expects the async to always - * block (it was triggered by WSASend*() with a valid OVERLAPPED - * structure) and for the timeout not to be respected. */ - if (is_fd_overlapped( fd )) - timeout = (timeout_t)sock->sndtimeo * -10000; - - status = STATUS_PENDING; - } - - if ((status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) && sock->wr_shutdown) - status = STATUS_PIPE_DISCONNECTED; + if (!req->force_async && !sock->nonblocking && is_fd_overlapped( fd )) + timeout = (timeout_t)sock->sndtimeo * -10000; - if ((status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) && !async_queued( &sock->write_q )) + if (bind_errno) status = sock_get_ntstatus( bind_errno ); + else if (sock->wr_shutdown) status = STATUS_PIPE_DISCONNECTED; + else if (!async_queued( &sock->write_q )) { /* If write_q is not empty, we cannot really tell if the already queued * asyncs will not consume all available space; if there's no space @@ -3580,6 +3559,9 @@ DECL_HANDLER(send_socket) } } + if (status == STATUS_PENDING && !req->force_async && sock->nonblocking) + status = STATUS_DEVICE_NOT_READY; + if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async ))) { struct send_req *send_req; @@ -3594,7 +3576,6 @@ DECL_HANDLER(send_socket) else if (status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) status = STATUS_NO_MEMORY; - if (status == STATUS_SUCCESS) iosb->result = req->total; release_object( iosb ); set_error( status ); diff --git a/server/trace.c b/server/trace.c index 8653755e8a6..a792b74dc05 100644 --- a/server/trace.c +++ b/server/trace.c @@ -2045,8 +2045,7 @@ static void dump_recv_socket_reply( const struct recv_socket_reply *req ) static void dump_send_socket_request( const struct send_socket_request *req ) { dump_async_data( " async=", &req->async ); - fprintf( stderr, ", status=%08x", req->status ); - fprintf( stderr, ", total=%08x", req->total ); + fprintf( stderr, ", force_async=%d", req->force_async ); } static void dump_send_socket_reply( const struct send_socket_reply *req )

1 0

Jinoh Kang : ntdll: Don't call try_send before server call in sock_send.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: 74059d12b83e9f6d6fd64556ba11d7b5331d5d00 URL: https://source.winehq.org/git/wine.git/?a=commit;h=74059d12b83e9f6d6fd64556… Author: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Date: Thu Mar 24 02:25:25 2022 +0900 ntdll: Don't call try_send before server call in sock_send. Otherwise, try_send() call from sock_send() may race against try_send() call from async_send_proc(), shuffling the packet order. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=52401 Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/ntdll/unix/socket.c | 13 ++----------- dlls/ws2_32/tests/sock.c | 14 +++++++------- 2 files changed, 9 insertions(+), 18 deletions(-) diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index 62920a7e557..8e5a1825181 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -908,21 +908,12 @@ static NTSTATUS sock_send( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi async->iov_cursor = 0; async->sent_len = 0; - status = try_send( fd, async ); - - if (status != STATUS_SUCCESS && status != STATUS_DEVICE_NOT_READY) - { - release_fileio( &async->io ); - return status; - } - - if (status == STATUS_DEVICE_NOT_READY && force_async) - status = STATUS_PENDING; + status = force_async ? STATUS_PENDING : STATUS_DEVICE_NOT_READY; SERVER_START_REQ( send_socket ) { req->status = status; - req->total = async->sent_len; + req->total = 0; req->async = server_async( handle, &async->io, event, apc, apc_user, iosb_client_ptr(io) ); status = wine_server_call( req ); wait_handle = wine_server_ptr_handle( reply->wait ); diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c index cc74e301f60..d501930b32d 100644 --- a/dlls/ws2_32/tests/sock.c +++ b/dlls/ws2_32/tests/sock.c @@ -8010,7 +8010,7 @@ static void test_shutdown(void) WSASetLastError(0xdeadbeef); ret = send(client, "test", 5, 0); ok(ret == -1, "got %d\n", ret); - todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); + ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); ret = recv(server, buffer, sizeof(buffer), 0); ok(!ret, "got %d\n", ret); @@ -8057,7 +8057,7 @@ static void test_shutdown(void) WSASetLastError(0xdeadbeef); ret = send(server, "test", 5, 0); ok(ret == -1, "got %d\n", ret); - todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); + ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); addrlen = sizeof(addr); ret = getpeername(client, (struct sockaddr *)&addr, &addrlen); @@ -8107,7 +8107,7 @@ static void test_shutdown(void) WSASetLastError(0xdeadbeef); ret = send(client, "test", 5, 0); ok(ret == -1, "got %d\n", ret); - todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); + ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); ret = recv(server, buffer, sizeof(buffer), 0); ok(!ret, "got %d\n", ret); @@ -8125,7 +8125,7 @@ static void test_shutdown(void) WSASetLastError(0xdeadbeef); ret = send(server, "test", 5, 0); ok(ret == -1, "got %d\n", ret); - todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); + ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); addrlen = sizeof(addr); ret = getpeername(client, (struct sockaddr *)&addr, &addrlen); @@ -8256,7 +8256,7 @@ static void test_shutdown(void) WSASetLastError(0xdeadbeef); ret = sendto(client, "test", 5, 0, (struct sockaddr *)&server_addr, sizeof(server_addr)); ok(ret == -1, "got %d\n", ret); - todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); + ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); closesocket(client); closesocket(server); @@ -8337,7 +8337,7 @@ static void test_DisconnectEx(void) WSASetLastError(0xdeadbeef); ret = send(client, "test", 5, 0); ok(ret == -1, "expected failure\n"); - todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); + ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); ret = recv(server, buffer, sizeof(buffer), 0); ok(!ret, "got %d\n", ret); @@ -8391,7 +8391,7 @@ static void test_DisconnectEx(void) WSASetLastError(0xdeadbeef); ret = send(client, "test", 5, 0); ok(ret == -1, "expected failure\n"); - todo_wine ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); + ok(WSAGetLastError() == WSAESHUTDOWN, "got error %u\n", WSAGetLastError()); ret = recv(server, buffer, sizeof(buffer), 0); ok(!ret, "got %d\n", ret);

1 0

Jinoh Kang : server: Ensure datagram sockets are bound in send_socket.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: 0ac256eacc9cd67d689bdc0956315670cd60dfbc URL: https://source.winehq.org/git/wine.git/?a=commit;h=0ac256eacc9cd67d689bdc09… Author: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Date: Thu Mar 24 02:25:20 2022 +0900 server: Ensure datagram sockets are bound in send_socket. If the type of the socket is SOCK_DGRAM, it shall always be bound to an address if we ever attempt to send datagrams through the socket, whether the attempt succeeds or not. Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- server/sock.c | 45 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 40 insertions(+), 5 deletions(-) diff --git a/server/sock.c b/server/sock.c index 1beff85cbe0..e3779940174 100644 --- a/server/sock.c +++ b/server/sock.c @@ -471,6 +471,32 @@ static socklen_t sockaddr_to_unix( const struct WS_sockaddr *wsaddr, int wsaddrl } } +static socklen_t get_unix_sockaddr_any( union unix_sockaddr *uaddr, int ws_family ) +{ + memset( uaddr, 0, sizeof(*uaddr) ); + switch (ws_family) + { + case WS_AF_INET: + uaddr->in.sin_family = AF_INET; + return sizeof(uaddr->in); + case WS_AF_INET6: + uaddr->in6.sin6_family = AF_INET6; + return sizeof(uaddr->in6); +#ifdef HAS_IPX + case WS_AF_IPX: + uaddr->ipx.sipx_family = AF_IPX; + return sizeof(uaddr->ipx); +#endif +#ifdef HAS_IRDA + case WS_AF_IRDA: + uaddr->irda.sir_family = AF_IRDA; + return sizeof(uaddr->irda); +#endif + default: + return 0; + } +} + /* some events are generated at the same time but must be sent in a particular * order (e.g. CONNECT must be sent before READ) */ static const enum afd_poll_bit event_bitorder[] = @@ -3490,15 +3516,24 @@ DECL_HANDLER(send_socket) if (!sock) return; fd = sock->fd; - if (sock->type == WS_SOCK_DGRAM) + if (sock->type == WS_SOCK_DGRAM && !sock->bound) { - /* sendto() and sendmsg() implicitly binds a socket */ union unix_sockaddr unix_addr; - socklen_t unix_len = sizeof(unix_addr); + socklen_t unix_len; + int bind_errno = 0; + int unix_fd = get_unix_fd( fd ); - if (!sock->bound && !getsockname( get_unix_fd( fd ), &unix_addr.addr, &unix_len )) + unix_len = get_unix_sockaddr_any( &unix_addr, sock->family ); + if (bind( unix_fd, &unix_addr.addr, unix_len ) < 0) + bind_errno = errno; + + if (getsockname( unix_fd, &unix_addr.addr, &unix_len ) >= 0) + { sock->addr_len = sockaddr_from_unix( &unix_addr, &sock->addr.addr, sizeof(sock->addr) ); - sock->bound = 1; + sock->bound = 1; + } + else if (status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) + status = sock_get_ntstatus( bind_errno ? bind_errno : errno ); } /* If we had a short write and the socket is nonblocking (and the client is

1 0

Jinoh Kang : server: Attempt to complete I/O request immediately in send_socket.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: 65d12984f2c5c33d2233d705970d0524f2f5e775 URL: https://source.winehq.org/git/wine.git/?a=commit;h=65d12984f2c5c33d2233d705… Author: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Date: Thu Mar 24 02:25:17 2022 +0900 server: Attempt to complete I/O request immediately in send_socket. Make send_socket alert the async immediately if poll() call detects that there are incoming data in the socket, bypassing the wineserver's main polling loop. For sock_transmit, we always mark the async as pending and set the IOSB (unless async allocation has failed). Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/ntdll/unix/socket.c | 72 +++++++++++++++++++++++++++++++++++------- include/wine/server_protocol.h | 4 ++- server/protocol.def | 1 + server/request.h | 3 +- server/sock.c | 22 ++++++++++++- server/trace.c | 1 + 6 files changed, 89 insertions(+), 14 deletions(-) diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index 2f8bd6e62bf..62920a7e557 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -868,11 +868,13 @@ static NTSTATUS sock_send( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi const struct WS_sockaddr *addr, unsigned int addr_len, int unix_flags, int force_async ) { struct async_send_ioctl *async; + ULONG_PTR information; HANDLE wait_handle; DWORD async_size; NTSTATUS status; unsigned int i; ULONG options; + BOOL nonblocking, alerted; async_size = offsetof( struct async_send_ioctl, iov[count] ); @@ -925,16 +927,38 @@ static NTSTATUS sock_send( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi status = wine_server_call( req ); wait_handle = wine_server_ptr_handle( reply->wait ); options = reply->options; - if ((!NT_ERROR(status) || wait_handle) && status != STATUS_PENDING) + nonblocking = reply->nonblocking; + } + SERVER_END_REQ; + + alerted = status == STATUS_ALERTED; + if (alerted) + { + status = try_send( fd, async ); + if (status == STATUS_DEVICE_NOT_READY && (force_async || !nonblocking)) + status = STATUS_PENDING; + + /* If we had a short write and the socket is nonblocking (and we are + * not trying to force the operation to be asynchronous), return + * success. Windows actually refuses to send any data in this case, + * and returns EWOULDBLOCK, but we have no way of doing that. */ + if (status == STATUS_DEVICE_NOT_READY && async->sent_len) + status = STATUS_SUCCESS; + } + + if (status != STATUS_PENDING) + { + information = async->sent_len; + if (!NT_ERROR(status) || (wait_handle && !alerted)) { io->Status = status; - io->Information = async->sent_len; + io->Information = information; } + release_fileio( &async->io ); } - SERVER_END_REQ; - - if (status != STATUS_PENDING) release_fileio( &async->io ); + else information = 0; + if (alerted) set_async_direct_result( &wait_handle, status, information, FALSE ); if (wait_handle) status = wait_async( wait_handle, options & FILE_SYNCHRONOUS_IO_ALERT ); return status; } @@ -1055,7 +1079,9 @@ static NTSTATUS sock_transmit( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, socklen_t addr_len; HANDLE wait_handle; NTSTATUS status; + ULONG_PTR information; ULONG options; + BOOL alerted; addr_len = sizeof(addr); if (getpeername( fd, &addr.addr, &addr_len ) != 0) @@ -1105,16 +1131,40 @@ static NTSTATUS sock_transmit( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, status = wine_server_call( req ); wait_handle = wine_server_ptr_handle( reply->wait ); options = reply->options; - /* In theory we'd fill the iosb here, as above in sock_send(), but it's - * actually currently impossible to get STATUS_SUCCESS. The server will - * either return STATUS_PENDING or an error code, and in neither case - * should the iosb be filled. */ - if (!status) FIXME( "Unhandled success status." ); } SERVER_END_REQ; - if (status != STATUS_PENDING) release_fileio( &async->io ); + alerted = status == STATUS_ALERTED; + if (alerted) + { + status = try_transmit( fd, file_fd, async ); + if (status == STATUS_DEVICE_NOT_READY) + status = STATUS_PENDING; + } + + if (status != STATUS_PENDING) + { + information = async->head_cursor + async->file_cursor + async->tail_cursor; + if (!NT_ERROR(status) || wait_handle) + { + io->Status = status; + io->Information = information; + } + release_fileio( &async->io ); + } + else information = 0; + if (alerted) + { + set_async_direct_result( &wait_handle, status, information, TRUE ); + if (!(options & (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT))) + { + /* Pretend we always do async I/O. The client can always retrieve + * the actual I/O status via the IO_STATUS_BLOCK. + */ + status = STATUS_PENDING; + } + } if (wait_handle) status = wait_async( wait_handle, options & FILE_SYNCHRONOUS_IO_ALERT ); return status; } diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index 75b48d7601c..b3a5d3ef3d5 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -1791,6 +1791,8 @@ struct send_socket_reply struct reply_header __header; obj_handle_t wait; unsigned int options; + int nonblocking; + char __pad_20[4]; }; @@ -6284,7 +6286,7 @@ union generic_reply /* ### protocol_version begin ### */ -#define SERVER_PROTOCOL_VERSION 747 +#define SERVER_PROTOCOL_VERSION 748 /* ### protocol_version end ### */ diff --git a/server/protocol.def b/server/protocol.def index 66c6c97b1e0..81b44aefd7c 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -1467,6 +1467,7 @@ enum server_fd_type @REPLY obj_handle_t wait; /* handle to wait on for blocking send */ unsigned int options; /* device open options */ + int nonblocking; /* is socket non-blocking? */ @END diff --git a/server/request.h b/server/request.h index 434041490c0..32929c146a0 100644 --- a/server/request.h +++ b/server/request.h @@ -1056,7 +1056,8 @@ C_ASSERT( FIELD_OFFSET(struct send_socket_request, total) == 60 ); C_ASSERT( sizeof(struct send_socket_request) == 64 ); C_ASSERT( FIELD_OFFSET(struct send_socket_reply, wait) == 8 ); C_ASSERT( FIELD_OFFSET(struct send_socket_reply, options) == 12 ); -C_ASSERT( sizeof(struct send_socket_reply) == 16 ); +C_ASSERT( FIELD_OFFSET(struct send_socket_reply, nonblocking) == 16 ); +C_ASSERT( sizeof(struct send_socket_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, signal) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, read) == 20 ); diff --git a/server/sock.c b/server/sock.c index 3e140319965..1beff85cbe0 100644 --- a/server/sock.c +++ b/server/sock.c @@ -3526,6 +3526,25 @@ DECL_HANDLER(send_socket) if ((status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) && sock->wr_shutdown) status = STATUS_PIPE_DISCONNECTED; + if ((status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) && !async_queued( &sock->write_q )) + { + /* If write_q is not empty, we cannot really tell if the already queued + * asyncs will not consume all available space; if there's no space + * available, the current request won't be immediately satiable. + */ + struct pollfd pollfd; + pollfd.fd = get_unix_fd( sock->fd ); + pollfd.events = POLLOUT; + pollfd.revents = 0; + if (poll(&pollfd, 1, 0) >= 0 && pollfd.revents) + { + /* Give the client opportunity to complete synchronously. + * If it turns out that the I/O request is not actually immediately satiable, + * the client may then choose to re-queue the async (with STATUS_PENDING). */ + status = STATUS_ALERTED; + } + } + if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async ))) { struct send_req *send_req; @@ -3548,7 +3567,7 @@ DECL_HANDLER(send_socket) if (timeout) async_set_timeout( async, timeout, STATUS_IO_TIMEOUT ); - if (status == STATUS_PENDING) + if (status == STATUS_PENDING || status == STATUS_ALERTED) { queue_async( &sock->write_q, async ); sock_reselect( sock ); @@ -3556,6 +3575,7 @@ DECL_HANDLER(send_socket) reply->wait = async_handoff( async, NULL, 0 ); reply->options = get_fd_options( fd ); + reply->nonblocking = sock->nonblocking; release_object( async ); } release_object( sock ); diff --git a/server/trace.c b/server/trace.c index 75bc35b6b56..8653755e8a6 100644 --- a/server/trace.c +++ b/server/trace.c @@ -2053,6 +2053,7 @@ static void dump_send_socket_reply( const struct send_socket_reply *req ) { fprintf( stderr, " wait=%04x", req->wait ); fprintf( stderr, ", options=%08x", req->options ); + fprintf( stderr, ", nonblocking=%d", req->nonblocking ); } static void dump_get_next_console_request_request( const struct get_next_console_request_request *req )

1 0

Jinoh Kang : server: Defer clearing events until async is completed in send_socket handler.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: 1c6c90c7e1f1cd011e0ddb1dba47719d61d78fb2 URL: https://source.winehq.org/git/wine.git/?a=commit;h=1c6c90c7e1f1cd011e0ddb1d… Author: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Date: Thu Mar 24 02:25:13 2022 +0900 server: Defer clearing events until async is completed in send_socket handler. This allows the initial I/O to be performed after the send_socket handler is called. Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- server/sock.c | 55 +++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 41 insertions(+), 14 deletions(-) diff --git a/server/sock.c b/server/sock.c index 91f98556552..3e140319965 100644 --- a/server/sock.c +++ b/server/sock.c @@ -153,6 +153,12 @@ struct connect_req unsigned int addr_len, send_len, send_cursor; }; +struct send_req +{ + struct iosb *iosb; + struct sock *sock; +}; + enum connection_state { SOCK_LISTENING, @@ -3454,6 +3460,25 @@ DECL_HANDLER(recv_socket) release_object( sock ); } +static void send_socket_completion_callback( void *private ) +{ + struct send_req *send_req = private; + struct iosb *iosb = send_req->iosb; + struct sock *sock = send_req->sock; + + if (iosb->status != STATUS_SUCCESS) + { + /* send() calls only clear and reselect events if unsuccessful. */ + sock->pending_events &= ~AFD_POLL_WRITE; + sock->reported_events &= ~AFD_POLL_WRITE; + sock_reselect( sock ); + } + + release_object( iosb ); + release_object( sock ); + free( send_req ); +} + DECL_HANDLER(send_socket) { struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops ); @@ -3476,13 +3501,6 @@ DECL_HANDLER(send_socket) sock->bound = 1; } - if (status != STATUS_SUCCESS) - { - /* send() calls only clear and reselect events if unsuccessful. */ - sock->pending_events &= ~AFD_POLL_WRITE; - sock->reported_events &= ~AFD_POLL_WRITE; - } - /* If we had a short write and the socket is nonblocking (and the client is * not trying to force the operation to be asynchronous), return success. * Windows actually refuses to send any data in this case, and returns @@ -3510,22 +3528,31 @@ DECL_HANDLER(send_socket) if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async ))) { - if (status == STATUS_SUCCESS) + struct send_req *send_req; + struct iosb *iosb = async_get_iosb( async ); + + if ((send_req = mem_alloc( sizeof(*send_req) ))) { - struct iosb *iosb = async_get_iosb( async ); - iosb->result = req->total; - release_object( iosb ); + send_req->iosb = (struct iosb *)grab_object( iosb ); + send_req->sock = (struct sock *)grab_object( sock ); + async_set_completion_callback( async, send_socket_completion_callback, send_req ); } + else if (status == STATUS_PENDING || status == STATUS_DEVICE_NOT_READY) + status = STATUS_NO_MEMORY; + + if (status == STATUS_SUCCESS) iosb->result = req->total; + release_object( iosb ); + set_error( status ); if (timeout) async_set_timeout( async, timeout, STATUS_IO_TIMEOUT ); if (status == STATUS_PENDING) + { queue_async( &sock->write_q, async ); - - /* always reselect; we changed reported_events above */ - sock_reselect( sock ); + sock_reselect( sock ); + } reply->wait = async_handoff( async, NULL, 0 ); reply->options = get_fd_options( fd );

1 0

Jinoh Kang : server: Allow async completion callback to retrieve status on synchronous failure.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: e81c2a6af4c2b4103f2e06fd280fee2bf56de1ee URL: https://source.winehq.org/git/wine.git/?a=commit;h=e81c2a6af4c2b4103f2e06fd… Author: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Date: Thu Mar 24 02:25:08 2022 +0900 server: Allow async completion callback to retrieve status on synchronous failure. This also makes async_handoff() behaviour more consistent with async_set_result() for handling I/O failures. Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- server/async.c | 1 + 1 file changed, 1 insertion(+) diff --git a/server/async.c b/server/async.c index a4c9090fa73..a4fbeab555e 100644 --- a/server/async.c +++ b/server/async.c @@ -370,6 +370,7 @@ obj_handle_t async_handoff( struct async *async, data_size_t *result, int force_ if (!async->pending && NT_ERROR( get_error() )) { + async->iosb->status = get_error(); async_call_completion_callback( async ); close_handle( async->thread->process, async->wait_handle );

1 0

Jinoh Kang : server: Generalise async completion callback to be called on synchronous failure.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: 5d98ffe982b3b0ad72dfc938bfbe5bee7e210dcb URL: https://source.winehq.org/git/wine.git/?a=commit;h=5d98ffe982b3b0ad72dfc938… Author: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Date: Thu Mar 24 02:25:04 2022 +0900 server: Generalise async completion callback to be called on synchronous failure. Today, async_set_completion_callback() is used to register a function that is called when the async I/O is completed. It is assumed that the async will eventually be queued when such callback is registered. However, this incurs extra complexity in future code that needs the completion logic to be invoked even if the async is never actually queued (e.g. when the I/O failed synchronously before async_handoff). Generalise async completion callback by calling it in async_handoff() when the I/O status indicates failure. Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- server/async.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/server/async.c b/server/async.c index a92798fcd39..a4c9090fa73 100644 --- a/server/async.c +++ b/server/async.c @@ -322,6 +322,13 @@ void async_wake_obj( struct async *async ) } } +static void async_call_completion_callback( struct async *async ) +{ + if (async->completion_callback) + async->completion_callback( async->completion_callback_private ); + async->completion_callback = NULL; +} + /* return async object status and wait handle to client */ obj_handle_t async_handoff( struct async *async, data_size_t *result, int force_blocking ) { @@ -363,6 +370,8 @@ obj_handle_t async_handoff( struct async *async, data_size_t *result, int force_ if (!async->pending && NT_ERROR( get_error() )) { + async_call_completion_callback( async ); + close_handle( async->thread->process, async->wait_handle ); async->wait_handle = 0; return 0; @@ -528,9 +537,7 @@ void async_set_result( struct object *obj, unsigned int status, apc_param_t tota wake_up( &async->obj, 0 ); } - if (async->completion_callback) - async->completion_callback( async->completion_callback_private ); - async->completion_callback = NULL; + async_call_completion_callback( async ); if (async->queue) {

1 0

Hans Leidekker : crypt32: Add partial support for decoding OCSP_BASIC_RESPONSE_INFO structures.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: f04b10248480e4afae7424d1ff3506134b2996ef URL: https://source.winehq.org/git/wine.git/?a=commit;h=f04b10248480e4afae7424d1… Author: Hans Leidekker <hans(a)codeweavers.com> Date: Fri Mar 25 14:18:07 2022 +0100 crypt32: Add partial support for decoding OCSP_BASIC_RESPONSE_INFO structures. Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/crypt32/decode.c | 243 ++++++++++++++++++++++++++++++++++++++++++++ dlls/crypt32/tests/encode.c | 58 +++++++++++ 2 files changed, 301 insertions(+) Diff: https://source.winehq.org/git/wine.git/?a=commitdiff;h=f04b10248480e4afae74…

1 0

Rémi Bernon : kernelbase: Fix GlobalMemoryStatusEx counters.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: bb1758323970f947623b51253b578652f42f1858 URL: https://source.winehq.org/git/wine.git/?a=commit;h=bb1758323970f947623b5125… Author: Rémi Bernon <rbernon(a)codeweavers.com> Date: Fri Mar 25 13:56:53 2022 +0100 kernelbase: Fix GlobalMemoryStatusEx counters. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/kernel32/tests/heap.c | 4 ---- dlls/kernelbase/memory.c | 13 ++++++++----- dlls/ntdll/unix/system.c | 4 ++++ 3 files changed, 12 insertions(+), 9 deletions(-) diff --git a/dlls/kernel32/tests/heap.c b/dlls/kernel32/tests/heap.c index c36d9331bef..6efe4da4634 100644 --- a/dlls/kernel32/tests/heap.c +++ b/dlls/kernel32/tests/heap.c @@ -1266,17 +1266,13 @@ static void test_GlobalMemoryStatus(void) expect.ullAvailExtendedVirtual = 0; ok( memex.dwMemoryLoad == expect.dwMemoryLoad, "got dwMemoryLoad %lu\n", memex.dwMemoryLoad ); - todo_wine ok( memex.ullTotalPhys == expect.ullTotalPhys, "got ullTotalPhys %#I64x\n", memex.ullTotalPhys ); ok( memex.ullAvailPhys == expect.ullAvailPhys, "got ullAvailPhys %#I64x\n", memex.ullAvailPhys ); - todo_wine ok( memex.ullTotalPageFile == expect.ullTotalPageFile, "got ullTotalPageFile %#I64x\n", memex.ullTotalPageFile ); /* allow some variability, page file is not always in sync on Windows */ ok( memex.ullAvailPageFile - expect.ullAvailPageFile + 32 * basic_info.PageSize <= 64 * basic_info.PageSize, "got ullAvailPageFile %#I64x\n", memex.ullAvailPageFile ); - todo_wine ok( memex.ullTotalVirtual == expect.ullTotalVirtual, "got ullTotalVirtual %#I64x\n", memex.ullTotalVirtual ); - todo_wine ok( memex.ullAvailVirtual <= expect.ullAvailVirtual, "got ullAvailVirtual %#I64x\n", memex.ullAvailVirtual ); ok( memex.ullAvailExtendedVirtual == 0, "got ullAvailExtendedVirtual %#I64x\n", memex.ullAvailExtendedVirtual ); diff --git a/dlls/kernelbase/memory.c b/dlls/kernelbase/memory.c index 29e1999fe6b..42ffd1bcdd9 100644 --- a/dlls/kernelbase/memory.c +++ b/dlls/kernelbase/memory.c @@ -1043,6 +1043,7 @@ BOOL WINAPI DECLSPEC_HOTPATCH GlobalMemoryStatusEx( MEMORYSTATUSEX *status ) static DWORD last_check; SYSTEM_BASIC_INFORMATION basic_info; SYSTEM_PERFORMANCE_INFORMATION perf_info; + VM_COUNTERS_EX vmc; if (status->dwLength != sizeof(*status)) { @@ -1059,16 +1060,18 @@ BOOL WINAPI DECLSPEC_HOTPATCH GlobalMemoryStatusEx( MEMORYSTATUSEX *status ) if (!set_ntstatus( NtQuerySystemInformation( SystemBasicInformation, &basic_info, sizeof(basic_info), NULL )) || !set_ntstatus( NtQuerySystemInformation( SystemPerformanceInformation, - &perf_info, sizeof(perf_info), NULL))) + &perf_info, sizeof(perf_info), NULL)) || + !set_ntstatus( NtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, + &vmc, sizeof(vmc), NULL ))) return FALSE; status->dwMemoryLoad = 0; - status->ullTotalPhys = perf_info.TotalCommitLimit; + status->ullTotalPhys = basic_info.MmNumberOfPhysicalPages; status->ullAvailPhys = perf_info.AvailablePages; - status->ullTotalPageFile = perf_info.TotalCommitLimit + 1; /* Titan Quest refuses to run if TotalPageFile <= TotalPhys */ + status->ullTotalPageFile = perf_info.TotalCommitLimit; status->ullAvailPageFile = status->ullTotalPageFile - perf_info.TotalCommittedPages; - status->ullTotalVirtual = (ULONG_PTR)basic_info.HighestUserAddress - (ULONG_PTR)basic_info.LowestUserAddress; - status->ullAvailVirtual = status->ullTotalVirtual - 64 * 1024; /* FIXME */ + status->ullTotalVirtual = (ULONG_PTR)basic_info.HighestUserAddress - (ULONG_PTR)basic_info.LowestUserAddress + 1; + status->ullAvailVirtual = status->ullTotalVirtual - (ULONGLONG)vmc.WorkingSetSize /* approximate */; status->ullAvailExtendedVirtual = 0; status->ullTotalPhys *= basic_info.PageSize; diff --git a/dlls/ntdll/unix/system.c b/dlls/ntdll/unix/system.c index 4052d28f644..65c49b6ccd1 100644 --- a/dlls/ntdll/unix/system.c +++ b/dlls/ntdll/unix/system.c @@ -2008,6 +2008,10 @@ static void get_performance_info( SYSTEM_PERFORMANCE_INFORMATION *info ) #endif } #endif + + /* Titan Quest refuses to run if TotalPageFile <= TotalPhys */ + if (!totalswap) totalswap = page_size; + info->AvailablePages = freeram / page_size; info->TotalCommittedPages = (totalram + totalswap - freeram - freeswap) / page_size; info->TotalCommitLimit = (totalram + totalswap) / page_size;

1 0

Rémi Bernon : kernel32/tests: Merge GlobalMemoryStatus(Ex) tests together.
by Alexandre Julliard 25 Mar '22

25 Mar '22

Module: wine Branch: master Commit: cabfefb026840a08a8091a0d9a37ea459da70c78 URL: https://source.winehq.org/git/wine.git/?a=commit;h=cabfefb026840a08a8091a0d… Author: Rémi Bernon <rbernon(a)codeweavers.com> Date: Fri Mar 25 13:56:52 2022 +0100 kernel32/tests: Merge GlobalMemoryStatus(Ex) tests together. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/kernel32/tests/heap.c | 72 ++++++++++++---------------------------------- 1 file changed, 19 insertions(+), 53 deletions(-) diff --git a/dlls/kernel32/tests/heap.c b/dlls/kernel32/tests/heap.c index fc4ece81e00..c36d9331bef 100644 --- a/dlls/kernel32/tests/heap.c +++ b/dlls/kernel32/tests/heap.c @@ -1213,63 +1213,13 @@ static void test_GetPhysicallyInstalledSystemMemory(void) "expected total_memory >= memstatus.ullTotalPhys / 1024\n"); } -static BOOL compare_ulong64(ULONG64 v1, ULONG64 v2, ULONG64 max_diff) -{ - ULONG64 diff = v1 > v2 ? v1 - v2 : v2 - v1; - - return diff <= max_diff; -} - static void test_GlobalMemoryStatus(void) -{ - static const ULONG64 max_diff = 0x200000; - SIZE_T size, size_broken; - MEMORYSTATUSEX memex; - MEMORYSTATUS mem; - - mem.dwLength = sizeof(mem); - GlobalMemoryStatus(&mem); - memex.dwLength = sizeof(memex); - GlobalMemoryStatusEx(&memex); - - /* Compare values approximately as the available memory may change between - * GlobalMemoryStatus() and GlobalMemoryStatusEx() calls. */ - - size = min(memex.ullTotalPhys, ~(SIZE_T)0 >> 1); - size_broken = min(memex.ullTotalPhys, ~(SIZE_T)0); - ok(compare_ulong64(mem.dwTotalPhys, size, max_diff) - || broken(compare_ulong64(mem.dwTotalPhys, size_broken, max_diff)) /* Win <= 8.1 with RAM size > 4GB */, - "Got unexpected dwTotalPhys %s, size %s.\n", - wine_dbgstr_longlong(mem.dwTotalPhys), wine_dbgstr_longlong(size)); - size = min(memex.ullAvailPhys, ~(SIZE_T)0 >> 1); - size_broken = min(memex.ullAvailPhys, ~(SIZE_T)0); - ok(compare_ulong64(mem.dwAvailPhys, size, max_diff) - || broken(compare_ulong64(mem.dwAvailPhys, size_broken, max_diff)) /* Win <= 8.1 with RAM size > 4GB */, - "Got unexpected dwAvailPhys %s, size %s.\n", - wine_dbgstr_longlong(mem.dwAvailPhys), wine_dbgstr_longlong(size)); - - size = min(memex.ullTotalPageFile, ~(SIZE_T)0); - ok(compare_ulong64(mem.dwTotalPageFile, size, max_diff), - "Got unexpected dwTotalPageFile %s, size %s.\n", - wine_dbgstr_longlong(mem.dwTotalPageFile), wine_dbgstr_longlong(size)); - size = min(memex.ullAvailPageFile, ~(SIZE_T)0); - ok(compare_ulong64(mem.dwAvailPageFile, size, max_diff), "Got unexpected dwAvailPageFile %s, size %s.\n", - wine_dbgstr_longlong(mem.dwAvailPageFile), wine_dbgstr_longlong(size)); - - ok(compare_ulong64(mem.dwTotalVirtual, memex.ullTotalVirtual, max_diff), - "Got unexpected dwTotalVirtual %s, ullTotalVirtual %s.\n", - wine_dbgstr_longlong(mem.dwTotalVirtual), wine_dbgstr_longlong(memex.ullTotalVirtual)); - ok(compare_ulong64(mem.dwAvailVirtual, memex.ullAvailVirtual, max_diff), - "Got unexpected dwAvailVirtual %s, ullAvailVirtual %s.\n", - wine_dbgstr_longlong(mem.dwAvailVirtual), wine_dbgstr_longlong(memex.ullAvailVirtual)); -} - -static void test_GlobalMemoryStatusEx(void) { char buffer[sizeof(SYSTEM_PERFORMANCE_INFORMATION) + 16]; /* some Win 7 versions need a larger info */ SYSTEM_PERFORMANCE_INFORMATION *perf_info = (void *)buffer; SYSTEM_BASIC_INFORMATION basic_info; MEMORYSTATUSEX memex = {0}, expect; + MEMORYSTATUS mem = {0}; VM_COUNTERS_EX vmc; NTSTATUS status; BOOL ret; @@ -1278,6 +1228,9 @@ static void test_GlobalMemoryStatusEx(void) ret = GlobalMemoryStatusEx( &memex ); ok( !ret, "GlobalMemoryStatusEx succeeded\n" ); ok( GetLastError() == ERROR_INVALID_PARAMETER, "got error %lu\n", GetLastError() ); + SetLastError( 0xdeadbeef ); + GlobalMemoryStatus( &mem ); + ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() ); do { @@ -1287,10 +1240,13 @@ static void test_GlobalMemoryStatusEx(void) ok( !status, "NtQuerySystemInformation returned %#lx\n", status ); status = NtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &vmc, sizeof(vmc), NULL ); ok( !status, "NtQueryInformationProcess returned %#lx\n", status ); + mem.dwLength = sizeof(MEMORYSTATUS); + GlobalMemoryStatus( &mem ); memex.dwLength = sizeof(MEMORYSTATUSEX); ret = GlobalMemoryStatusEx( &memex ); ok( ret, "GlobalMemoryStatusEx succeeded\n" ); - } while (memex.ullAvailPhys != (ULONGLONG)perf_info->AvailablePages * basic_info.PageSize); + } while (memex.ullAvailPhys != (ULONGLONG)perf_info->AvailablePages * basic_info.PageSize || + mem.dwAvailPhys != min( ~(SIZE_T)0 >> 1, memex.ullAvailPhys )); ok( basic_info.PageSize, "got 0 PageSize\n" ); ok( basic_info.MmNumberOfPhysicalPages, "got 0 MmNumberOfPhysicalPages\n" ); @@ -1323,6 +1279,17 @@ static void test_GlobalMemoryStatusEx(void) todo_wine ok( memex.ullAvailVirtual <= expect.ullAvailVirtual, "got ullAvailVirtual %#I64x\n", memex.ullAvailVirtual ); ok( memex.ullAvailExtendedVirtual == 0, "got ullAvailExtendedVirtual %#I64x\n", memex.ullAvailExtendedVirtual ); + + ok( mem.dwMemoryLoad == memex.dwMemoryLoad, "got dwMemoryLoad %lu\n", mem.dwMemoryLoad ); + ok( mem.dwTotalPhys == min( ~(SIZE_T)0 >> 1, memex.ullTotalPhys ), "got dwTotalPhys %#Ix\n", mem.dwTotalPhys ); + ok( mem.dwAvailPhys == min( ~(SIZE_T)0 >> 1, memex.ullAvailPhys ), "got dwAvailPhys %#Ix\n", mem.dwAvailPhys ); +#ifndef _WIN64 + todo_wine_if(memex.ullTotalPageFile > 0xfff7ffff) +#endif + ok( mem.dwTotalPageFile == min( ~(SIZE_T)0, memex.ullTotalPageFile ), "got dwTotalPageFile %#Ix\n", mem.dwTotalPageFile ); + ok( mem.dwAvailPageFile == min( ~(SIZE_T)0, memex.ullAvailPageFile ), "got dwAvailPageFile %#Ix\n", mem.dwAvailPageFile ); + ok( mem.dwTotalVirtual == memex.ullTotalVirtual, "got dwTotalVirtual %#Ix\n", mem.dwTotalVirtual ); + ok( mem.dwAvailVirtual == memex.ullAvailVirtual, "got dwAvailVirtual %#Ix\n", mem.dwAvailVirtual ); } START_TEST(heap) @@ -1359,7 +1326,6 @@ START_TEST(heap) test_HeapQueryInformation(); test_GetPhysicallyInstalledSystemMemory(); test_GlobalMemoryStatus(); - test_GlobalMemoryStatusEx(); if (pRtlGetNtGlobalFlags) {

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-commits March 2022