[PATCH v25 0/9] MR3103: server: Create and use a desktop shared mapping for GetCursorPos.

[Rémi Bernon]

First part of Proton shared memory series. The full branch can be seen at https://gitlab.winehq.org/rbernon/wine/-/commits/mr/shared-memories.

--
  v25: win32u: Use the desktop shared data for GetCursorPos.
       server: Move the last cursor time to the desktop session object.
       server: Move the cursor position to the desktop session object.
       win32u: Open desktop shared objects from session mapping.
       server: Return the desktop object info in get_thread_desktop.
       server: Allocate shared session object for desktops.
       win32u: Open the global session shared mapping.
       include: Add ReadNoFence64 inline helpers.
       server: Create a global session shared mapping.
 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 1/9] server: Create a global session shared mapping.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 server/directory.c  |  7 +++++++
 server/file.h       | 19 +++++++++++++++++++
 server/mapping.c    | 32 ++++++++++++++++++++++++++++++++
 server/protocol.def | 24 ++++++++++++++++++++++++
 tools/make_requests |  1 +
 5 files changed, 83 insertions(+)

diff --git a/server/directory.c b/server/directory.c
index 23d7eb0a2b7..1ef645c2c2d 100644
--- a/server/directory.c
+++ b/server/directory.c
@@ -439,11 +439,14 @@ void init_directories( struct fd *intl_fd )
     /* mappings */
     static const WCHAR intlW[] = {'N','l','s','S','e','c','t','i','o','n','L','A','N','G','_','I','N','T','L'};
     static const WCHAR user_dataW[] = {'_','_','w','i','n','e','_','u','s','e','r','_','s','h','a','r','e','d','_','d','a','t','a'};
+    static const WCHAR sessionW[] = {'_','_','w','i','n','e','_','s','e','s','s','i','o','n'};
     static const struct unicode_str intl_str = {intlW, sizeof(intlW)};
     static const struct unicode_str user_data_str = {user_dataW, sizeof(user_dataW)};
+    static const struct unicode_str session_str = {sessionW, sizeof(sessionW)};
 
     struct directory *dir_driver, *dir_device, *dir_global, *dir_kernel, *dir_nls;
     struct object *named_pipe_device, *mailslot_device, *null_device;
+    struct mapping *session_mapping;
     unsigned int i;
 
     root_directory = create_directory( NULL, NULL, OBJ_PERMANENT, HASH_SIZE, NULL );
@@ -491,6 +494,10 @@ void init_directories( struct fd *intl_fd )
     release_object( create_user_data_mapping( &dir_kernel->obj, &user_data_str, OBJ_PERMANENT, NULL ));
     release_object( intl_fd );
 
+    session_mapping = create_session_mapping( &dir_kernel->obj, &session_str, OBJ_PERMANENT, NULL );
+    set_session_mapping( session_mapping );
+    release_object( session_mapping );
+
     release_object( named_pipe_device );
     release_object( mailslot_device );
     release_object( null_device );
diff --git a/server/file.h b/server/file.h
index 7f2d1637863..3a288f0a212 100644
--- a/server/file.h
+++ b/server/file.h
@@ -188,6 +188,25 @@ extern struct mapping *create_fd_mapping( struct object *root, const struct unic
                                           unsigned int attr, const struct security_descriptor *sd );
 extern struct object *create_user_data_mapping( struct object *root, const struct unicode_str *name,
                                                 unsigned int attr, const struct security_descriptor *sd );
+extern struct mapping *create_session_mapping( struct object *root, const struct unicode_str *name,
+                                               unsigned int attr, const struct security_descriptor *sd );
+extern void set_session_mapping( struct mapping *mapping );
+
+
+#define SHARED_WRITE_BEGIN( object, type )                              \
+    do {                                                                \
+        const type *__shared = (object);                                \
+        type *shared = (type *)__shared;                                \
+        LONG64 __seq = shared->obj.seq + 1, __end = __seq + 1;          \
+        assert( (__seq & 1) != 0 );                                     \
+        __WINE_ATOMIC_STORE_RELEASE( &shared->obj.seq, &__seq );        \
+        do
+
+#define SHARED_WRITE_END                                                \
+        while(0);                                                       \
+        assert( __seq == shared->obj.seq );                             \
+        __WINE_ATOMIC_STORE_RELEASE( &shared->obj.seq, &__end );        \
+    } while(0)
 
 /* device functions */
 
diff --git a/server/mapping.c b/server/mapping.c
index 6b0de1b8b94..d22be2c62fa 100644
--- a/server/mapping.c
+++ b/server/mapping.c
@@ -225,6 +225,13 @@ static const mem_size_t granularity_mask = 0xffff;
 static struct addr_range ranges32;
 static struct addr_range ranges64;
 
+struct session
+{
+    const session_shm_t *shared;
+};
+static struct mapping *session_mapping;
+static struct session session;
+
 #define ROUND_SIZE(size)  (((size) + page_mask) & ~page_mask)
 
 void init_memory(void)
@@ -1256,6 +1263,31 @@ int get_page_size(void)
     return page_mask + 1;
 }
 
+struct mapping *create_session_mapping( struct object *root, const struct unicode_str *name,
+                                        unsigned int attr, const struct security_descriptor *sd )
+{
+    static const unsigned int access = FILE_READ_DATA | FILE_WRITE_DATA;
+    mem_size_t size;
+
+    size = max(offsetof(session_shm_t, objects[512]), 0x10000);
+    size = (size + page_mask) & ~((mem_size_t)page_mask);
+
+    return create_mapping( root, name, attr, size, SEC_COMMIT, 0, access, sd );
+}
+
+void set_session_mapping( struct mapping *mapping )
+{
+    session.shared = mmap( NULL, mapping->size, PROT_READ | PROT_WRITE, MAP_SHARED, get_unix_fd( mapping->fd ), 0 );
+    if (session.shared == MAP_FAILED) return;
+
+    session_mapping = mapping;
+    SHARED_WRITE_BEGIN( session.shared, session_shm_t )
+    {
+        shared->object_capacity = (mapping->size - offsetof(session_shm_t, objects[0])) / sizeof(session_obj_t);
+    }
+    SHARED_WRITE_END;
+}
+
 struct object *create_user_data_mapping( struct object *root, const struct unicode_str *name,
                                         unsigned int attr, const struct security_descriptor *sd )
 {
diff --git a/server/protocol.def b/server/protocol.def
index 13aea96e796..08f55aaeee2 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -45,6 +45,7 @@ typedef unsigned __int64 mem_size_t;
 typedef unsigned __int64 file_pos_t;
 typedef unsigned __int64 client_ptr_t;
 typedef unsigned __int64 affinity_t;
+typedef unsigned __int64 object_id_t;
 typedef client_ptr_t mod_handle_t;
 
 struct request_header
@@ -874,6 +875,29 @@ typedef struct
     lparam_t info;
 } cursor_pos_t;
 
+/****************************************************************/
+/* shared session mapping structures */
+
+typedef volatile struct
+{
+    LONG64               seq;              /* sequence number - server updating if (seq & 1) != 0 */
+    object_id_t          id;               /* object unique id, object data is valid if != 0 */
+} object_shm_t;
+
+typedef volatile union
+{
+    object_shm_t         obj;
+} session_obj_t;
+
+typedef volatile struct
+{
+    object_shm_t         obj;
+    mem_size_t           object_capacity;
+    session_obj_t        objects[];
+} session_shm_t;
+
+C_ASSERT(sizeof(session_shm_t) == offsetof(session_shm_t, objects[0]));
+
 /****************************************************************/
 /* Request declarations */
 
diff --git a/tools/make_requests b/tools/make_requests
index e3eaaf45b6f..f22ad279b61 100755
--- a/tools/make_requests
+++ b/tools/make_requests
@@ -42,6 +42,7 @@ my %formats =
     "file_pos_t"    => [  8,   8,  "&dump_uint64" ],
     "mem_size_t"    => [  8,   8,  "&dump_uint64" ],
     "affinity_t"    => [  8,   8,  "&dump_uint64" ],
+    "object_id_t"   => [  8,   8,  "&dump_uint64" ],
     "timeout_t"     => [  8,   8,  "&dump_timeout" ],
     "abstime_t"     => [  8,   8,  "&dump_abstime" ],
     "rectangle_t"   => [  16,  4,  "&dump_rectangle" ],
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 2/9] include: Add ReadNoFence64 inline helpers.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 include/winnt.h | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/include/winnt.h b/include/winnt.h
index e7c322fd127..5ea908c97ad 100644
--- a/include/winnt.h
+++ b/include/winnt.h
@@ -7059,11 +7059,14 @@ static FORCEINLINE void MemoryBarrier(void)
  */
 #if _MSC_VER >= 1700
 #pragma intrinsic(__iso_volatile_load32)
+#pragma intrinsic(__iso_volatile_load64)
 #pragma intrinsic(__iso_volatile_store32)
 #define __WINE_LOAD32_NO_FENCE(src) (__iso_volatile_load32(src))
+#define __WINE_LOAD64_NO_FENCE(src) (__iso_volatile_load64(src))
 #define __WINE_STORE32_NO_FENCE(dest, value) (__iso_volatile_store32(dest, value))
 #else  /* _MSC_VER >= 1700 */
 #define __WINE_LOAD32_NO_FENCE(src) (*(src))
+#define __WINE_LOAD64_NO_FENCE(src) (*(src))
 #define __WINE_STORE32_NO_FENCE(dest, value) ((void)(*(dest) = (value)))
 #endif  /* _MSC_VER >= 1700 */
 
@@ -7097,6 +7100,12 @@ static FORCEINLINE LONG ReadNoFence( LONG const volatile *src )
     return value;
 }
 
+static FORCEINLINE LONG64 ReadNoFence64( LONG64 const volatile *src )
+{
+    LONG64 value = __WINE_LOAD64_NO_FENCE( (__int64 const volatile *)src );
+    return value;
+}
+
 static FORCEINLINE void WriteRelease( LONG volatile *dest, LONG value )
 {
     __wine_memory_barrier_acq_rel();
@@ -7283,6 +7292,13 @@ static FORCEINLINE LONG ReadNoFence( LONG const volatile *src )
     return value;
 }
 
+static FORCEINLINE LONG64 ReadNoFence64( LONG64 const volatile *src )
+{
+    LONG64 value;
+    __WINE_ATOMIC_LOAD_RELAXED( src, &value );
+    return value;
+}
+
 static FORCEINLINE void WriteRelease( LONG volatile *dest, LONG value )
 {
     __WINE_ATOMIC_STORE_RELEASE( dest, &value );
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 3/9] win32u: Open the global session shared mapping.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 dlls/win32u/win32u_private.h |  23 +++++++
 dlls/win32u/winstation.c     | 112 ++++++++++++++++++++++++++++++++++-
 2 files changed, 134 insertions(+), 1 deletion(-)

diff --git a/dlls/win32u/win32u_private.h b/dlls/win32u/win32u_private.h
index 0af6960a3eb..003d2fd5c24 100644
--- a/dlls/win32u/win32u_private.h
+++ b/dlls/win32u/win32u_private.h
@@ -364,4 +364,27 @@ static inline BOOL intersect_rect( RECT *dst, const RECT *src1, const RECT *src2
     return !IsRectEmpty( dst );
 }
 
+#if defined(__i386__) || defined(__x86_64__)
+/* this prevents compilers from incorrectly reordering non-volatile reads (e.g., memcpy) from shared memory */
+#define __SHARED_READ_FENCE do { __asm__ __volatile__( "" ::: "memory" ); } while (0)
+#else
+#define __SHARED_READ_FENCE __atomic_thread_fence( __ATOMIC_ACQUIRE )
+#endif
+
+#define SHARED_READ_BEGIN( ptr, type )                                  \
+    do {                                                                \
+        const type *shared = (ptr);                                     \
+        LONG64 __seq;                                                   \
+        do {                                                            \
+            while ((__seq = ReadNoFence64( &shared->obj.seq )) & 1)     \
+                YieldProcessor();                                       \
+            __SHARED_READ_FENCE;                                        \
+            do
+
+#define SHARED_READ_END                                                 \
+            while (0);                                                  \
+            __SHARED_READ_FENCE;                                        \
+        } while (ReadNoFence64( &shared->obj.seq ) != __seq);           \
+    } while(0)
+
 #endif /* __WINE_WIN32U_PRIVATE */
diff --git a/dlls/win32u/winstation.c b/dlls/win32u/winstation.c
index 6ddd5411f94..aec8fcee067 100644
--- a/dlls/win32u/winstation.c
+++ b/dlls/win32u/winstation.c
@@ -22,9 +22,12 @@
 #pragma makedep unix
 #endif
 
+#include <stdarg.h>
+#include <stddef.h>
+#include <pthread.h>
+
 #include "ntstatus.h"
 #define WIN32_NO_STATUS
-#include <stdarg.h>
 #include "windef.h"
 #include "winbase.h"
 #include "ntuser.h"
@@ -40,6 +43,109 @@ WINE_DECLARE_DEBUG_CHANNEL(win);
 
 #define DESKTOP_ALL_ACCESS 0x01ff
 
+struct shared_session
+{
+    LONG ref;
+    UINT64 id;
+    UINT object_capacity;
+    const session_shm_t *shared;
+};
+
+static pthread_mutex_t session_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct shared_session *shared_session;
+
+static struct shared_session *shared_session_acquire( struct shared_session *session )
+{
+    int ref = InterlockedIncrement( &session->ref );
+    TRACE( "session %p incrementing ref to %d\n", session, ref );
+    return session;
+}
+
+static void shared_session_release( struct shared_session *session )
+{
+    int ref = InterlockedDecrement( &session->ref );
+    TRACE( "session %p decrementing ref to %d\n", session, ref );
+    if (!ref)
+    {
+        NtUnmapViewOfSection( GetCurrentProcess(), (void *)session->shared );
+        free( session );
+    }
+}
+
+static NTSTATUS map_shared_session_section( struct shared_session *session, HANDLE handle )
+{
+    NTSTATUS status;
+    SIZE_T size = 0;
+
+    while (!(status = NtMapViewOfSection( handle, GetCurrentProcess(), (void **)&session->shared, 0, 0,
+                                          NULL, &size, ViewUnmap, 0, PAGE_READONLY )))
+    {
+        BOOL valid;
+        session->object_capacity = (size - offsetof(session_shm_t, objects[0])) / sizeof(session_obj_t);
+        SHARED_READ_BEGIN( session->shared, session_shm_t )
+        {
+            valid = session->object_capacity == shared->object_capacity;
+            session->id = shared->obj.id;
+        }
+        SHARED_READ_END;
+        if (valid) break;
+
+        NtUnmapViewOfSection( GetCurrentProcess(), (void *)session->shared );
+        session->shared = NULL;
+        size = 0;
+    }
+
+    return status;
+}
+
+static struct shared_session *get_shared_session( BOOL force )
+{
+    struct shared_session *session;
+
+    pthread_mutex_lock( &session_lock );
+
+    if (force || !shared_session)
+    {
+        static const WCHAR nameW[] =
+        {
+            '\\','K','e','r','n','e','l','O','b','j','e','c','t','s','\\',
+            '_','_','w','i','n','e','_','s','e','s','s','i','o','n',0
+        };
+        UNICODE_STRING name = RTL_CONSTANT_STRING( nameW );
+        OBJECT_ATTRIBUTES attr;
+        unsigned int status;
+        HANDLE handle;
+
+        if (!(session = calloc( 1, sizeof(*session) ))) goto done;
+        session->ref = 1;
+
+        InitializeObjectAttributes( &attr, &name, 0, NULL, NULL );
+        if (!(status = NtOpenSection( &handle, SECTION_MAP_READ, &attr )))
+        {
+            status = map_shared_session_section( session, handle );
+            NtClose( handle );
+        }
+
+        if (status)
+        {
+            ERR( "Failed to map session mapping, status %#x\n", status );
+            free( session );
+            session = NULL;
+            goto done;
+        }
+
+        if (shared_session) shared_session_release( shared_session );
+        shared_session = session;
+    }
+
+    session = shared_session_acquire( shared_session );
+
+done:
+    pthread_mutex_unlock( &session_lock );
+
+    return session;
+}
+
 BOOL is_virtual_desktop(void)
 {
     HANDLE desktop = NtUserGetThreadDesktop( GetCurrentThreadId() );
@@ -630,12 +736,16 @@ void winstation_init(void)
 {
     RTL_USER_PROCESS_PARAMETERS *params = NtCurrentTeb()->Peb->ProcessParameters;
     WCHAR *winstation = NULL, *desktop = NULL, *buffer = NULL;
+    struct shared_session *session;
     HANDLE handle, dir = NULL;
     OBJECT_ATTRIBUTES attr;
     UNICODE_STRING str;
 
     static const WCHAR winsta0[] = {'W','i','n','S','t','a','0',0};
 
+    if ((session = get_shared_session( FALSE )))
+        shared_session_release( session );
+
     if (params->Desktop.Length)
     {
         buffer = malloc( params->Desktop.Length + sizeof(WCHAR) );
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 4/9] server: Allocate shared session object for desktops.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 server/file.h       |  4 +++
 server/mapping.c    | 75 +++++++++++++++++++++++++++++++++++++++++++++
 server/protocol.def |  6 ++++
 server/user.h       |  1 +
 server/winstation.c |  8 +++++
 5 files changed, 94 insertions(+)

diff --git a/server/file.h b/server/file.h
index 3a288f0a212..5380e1a6430 100644
--- a/server/file.h
+++ b/server/file.h
@@ -192,6 +192,10 @@ extern struct mapping *create_session_mapping( struct object *root, const struct
                                                unsigned int attr, const struct security_descriptor *sd );
 extern void set_session_mapping( struct mapping *mapping );
 
+extern int alloc_shared_object(void);
+extern void free_shared_object( int index );
+extern const desktop_shm_t *get_shared_desktop( int index );
+
 
 #define SHARED_WRITE_BEGIN( object, type )                              \
     do {                                                                \
diff --git a/server/mapping.c b/server/mapping.c
index d22be2c62fa..b06e3f1cd45 100644
--- a/server/mapping.c
+++ b/server/mapping.c
@@ -228,6 +228,8 @@ static struct addr_range ranges64;
 struct session
 {
     const session_shm_t *shared;
+    mem_size_t next_object_index;
+    object_id_t last_object_id;
 };
 static struct mapping *session_mapping;
 static struct session session;
@@ -1288,6 +1290,79 @@ void set_session_mapping( struct mapping *mapping )
     SHARED_WRITE_END;
 }
 
+static int grow_session_mapping(void)
+{
+    unsigned int capacity;
+    mem_size_t size;
+    int unix_fd;
+    void *tmp;
+
+    capacity = session.shared->object_capacity * 3 / 2;
+    size = offsetof(session_shm_t, objects[capacity]);
+    size = (size + page_mask) & ~((mem_size_t)page_mask);
+
+    unix_fd = get_unix_fd( session_mapping->fd );
+    if (!grow_file( unix_fd, size )) return -1;
+
+    if ((tmp = mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, unix_fd, 0 )) == MAP_FAILED)
+    {
+        file_set_error();
+        return -1;
+    }
+    munmap( (void *)session.shared, session_mapping->size );
+    session.shared = tmp;
+    session_mapping->size = size;
+
+    SHARED_WRITE_BEGIN( session.shared, session_shm_t )
+    {
+        shared->object_capacity = (size - offsetof(session_shm_t, objects[0])) / sizeof(session_obj_t);
+    }
+    SHARED_WRITE_END;
+
+    return 0;
+}
+
+int alloc_shared_object(void)
+{
+    mem_size_t index, offset = session.next_object_index, capacity = session.shared->object_capacity;
+
+    for (index = offset; index != offset + capacity; index++)
+        if (!session.shared->objects[index % capacity].obj.id)
+            break;
+    if (index != offset + capacity) index %= capacity;
+    else
+    {
+        if (grow_session_mapping()) return -1;
+        index = capacity;
+    }
+
+    SHARED_WRITE_BEGIN( &session.shared->objects[index], session_obj_t )
+    {
+        shared->obj.id = ++session.last_object_id;
+    }
+    SHARED_WRITE_END;
+    session.next_object_index = index + 1;
+
+    return index;
+}
+
+void free_shared_object( int index )
+{
+    if (index < 0) return;
+
+    SHARED_WRITE_BEGIN( &session.shared->objects[index], session_obj_t )
+    {
+        shared->obj.id = 0;
+    }
+    SHARED_WRITE_END;
+}
+
+const desktop_shm_t *get_shared_desktop( int index )
+{
+    if (index < 0) return NULL;
+    return &session.shared->objects[index].desktop;
+}
+
 struct object *create_user_data_mapping( struct object *root, const struct unicode_str *name,
                                         unsigned int attr, const struct security_descriptor *sd )
 {
diff --git a/server/protocol.def b/server/protocol.def
index 08f55aaeee2..258b1abb6ed 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -884,9 +884,15 @@ typedef volatile struct
     object_id_t          id;               /* object unique id, object data is valid if != 0 */
 } object_shm_t;
 
+typedef volatile struct
+{
+    object_shm_t         obj;
+} desktop_shm_t;
+
 typedef volatile union
 {
     object_shm_t         obj;
+    desktop_shm_t        desktop;
 } session_obj_t;
 
 typedef volatile struct
diff --git a/server/user.h b/server/user.h
index 309a0966104..21d67656c9c 100644
--- a/server/user.h
+++ b/server/user.h
@@ -81,6 +81,7 @@ struct desktop
     unsigned int         users;            /* processes and threads using this desktop */
     struct global_cursor cursor;           /* global cursor information */
     unsigned char        keystate[256];    /* asynchronous key state */
+    int                  session_index;    /* desktop index in session shared memory */
 };
 
 /* user handles functions */
diff --git a/server/winstation.c b/server/winstation.c
index 3af4c365ec3..d055a632dec 100644
--- a/server/winstation.c
+++ b/server/winstation.c
@@ -297,6 +297,13 @@ static struct desktop *create_desktop( const struct unicode_str *name, unsigned
             list_add_tail( &winstation->desktops, &desktop->entry );
             list_init( &desktop->hotkeys );
             list_init( &desktop->pointers );
+            desktop->session_index = -1;
+
+            if ((desktop->session_index = alloc_shared_object()) == -1)
+            {
+                release_object( desktop );
+                return NULL;
+            }
         }
         else
         {
@@ -366,6 +373,7 @@ static void desktop_destroy( struct object *obj )
     if (desktop->global_hooks) release_object( desktop->global_hooks );
     if (desktop->close_timeout) remove_timeout_user( desktop->close_timeout );
     release_object( desktop->winstation );
+    free_shared_object( desktop->session_index );
 }
 
 /* retrieve the thread desktop, checking the handle access rights */
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 5/9] server: Return the desktop object info in get_thread_desktop.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 server/protocol.def |  2 ++
 server/winstation.c | 12 ++++++++++++
 2 files changed, 14 insertions(+)

diff --git a/server/protocol.def b/server/protocol.def
index 258b1abb6ed..1096df4c0ab 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -2813,6 +2813,8 @@ enum coords_relative
     thread_id_t  tid;             /* thread id */
 @REPLY
     obj_handle_t handle;          /* handle to the desktop */
+    int          index;           /* index of desktop object in session shared memory */
+    object_id_t  object_id;       /* id of the session object */
 @END
 
 
diff --git a/server/winstation.c b/server/winstation.c
index d055a632dec..54f422ddf60 100644
--- a/server/winstation.c
+++ b/server/winstation.c
@@ -737,10 +737,22 @@ DECL_HANDLER(close_desktop)
 /* get the thread current desktop */
 DECL_HANDLER(get_thread_desktop)
 {
+    struct desktop *desktop;
     struct thread *thread;
 
     if (!(thread = get_thread_from_id( req->tid ))) return;
     reply->handle = thread->desktop;
+    reply->index = -1;
+
+    if (!(desktop = get_thread_desktop( thread, 0 ))) clear_error();
+    else
+    {
+        const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
+        reply->index     = desktop->session_index;
+        reply->object_id = desktop_shm->obj.id;
+        release_object( desktop );
+    }
+
     release_object( thread );
 }
 
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 6/9] win32u: Open desktop shared objects from session mapping.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 dlls/win32u/ntuser_private.h |   1 +
 dlls/win32u/sysparams.c      |   1 +
 dlls/win32u/win32u_private.h |  13 +++++
 dlls/win32u/winstation.c     | 102 +++++++++++++++++++++++++++++++++--
 4 files changed, 113 insertions(+), 4 deletions(-)

diff --git a/dlls/win32u/ntuser_private.h b/dlls/win32u/ntuser_private.h
index 3b6cab5bdc9..27430c3478b 100644
--- a/dlls/win32u/ntuser_private.h
+++ b/dlls/win32u/ntuser_private.h
@@ -127,6 +127,7 @@ struct user_thread_info
     UINT                          spy_indent;             /* Current spy indent */
     BOOL                          clipping_cursor;        /* thread is currently clipping */
     DWORD                         clipping_reset;         /* time when clipping was last reset */
+    struct session_thread_data   *session_data;           /* shared session thread data */
 };
 
 C_ASSERT( sizeof(struct user_thread_info) <= sizeof(((TEB *)0)->Win32ClientInfo) );
diff --git a/dlls/win32u/sysparams.c b/dlls/win32u/sysparams.c
index 6c4223f0cdb..cb9920bb4d5 100644
--- a/dlls/win32u/sysparams.c
+++ b/dlls/win32u/sysparams.c
@@ -6151,6 +6151,7 @@ static void thread_detach(void)
     destroy_thread_windows();
     cleanup_imm_thread();
     NtClose( thread_info->server_queue );
+    free( thread_info->session_data );
 
     exiting_thread_id = 0;
 }
diff --git a/dlls/win32u/win32u_private.h b/dlls/win32u/win32u_private.h
index 003d2fd5c24..4b7905639b7 100644
--- a/dlls/win32u/win32u_private.h
+++ b/dlls/win32u/win32u_private.h
@@ -193,6 +193,19 @@ extern void user_unlock(void);
 extern void user_check_not_lock(void);
 
 /* winstation.c */
+
+struct shared_session;
+
+struct object_lock
+{
+    UINT64 id;
+    const session_obj_t *shared; /* only valid when locked, read inside SHARED_READ_BEGIN */
+    struct shared_session *session; /* only valid when locked */
+};
+
+extern void object_lock_release( struct object_lock *lock );
+extern BOOL get_shared_desktop( struct object_lock *lock );
+
 extern BOOL is_virtual_desktop(void);
 
 /* window.c */
diff --git a/dlls/win32u/winstation.c b/dlls/win32u/winstation.c
index aec8fcee067..908d2b09344 100644
--- a/dlls/win32u/winstation.c
+++ b/dlls/win32u/winstation.c
@@ -43,6 +43,17 @@ WINE_DECLARE_DEBUG_CHANNEL(win);
 
 #define DESKTOP_ALL_ACCESS 0x01ff
 
+struct object_info
+{
+    UINT64 id;
+    UINT index;
+};
+
+struct session_thread_data
+{
+    struct object_info shared_desktop;         /* thread desktop shared session object info */
+};
+
 struct shared_session
 {
     LONG ref;
@@ -54,6 +65,13 @@ struct shared_session
 static pthread_mutex_t session_lock = PTHREAD_MUTEX_INITIALIZER;
 static struct shared_session *shared_session;
 
+static struct session_thread_data *get_session_thread_data(void)
+{
+    struct user_thread_info *thread_info = get_user_thread_info();
+    if (!thread_info->session_data) thread_info->session_data = calloc(1, sizeof(*thread_info->session_data));
+    return thread_info->session_data;
+}
+
 static struct shared_session *shared_session_acquire( struct shared_session *session )
 {
     int ref = InterlockedIncrement( &session->ref );
@@ -146,6 +164,82 @@ done:
     return session;
 }
 
+void object_lock_release( struct object_lock *lock )
+{
+    shared_session_release( lock->session );
+    memset( lock, 0, sizeof(*lock) );
+    lock->id = -1; /* force object to be refreshed when retrying lock */
+}
+
+enum object_type
+{
+    OBJECT_TYPE_DESKTOP = 1,
+};
+
+static NTSTATUS get_thread_session_object_info( UINT tid, enum object_type type,
+                                                struct object_info *info )
+{
+    NTSTATUS status;
+
+    switch (type)
+    {
+    case OBJECT_TYPE_DESKTOP:
+        SERVER_START_REQ( get_thread_desktop )
+        {
+            req->tid = tid;
+            if (!(status = wine_server_call_err( req )))
+            {
+                info->id = reply->object_id;
+                info->index = reply->index;
+            }
+        }
+        SERVER_END_REQ;
+        break;
+    }
+
+    return status;
+}
+
+/* return a locked session object for a thread id and type */
+static BOOL get_thread_session_object( UINT tid, enum object_type type, struct object_info *info,
+                                       struct object_lock *lock )
+{
+    struct shared_session *session;
+    BOOL valid = TRUE;
+
+    TRACE( "tid %04x, type %u\n", tid, type );
+
+    while ((session = get_shared_session( !valid )))
+    {
+        if (!info->id && get_thread_session_object_info( tid, type, info )) break;
+        if ((valid = info->index < session->object_capacity))
+        {
+            lock->id = info->id;
+            lock->session = session;
+            lock->shared = &session->shared->objects[info->index];
+            return TRUE;
+        }
+        shared_session_release( session );
+        memset( info, 0, sizeof(*info) );
+    }
+
+    WARN( "Failed to find object type %u for thread %04x\n", type, tid );
+    if (session) shared_session_release( session );
+    memset( info, 0, sizeof(*info) );
+    return FALSE;
+}
+
+BOOL get_shared_desktop( struct object_lock *lock )
+{
+    struct session_thread_data *data = get_session_thread_data();
+    struct object_info *info = &data->shared_desktop;
+
+    TRACE( "lock %p\n", lock );
+
+    if (lock->id) info->id = 0; /* invalidate info if the lock was abandoned due to id mismatch */
+    return get_thread_session_object( GetCurrentThreadId(), OBJECT_TYPE_DESKTOP, info, lock );
+}
+
 BOOL is_virtual_desktop(void)
 {
     HANDLE desktop = NtUserGetThreadDesktop( GetCurrentThreadId() );
@@ -367,9 +461,13 @@ BOOL WINAPI NtUserSetThreadDesktop( HDESK handle )
     {
         struct user_thread_info *thread_info = get_user_thread_info();
         struct user_key_state_info *key_state_info = thread_info->key_state;
+        struct object_info *desktop_info = &get_session_thread_data()->shared_desktop;
+        struct object_lock lock = {0};
         thread_info->client_info.top_window = 0;
         thread_info->client_info.msg_window = 0;
         if (key_state_info) key_state_info->time = 0;
+        memset( desktop_info, 0, sizeof(*desktop_info) );
+        if (get_shared_desktop( &lock )) object_lock_release( &lock );
         if (was_virtual_desktop != is_virtual_desktop()) update_display_cache( TRUE );
     }
     return ret;
@@ -736,16 +834,12 @@ void winstation_init(void)
 {
     RTL_USER_PROCESS_PARAMETERS *params = NtCurrentTeb()->Peb->ProcessParameters;
     WCHAR *winstation = NULL, *desktop = NULL, *buffer = NULL;
-    struct shared_session *session;
     HANDLE handle, dir = NULL;
     OBJECT_ATTRIBUTES attr;
     UNICODE_STRING str;
 
     static const WCHAR winsta0[] = {'W','i','n','S','t','a','0',0};
 
-    if ((session = get_shared_session( FALSE )))
-        shared_session_release( session );
-
     if (params->Desktop.Length)
     {
         buffer = malloc( params->Desktop.Length + sizeof(WCHAR) );
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 7/9] server: Move the cursor position to the desktop session object.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

Based on a patch by Huw Davies <huw(a)codeweavers.com>.
---
 server/protocol.def |  7 ++++
 server/queue.c      | 78 ++++++++++++++++++++++++++++-----------------
 server/user.h       |  2 --
 3 files changed, 55 insertions(+), 32 deletions(-)

diff --git a/server/protocol.def b/server/protocol.def
index 1096df4c0ab..736d2b0232c 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -878,6 +878,12 @@ typedef struct
 /****************************************************************/
 /* shared session mapping structures */
 
+struct shared_cursor
+{
+    int                  x;                /* cursor position */
+    int                  y;
+};
+
 typedef volatile struct
 {
     LONG64               seq;              /* sequence number - server updating if (seq & 1) != 0 */
@@ -887,6 +893,7 @@ typedef volatile struct
 typedef volatile struct
 {
     object_shm_t         obj;
+    struct shared_cursor cursor;           /* global cursor information */
 } desktop_shm_t;
 
 typedef volatile union
diff --git a/server/queue.c b/server/queue.c
index 0e8653bedf0..cba5514deef 100644
--- a/server/queue.c
+++ b/server/queue.c
@@ -418,6 +418,7 @@ static void queue_cursor_message( struct desktop *desktop, user_handle_t win, un
                                   lparam_t wparam, lparam_t lparam )
 {
     static const struct hw_msg_source source = { IMDT_UNAVAILABLE, IMO_SYSTEM };
+    const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
     struct thread_input *input;
     struct message *msg;
 
@@ -426,8 +427,8 @@ static void queue_cursor_message( struct desktop *desktop, user_handle_t win, un
     msg->msg = message;
     msg->wparam = wparam;
     msg->lparam = lparam;
-    msg->x = desktop->cursor.x;
-    msg->y = desktop->cursor.y;
+    msg->x = desktop_shm->cursor.x;
+    msg->y = desktop_shm->cursor.y;
     if (!(msg->win = win) && (input = desktop->foreground_input)) msg->win = input->active;
     queue_hardware_message( desktop, msg, 1 );
 }
@@ -465,13 +466,20 @@ static int update_desktop_cursor_window( struct desktop *desktop, user_handle_t
 
 static int update_desktop_cursor_pos( struct desktop *desktop, user_handle_t win, int x, int y )
 {
+    const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
     int updated;
 
     x = max( min( x, desktop->cursor.clip.right - 1 ), desktop->cursor.clip.left );
     y = max( min( y, desktop->cursor.clip.bottom - 1 ), desktop->cursor.clip.top );
-    updated = (desktop->cursor.x != x || desktop->cursor.y != y);
-    desktop->cursor.x = x;
-    desktop->cursor.y = y;
+
+    SHARED_WRITE_BEGIN( desktop_shm, desktop_shm_t )
+    {
+        updated = shared->cursor.x != x || shared->cursor.y != y;
+        shared->cursor.x = x;
+        shared->cursor.y = y;
+    }
+    SHARED_WRITE_END;
+
     desktop->cursor.last_change = get_tick_count();
 
     if (!win || !is_window_visible( win ) || is_window_transparent( win ))
@@ -517,15 +525,17 @@ static void set_cursor_pos( struct desktop *desktop, int x, int y )
 static void get_message_defaults( struct msg_queue *queue, int *x, int *y, unsigned int *time )
 {
     struct desktop *desktop = queue->input->desktop;
+    const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
 
-    *x = desktop->cursor.x;
-    *y = desktop->cursor.y;
+    *x = desktop_shm->cursor.x;
+    *y = desktop_shm->cursor.y;
     *time = get_tick_count();
 }
 
 /* set the cursor clip rectangle */
 void set_clip_rectangle( struct desktop *desktop, const rectangle_t *rect, unsigned int flags, int reset )
 {
+    const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
     rectangle_t top_rect;
     int x, y;
 
@@ -543,9 +553,9 @@ void set_clip_rectangle( struct desktop *desktop, const rectangle_t *rect, unsig
     else desktop->cursor.clip = top_rect;
 
     /* warp the mouse to be inside the clip rect */
-    x = max( min( desktop->cursor.x, desktop->cursor.clip.right - 1 ), desktop->cursor.clip.left );
-    y = max( min( desktop->cursor.y, desktop->cursor.clip.bottom - 1 ), desktop->cursor.clip.top );
-    if (x != desktop->cursor.x || y != desktop->cursor.y) set_cursor_pos( desktop, x, y );
+    x = max( min( desktop_shm->cursor.x, desktop->cursor.clip.right - 1 ), desktop->cursor.clip.left );
+    y = max( min( desktop_shm->cursor.y, desktop->cursor.clip.bottom - 1 ), desktop->cursor.clip.top );
+    if (x != desktop_shm->cursor.x || y != desktop_shm->cursor.y) set_cursor_pos( desktop, x, y );
 
     /* request clip cursor rectangle reset to the desktop thread */
     if (reset) post_desktop_message( desktop, WM_WINE_CLIPCURSOR, flags, FALSE );
@@ -1668,6 +1678,7 @@ static void prepend_cursor_history( int x, int y, unsigned int time, lparam_t in
 /* queue a hardware message into a given thread input */
 static void queue_hardware_message( struct desktop *desktop, struct message *msg, int always_queue )
 {
+    const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
     user_handle_t win;
     struct thread *thread;
     struct thread_input *input;
@@ -1700,8 +1711,8 @@ static void queue_hardware_message( struct desktop *desktop, struct message *msg
         if (desktop->keystate[VK_XBUTTON2] & 0x80) msg->wparam |= MK_XBUTTON2;
         break;
     }
-    msg->x = desktop->cursor.x;
-    msg->y = desktop->cursor.y;
+    msg->x = desktop_shm->cursor.x;
+    msg->y = desktop_shm->cursor.y;
 
     if (msg->win && (thread = get_window_thread( msg->win )))
     {
@@ -1983,6 +1994,7 @@ static void dispatch_rawinput_message( struct desktop *desktop, struct rawinput_
 static int queue_mouse_message( struct desktop *desktop, user_handle_t win, const hw_input_t *input,
                                 unsigned int origin, struct msg_queue *sender )
 {
+    const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
     const struct rawinput_device *device;
     struct hardware_msg_data *msg_data;
     struct rawinput_message raw_msg;
@@ -2021,19 +2033,19 @@ static int queue_mouse_message( struct desktop *desktop, user_handle_t win, cons
             x = input->mouse.x;
             y = input->mouse.y;
             if (flags & ~(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE) &&
-                x == desktop->cursor.x && y == desktop->cursor.y)
+                x == desktop_shm->cursor.x && y == desktop_shm->cursor.y)
                 flags &= ~MOUSEEVENTF_MOVE;
         }
         else
         {
-            x = desktop->cursor.x + input->mouse.x;
-            y = desktop->cursor.y + input->mouse.y;
+            x = desktop_shm->cursor.x + input->mouse.x;
+            y = desktop_shm->cursor.y + input->mouse.y;
         }
     }
     else
     {
-        x = desktop->cursor.x;
-        y = desktop->cursor.y;
+        x = desktop_shm->cursor.x;
+        y = desktop_shm->cursor.y;
     }
 
     if ((foreground = get_foreground_thread( desktop, win )))
@@ -2044,7 +2056,7 @@ static int queue_mouse_message( struct desktop *desktop, user_handle_t win, cons
         raw_msg.time       = time;
         raw_msg.message    = WM_INPUT;
         raw_msg.flags      = flags;
-        rawmouse_init( &raw_msg.rawinput, &raw_msg.data.mouse, x - desktop->cursor.x, y - desktop->cursor.y,
+        rawmouse_init( &raw_msg.rawinput, &raw_msg.data.mouse, x - desktop_shm->cursor.x, y - desktop_shm->cursor.y,
                        raw_msg.flags, input->mouse.data, input->mouse.info );
 
         dispatch_rawinput_message( desktop, &raw_msg );
@@ -2246,6 +2258,7 @@ static void queue_pointer_message( struct pointer *pointer, int repeated )
     };
     struct hw_msg_source source = { IMDT_UNAVAILABLE, IMDT_TOUCH };
     struct desktop *desktop = pointer->desktop;
+    const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
     const hw_input_t *input = &pointer->input;
     unsigned int i, wparam = input->hw.wparam;
     timeout_t time = get_tick_count();
@@ -2268,8 +2281,8 @@ static void queue_pointer_message( struct pointer *pointer, int repeated )
         msg->msg       = messages[input->hw.msg - WM_POINTERUPDATE][i];
         msg->wparam    = wparam;
         msg->lparam    = MAKELONG(x, y);
-        msg->x         = desktop->cursor.x;
-        msg->y         = desktop->cursor.y;
+        msg->x         = desktop_shm->cursor.x;
+        msg->y         = desktop_shm->cursor.y;
 
         queue_hardware_message( desktop, msg, 1 );
     }
@@ -2324,6 +2337,7 @@ static struct pointer *find_pointer_from_id( struct desktop *desktop, unsigned i
 static void queue_custom_hardware_message( struct desktop *desktop, user_handle_t win,
                                            unsigned int origin, const hw_input_t *input )
 {
+    const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
     struct hw_msg_source source = { IMDT_UNAVAILABLE, origin };
     struct thread *foreground;
     struct pointer *pointer;
@@ -2368,8 +2382,8 @@ static void queue_custom_hardware_message( struct desktop *desktop, user_handle_
     msg->msg       = input->hw.msg;
     msg->wparam    = input->hw.wparam;
     msg->lparam    = input->hw.lparam;
-    msg->x         = desktop->cursor.x;
-    msg->y         = desktop->cursor.y;
+    msg->x         = desktop_shm->cursor.x;
+    msg->y         = desktop_shm->cursor.y;
 
     queue_hardware_message( desktop, msg, 1 );
 }
@@ -2917,6 +2931,7 @@ DECL_HANDLER(send_hardware_message)
     struct desktop *desktop;
     unsigned int origin = (req->flags & SEND_HWMSG_INJECTED ? IMO_INJECTED : IMO_HARDWARE);
     struct msg_queue *sender = req->flags & SEND_HWMSG_INJECTED ? get_current_queue() : NULL;
+    const desktop_shm_t *desktop_shm;
     int wait = 0;
 
     if (!(desktop = get_hardware_input_desktop( req->win ))) return;
@@ -2927,9 +2942,10 @@ DECL_HANDLER(send_hardware_message)
         set_error( STATUS_ACCESS_DENIED );
         return;
     }
+    desktop_shm = get_shared_desktop( desktop->session_index );
 
-    reply->prev_x = desktop->cursor.x;
-    reply->prev_y = desktop->cursor.y;
+    reply->prev_x = desktop_shm->cursor.x;
+    reply->prev_y = desktop_shm->cursor.y;
 
     switch (req->input.type)
     {
@@ -2947,8 +2963,8 @@ DECL_HANDLER(send_hardware_message)
     }
 
     reply->wait = sender ? wait : 0;
-    reply->new_x = desktop->cursor.x;
-    reply->new_y = desktop->cursor.y;
+    reply->new_x = desktop_shm->cursor.x;
+    reply->new_y = desktop_shm->cursor.y;
     release_object( desktop );
 }
 
@@ -3633,15 +3649,17 @@ DECL_HANDLER(set_cursor)
     struct msg_queue *queue = get_current_queue();
     struct thread_input *input;
     struct desktop *desktop;
+    const desktop_shm_t *desktop_shm;
 
     if (!queue) return;
     input = queue->input;
     desktop = input->desktop;
+    desktop_shm = get_shared_desktop( desktop->session_index );
 
     reply->prev_handle = input->cursor;
     reply->prev_count  = input->cursor_count;
-    reply->prev_x      = desktop->cursor.x;
-    reply->prev_y      = desktop->cursor.y;
+    reply->prev_x      = desktop_shm->cursor.x;
+    reply->prev_y      = desktop_shm->cursor.y;
 
     if (req->flags & SET_CURSOR_HANDLE)
     {
@@ -3664,8 +3682,8 @@ DECL_HANDLER(set_cursor)
     if (req->flags & (SET_CURSOR_HANDLE | SET_CURSOR_COUNT))
         update_desktop_cursor_handle( desktop, input );
 
-    reply->new_x       = desktop->cursor.x;
-    reply->new_y       = desktop->cursor.y;
+    reply->new_x       = desktop_shm->cursor.x;
+    reply->new_y       = desktop_shm->cursor.y;
     reply->new_clip    = desktop->cursor.clip;
     reply->last_change = desktop->cursor.last_change;
 }
diff --git a/server/user.h b/server/user.h
index 21d67656c9c..94c107116ed 100644
--- a/server/user.h
+++ b/server/user.h
@@ -56,8 +56,6 @@ struct winstation
 
 struct global_cursor
 {
-    int                  x;                /* cursor position */
-    int                  y;
     rectangle_t          clip;             /* cursor clip rectangle */
     unsigned int         last_change;      /* time of last position change */
     user_handle_t        win;              /* window that contains the cursor */
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 8/9] server: Move the last cursor time to the desktop session object.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

Based on a patch by Huw Davies <huw(a)codeweavers.com>.
---
 server/protocol.def |  1 +
 server/queue.c      | 17 +++++++++++------
 server/user.h       |  1 -
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/server/protocol.def b/server/protocol.def
index 736d2b0232c..32e94d02f28 100644
--- a/server/protocol.def
+++ b/server/protocol.def
@@ -882,6 +882,7 @@ struct shared_cursor
 {
     int                  x;                /* cursor position */
     int                  y;
+    unsigned int         last_change;      /* time of last position change */
 };
 
 typedef volatile struct
diff --git a/server/queue.c b/server/queue.c
index cba5514deef..85b2254ad12 100644
--- a/server/queue.c
+++ b/server/queue.c
@@ -468,6 +468,7 @@ static int update_desktop_cursor_pos( struct desktop *desktop, user_handle_t win
 {
     const desktop_shm_t *desktop_shm = get_shared_desktop( desktop->session_index );
     int updated;
+    unsigned int time = get_tick_count();
 
     x = max( min( x, desktop->cursor.clip.right - 1 ), desktop->cursor.clip.left );
     y = max( min( y, desktop->cursor.clip.bottom - 1 ), desktop->cursor.clip.top );
@@ -477,11 +478,10 @@ static int update_desktop_cursor_pos( struct desktop *desktop, user_handle_t win
         updated = shared->cursor.x != x || shared->cursor.y != y;
         shared->cursor.x = x;
         shared->cursor.y = y;
+        shared->cursor.last_change = time;
     }
     SHARED_WRITE_END;
 
-    desktop->cursor.last_change = get_tick_count();
-
     if (!win || !is_window_visible( win ) || is_window_transparent( win ))
         win = shallow_window_from_point( desktop, x, y );
     if (update_desktop_cursor_window( desktop, win )) updated = 1;
@@ -2000,7 +2000,7 @@ static int queue_mouse_message( struct desktop *desktop, user_handle_t win, cons
     struct rawinput_message raw_msg;
     struct message *msg;
     struct thread *foreground;
-    unsigned int i, time, flags;
+    unsigned int i, time = get_tick_count(), flags;
     struct hw_msg_source source = { IMDT_MOUSE, origin };
     int wait = 0, x, y;
 
@@ -2021,10 +2021,15 @@ static int queue_mouse_message( struct desktop *desktop, user_handle_t win, cons
         WM_MOUSEHWHEEL   /* 0x1000 = MOUSEEVENTF_HWHEEL */
     };
 
-    desktop->cursor.last_change = get_tick_count();
+    SHARED_WRITE_BEGIN( desktop_shm, desktop_shm_t )
+    {
+        shared->cursor.last_change = time;
+    }
+    SHARED_WRITE_END;
+
     flags = input->mouse.flags;
     time  = input->mouse.time;
-    if (!time) time = desktop->cursor.last_change;
+    if (!time) time = desktop_shm->cursor.last_change;
 
     if (flags & MOUSEEVENTF_MOVE)
     {
@@ -3685,7 +3690,7 @@ DECL_HANDLER(set_cursor)
     reply->new_x       = desktop_shm->cursor.x;
     reply->new_y       = desktop_shm->cursor.y;
     reply->new_clip    = desktop->cursor.clip;
-    reply->last_change = desktop->cursor.last_change;
+    reply->last_change = desktop_shm->cursor.last_change;
 }
 
 /* Get the history of the 64 last cursor positions */
diff --git a/server/user.h b/server/user.h
index 94c107116ed..4f98ce46ffa 100644
--- a/server/user.h
+++ b/server/user.h
@@ -57,7 +57,6 @@ struct winstation
 struct global_cursor
 {
     rectangle_t          clip;             /* cursor clip rectangle */
-    unsigned int         last_change;      /* time of last position change */
     user_handle_t        win;              /* window that contains the cursor */
 };
 
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[PATCH v25 9/9] win32u: Use the desktop shared data for GetCursorPos.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

Based on a patch by Huw Davies <huw(a)codeweavers.com>.
---
 dlls/win32u/input.c      | 21 +++++++++++++--------
 dlls/win32u/winstation.c |  2 --
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/dlls/win32u/input.c b/dlls/win32u/input.c
index 4a7c04f66c5..6728dbc5b24 100644
--- a/dlls/win32u/input.c
+++ b/dlls/win32u/input.c
@@ -739,22 +739,27 @@ BOOL WINAPI NtUserSetCursorPos( INT x, INT y )
  */
 BOOL get_cursor_pos( POINT *pt )
 {
-    BOOL ret;
-    DWORD last_change;
+    struct object_lock lock = {0};
+    BOOL ret = FALSE;
+    DWORD last_change = 0;
     UINT dpi;
 
     if (!pt) return FALSE;
 
-    SERVER_START_REQ( set_cursor )
+    while (get_shared_desktop( &lock ))
     {
-        if ((ret = !wine_server_call( req )))
+        BOOL valid;
+        SHARED_READ_BEGIN( &lock.shared->desktop, desktop_shm_t )
         {
-            pt->x = reply->new_x;
-            pt->y = reply->new_y;
-            last_change = reply->last_change;
+            valid = lock.id == shared->obj.id;
+            pt->x = shared->cursor.x;
+            pt->y = shared->cursor.y;
+            last_change = shared->cursor.last_change;
         }
+        SHARED_READ_END;
+        object_lock_release( &lock );
+        if ((ret = valid)) break;
     }
-    SERVER_END_REQ;
 
     /* query new position from graphics driver if we haven't updated recently */
     if (ret && NtGetTickCount() - last_change > 100) ret = user_driver->pGetCursorPos( pt );
diff --git a/dlls/win32u/winstation.c b/dlls/win32u/winstation.c
index 908d2b09344..d3303fca254 100644
--- a/dlls/win32u/winstation.c
+++ b/dlls/win32u/winstation.c
@@ -462,12 +462,10 @@ BOOL WINAPI NtUserSetThreadDesktop( HDESK handle )
         struct user_thread_info *thread_info = get_user_thread_info();
         struct user_key_state_info *key_state_info = thread_info->key_state;
         struct object_info *desktop_info = &get_session_thread_data()->shared_desktop;
-        struct object_lock lock = {0};
         thread_info->client_info.top_window = 0;
         thread_info->client_info.msg_window = 0;
         if (key_state_info) key_state_info->time = 0;
         memset( desktop_info, 0, sizeof(*desktop_info) );
-        if (get_shared_desktop( &lock )) object_lock_release( &lock );
         if (was_virtual_desktop != is_virtual_desktop()) update_display_cache( TRUE );
     }
     return ret;
-- 
GitLab

https://gitlab.winehq.org/wine/wine/-/merge_requests/3103

[Rémi Bernon]

On Sat Mar 16 20:15:15 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#35a0b3c4868b938764504464c7e3891ad9581e77_248_226)
> Done, differently.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65029

[Rémi Bernon]

On Sat Mar 16 20:15:15 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#35a0b3c4868b938764504464c7e3891ad9581e77_869_841)
> Done, then removed.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65030

[Rémi Bernon]

On Sat Mar 16 20:15:16 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#35a0b3c4868b938764504464c7e3891ad9581e77_869_841)
> This was done in the commit that introduces the shared session in order for the code to be used. I now removed it in the commit that introduces the thread desktop. Note that the same thing is true for the thread desktop, it's not necessary to initialize it when thread desktop is changed, but it is needed to avoid dead code until thread desktop is actually used for get_cursor_pos.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65031

[Rémi Bernon]

On Sat Mar 16 20:15:17 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#35a0b3c4868b938764504464c7e3891ad9581e77_217_190)
> Actually I changed this to fill the object info directly and return NTSTATUS, makes this cleaner.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65032

[Rémi Bernon]

On Sat Mar 16 20:15:18 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#2b37d5dc1c3bb6a637f043480c038caea64531bb_1303_1307)
> Done.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65033

[Rémi Bernon]

On Sat Mar 16 20:15:18 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#35a0b3c4868b938764504464c7e3891ad9581e77_243_214)
> Changed to clear info on failure. Then I don't think it needs to be initially cleared anymore with the other changes, as all the fields are written to on success.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65034

[Rémi Bernon]

On Sat Mar 16 20:15:20 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#4d68a309272d18487b10981d1a19afc828e3dca6_212_209)
> No reason, I don't think it matters. Changed nonetheless.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65035

[Rémi Bernon]

On Sat Mar 16 20:15:21 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#f4827eaac5000d9e0cb10ecd13fa0e88138746ac_384_384)
> Done.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65036

[Rémi Bernon]

On Sat Mar 16 09:44:19 2024 +0000, Jinoh Kang wrote:
> Is this needed?
#include <stdarg.h>
#include <stddef.h>

#include "windef.h"
#include "winbase.h"

Seemed to be the minimal include sequence that was used recently in many places. With some variation when "ntstatus.h" is needed. It's probably not necessary here because <pthread.h> includes it already but it made things more consistent.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65037

[Rémi Bernon]

On Sat Mar 16 20:15:22 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#35a0b3c4868b938764504464c7e3891ad9581e77_72_71)
> Done.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65038

[Rémi Bernon]

On Sat Mar 16 20:15:23 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#35a0b3c4868b938764504464c7e3891ad9581e77_209_179)
> Changed to `get_thread_session_object_info`.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65039

[Rémi Bernon]

On Sat Mar 16 20:15:24 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#35a0b3c4868b938764504464c7e3891ad9581e77_146_141)
> Removed, it was there from before, when I thought we had to do the size query explicitly.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65040

[Rémi Bernon]

On Sat Mar 16 20:15:27 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#14b74bf2d7f44f52a31e4ee1baa51371f14df769_2275_2275)
> Done.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65041

[Rémi Bernon]

On Sat Mar 16 09:44:22 2024 +0000, Jinoh Kang wrote:
> This will scan the entire objects array once the last index has been
> occupied (object\_count full).
> Instead, how about replacing `object_count` with `last_object_index`?
> This field doesn't actually count valid objects anyway, since some
> objects in the middle could be freed later. Instead, I would keep track
> of the *last* object index and start from there.
> ```suggestion:-20+0
>     unsigned int index = session.last_object_index;
>     for (;;)
>     {
>         index = (index + 1) % session.shared->object_capacity;
>         if (!session.shared->objects[index].obj.id)
>         {
>             /* found a free index */
>             break;
>         }
>         /* check if we're back to the starting point */
>         if (index == session.last_object_index)
>         {
>             /* all slots exhausted; skip to first index to be allocated */
>             index = session.shared->object_capacity;
>             break;
>         }
>     }
>     while (index >= session.shared->object_capacity)
>     {
>         if (grow_session_mapping()) return -1;
>     }
>     session.last_object_index = index;
>     SHARED_WRITE_BEGIN( &session.shared->objects[index], session_obj_t )
>     {
>         assert(!shared->obj.id);
>         shared->obj.id = ++session.last_object_id;
>     }
>     SHARED_WRITE_END;
> ```
> Note that the following initialization is also required:
> ```c
>     session.last_object_index = -1;
> ```
> I've changed it to something similar, though mostly because it makes the code slightly simpler. I don't see what difference it makes as looking from a free index starting from the previous one doesn't seem obviously more efficient than from the beginning.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65042

[Rémi Bernon]

On Sat Mar 16 20:15:25 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#65b3cab82e46519733db1b5e9ec0bae066630154_750_751)
> Done.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65043

[Rémi Bernon]

On Sat Mar 16 20:15:27 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#2b37d5dc1c3bb6a637f043480c038caea64531bb_231_231)
> Done.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65044

[Rémi Bernon]

On Sat Mar 16 20:15:28 2024 +0000, Rémi Bernon wrote:
> changed this line in [version 25 of the diff](/wine/wine/-/merge_requests/3103/diffs?diff_id=105562&start_sha=7a6dd3e2b3740cd43c5cace9892032d2d99c17c3#65b3cab82e46519733db1b5e9ec0bae066630154_746_747)
> Done.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65045

[Rémi Bernon]

On Sat Mar 16 20:16:29 2024 +0000, Jinoh Kang wrote:
> Additionally, I think the current session tracking logic can be greatly
> simplified by removing the id: see
> https://gitlab.winehq.org/iamahuman/wine/-/commit/f6697367fb1447c5508b6ec990...
> (untested).
> Yeah, it doesn't look completely correct there but I've included something similar I think.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65046

[Jinoh Kang (＠iamahuman)]

On Sat Mar 16 20:16:14 2024 +0000, Rémi Bernon wrote:
> Actually I changed this to fill the object info directly and return
> NTSTATUS, makes this cleaner.
> We're still using `wine_server_call_err`, so we're still setting Win32 LastError *in addition to* returning NTSTATUS.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65061

[Jinoh Kang (＠iamahuman)]

> I don't think this holds if we can guarantee capacity ≥ 3:

You're right, in fact we can see straightforwardly that

```math
\newcommand{\OP}{\mathsf{OldPages}}
\newcommand{\Ps}{\mathsf{PageSize}}
\newcommand{\Hs}{\mathsf{HeadSize}}
\newcommand{\Es}{\mathsf{EltSize}}
\\[1ex]
\begin{align*}
1&> k\\
 &> \frac23\cdot\frac\Ps\Es + \frac13\cdot\frac{\OP\cdot\Ps - \Hs}\Es\\[2ex]
 &> \frac13\cdot\frac{\OP\cdot\Ps - \Hs}\Es\\
 &\geq \frac13\cdot\left(\text{\textsf{old capacity}}\right)
\end{align*}
```

doesn't hold for (old capacity) ≥ 3, but that doesn't hold for 3⋅EltSize ≤ 2⋅PageSize either (which is currently the case).

I'm not saying this code is incorrect, but that this function in isolation could (and arguably should) guard against otherwise benign future patches, such as element size extension or initial capacity adjustment.
> I don't see what you mean by that, where is this guarded exactly?

In <https://gitlab.winehq.org/wine/wine/-/blob/552cc456d1889ab3ee0dd5ead6c7520c34d030c0/server/fd.c#L2692> and <https://gitlab.winehq.org/wine/wine/-/blob/552cc456d1889ab3ee0dd5ead6c7520c34d030c0/server/mapping.c#L1028>, others being not a problem a priori due to working on a new empty temporary file.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65062

[Jinoh Kang (＠iamahuman)]

Jinoh Kang (@iamahuman) commented about dlls/win32u/winstation.c:
> +            ERR( "Failed to map session mapping, status %#x\n", status );
> +            free( session );
> +            session = NULL;
> +            goto done;
> +        }
> +
> +        if (shared_session) shared_session_release( shared_session );
> +        shared_session = session;
> +    }
> +
> +    session = shared_session_acquire( shared_session );
> +
> +done:
> +    pthread_mutex_unlock( &session_lock );
> +
> +    return session;
> `session` is uninitialized if `!(force || !shared_session)`.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65152

[Jinoh Kang (＠iamahuman)]

Jinoh Kang (@iamahuman) commented about dlls/win32u/winstation.c:
> +struct object_info
> +{
> +    UINT64 id;
> +    UINT index;
> +};
> +
> +struct session_thread_data
> +{
> +    struct object_info shared_desktop;         /* thread desktop shared session object info */
> +};
> +
> +struct shared_session
> +{
> +    LONG ref;
> +    UINT64 id;

This field seems never read.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65153

[Jinoh Kang (＠iamahuman)]

On Sun Mar 17 18:18:46 2024 +0000, Jinoh Kang wrote:
> > I don't think this holds if we can guarantee capacity ≥ 3:
> > You're right, in fact we can see straightforwardly that
> \newcommand{\OP}{\mathsf{OldPages}}
> \newcommand{\Ps}{\mathsf{PageSize}}
> \newcommand{\Hs}{\mathsf{HeadSize}}
> \newcommand{\Es}{\mathsf{EltSize}}
> \\[1ex]
> \begin{align*}
> 1&> k\\
>  &> \frac23\cdot\frac\Ps\Es + \frac13\cdot\frac{\OP\cdot\Ps - \Hs}\Es\\[2ex]
>  &> \frac13\cdot\frac{\OP\cdot\Ps - \Hs}\Es\\
>  &\geq \frac13\cdot\left(\text{\textsf{old capacity}}\right)
> \end{align*}
>
> doesn't hold for (old capacity) ≥ 3, but that doesn't hold for 3⋅EltSize
> ≤ 2⋅PageSize either (which is currently the case).
> I'm not saying this code is incorrect, but that this function in
> isolation could (and arguably should) guard against otherwise benign
> future patches, such as element size extension or initial capacity adjustment.
> > I don't see what you mean by that, where is this guarded exactly?
> > In
> > <https://gitlab.winehq.org/wine/wine/-/blob/552cc456d1889ab3ee0dd5ead6c7520c34d030c0/server/fd.c#L2692>
> > and
> > <https://gitlab.winehq.org/wine/wine/-/blob/552cc456d1889ab3ee0dd5ead6c7520c34d030c0/server/mapping.c#L1028>,
> > others being not a problem a priori due to working on a new empty
> > temporary file.
> > @rbernon has pointed out that the capacity is always derived from the mapping size, which means that we can assume that the capacity is the greatest that can fill the given mapping.

Rewriting above in terms of old capacity so that truncated (i.e. does not fill the mapping) capacity is ruled out, the inequality (for non-growth) becomes:

```math
k > \tfrac12\cdot\mathsf{OldCapacity} + \mathsf{PageSize}/\mathsf{EltSize}
```

In general, for growth rate "1 + *g*", the equation is:

```math
k > g\cdot\mathsf{OldCapacity} + \mathsf{PageSize}/\mathsf{EltSize}
```

In the particular case of "*g* = ½" (in this MR), "capacity ≥ 2" is enough to guarantee that the mapping size increases. However, if it's reduced to a more modest growth rate, the minimum bar for capacity increases.

In short, the following two conditions are required for non-growth (the problem of interest):

1. **The element size is greater than the page size.**
   This might happen if we end up needing larger chunks of data that contains e.g. key state array.

2. **The old capacity is less than *g*<sup>-1</sup> (the inverse of the growth rate minus 1).** This might happen if we decide that the current growth rate is too fast and slow it down. For example, if "*g* = 1/32", then just "capacity = 31" satisfies the condition.

Although it might sound unlikely, I wouldn't completely rule out either possibility. I'd argue that it's always a good idea to insert explicit assertions[^1] locally rather than relying on the implicit environment (invariant conditions upheld by distant functions), especially since we'll probably end up putting more things into the shared mapping as new performance bottlenecks are discovered.

[^1]: One `assert()` statement in this case

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65154

[Jinoh Kang (＠iamahuman)]

On Mon Mar 18 06:39:16 2024 +0000, Jinoh Kang wrote:
> @rbernon has pointed out that the capacity is always derived from the
> mapping size, which means that we can assume that the capacity is the
> greatest that can fill the given mapping.
> Rewriting above in terms of old capacity so that truncated capacity
> (i.e. does not fill the mapping) is ruled out, the inequality (for
> non-growth) becomes:
> ```math
> k > \tfrac12\cdot\mathsf{OldCapacity} + \mathsf{PageSize}/\mathsf{EltSize}
> ```
> In general, for growth rate (1 + *g*), the equation is:
> ```math
> k > g\cdot\mathsf{OldCapacity} + \mathsf{PageSize}/\mathsf{EltSize}
> ```
> In the particular case of "*g* = ½" (in this MR), "capacity ≥ 2" is
> enough to guarantee that the mapping size increases. However, if it's
> reduced to a more modest growth rate, the minimum bar for capacity increases.
> In short, the following two conditions are required for non-growth (the
> problem of interest):
> 1. **The element size is greater than the page size.**
>    This might happen if we end up needing larger chunks of data that
> contains e.g. key state array.
> 2. **The old capacity is less than *g*<sup>-1</sup> (the inverse of the
> growth rate minus 1).** This might happen if we decide that the current
> growth rate is too fast and slow it down. For example, if "*g* = 1/32",
> then just "capacity = 31" satisfies the condition.[^c]
> Although it might sound unlikely, I wouldn't completely rule out either
> possibility. I'd argue that it's always a good idea to insert explicit
> assertions[^1] locally rather than relying on the implicit environment
> (invariant conditions upheld by surrounding code or distant functions),
> especially since we'll probably end up putting more things into the
> shared mapping as new performance bottlenecks are discovered. Assertions
> also improve clarity IMHO.
> [^c]: We can of course blame the incorrect initial capacity, but I don't
> see this kind of mistake as outlandish.
> [^1]: One `assert()` statement in this case
> As a concrete example, if the growth expression becomes `* 33 / 32` but initial capacity = 31, we won't be able to notice it because of page-unit roundup. After a while, someone enlarges the object size and/or make changes to allocation strategy, which will be blamed for regression until the initial faulty capacity is revealed as the root cause.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65156

[Jinoh Kang (＠iamahuman)]

On Mon Mar 18 07:29:20 2024 +0000, Jinoh Kang wrote:
> As a concrete example, if the growth expression becomes `* 33 / 32` but
> initial capacity = 31, we won't be able to notice it because of
> page-unit roundup. After a while, someone enlarges the object size
> and/or make changes to allocation strategy, which will be blamed for
> regression until the initial faulty capacity is revealed as the root cause.
> Actually I think I got `grow_file()` wrong; it doesn't fail even if I give it the current size (0% growth). Decrement is not possible. Marking this resolved.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65157

[Jinoh Kang (＠iamahuman)]

Jinoh Kang (@iamahuman) commented about server/mapping.c:
> +        shared->object_capacity = (mapping->size - offsetof(session_shm_t, objects[0])) / sizeof(session_obj_t);
> +    }
> +    SHARED_WRITE_END;
> +}
> +
> +static int grow_session_mapping(void)
> +{
> +    unsigned int capacity;
> +    mem_size_t size;
> +    int unix_fd;
> +    void *tmp;
> +
> +    capacity = session.shared->object_capacity * 3 / 2;
> +    size = offsetof(session_shm_t, objects[capacity]);
> +    size = (size + page_mask) & ~((mem_size_t)page_mask);
> +
> The growth rate is not kept in sync with initial capacity, so it's possible that `grow_session_mapping` ends up doing nothing (0% increment) since the initial capacity is too small (e.g. capacity = 31, growth = 33/32).  However, `alloc_shared_object` does not check for this condition, resulting in OOB.

So I think either `grow_session_mapping` or `alloc_shared_object` should have an assert for size growth (see the other thread). Note that decrement is not possible—I got this part wrong, sorry.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65158

[Rémi Bernon]

On Mon Mar 18 06:22:01 2024 +0000, Jinoh Kang wrote:
> `session` is uninitialized if `!(force || !shared_session)`.
> Uh? What about the `session = shared_session_acquire( shared_session );` part?

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3103#note_65167