[PATCH v23 3/8] win32u: Open the global session shared mapping.

[Rémi Bernon]

From: Rémi Bernon

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

diff --git a/dlls/win32u/win32u_private.h b/dlls/win32u/win32u_private.h
index eba9a3389eb..f74bda54f17 100644
--- a/dlls/win32u/win32u_private.h
+++ b/dlls/win32u/win32u_private.h
@@ -361,4 +361,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..9066a7279b7 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,112 @@ 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) )))
+        {
+            pthread_mutex_unlock( &session_lock );
+            return NULL;
+        }
+        session->ref = 1;
+
+        InitializeObjectAttributes( &attr, &name, 0, NULL, NULL );
+        if (!(status = NtOpenSection( &handle, SECTION_MAP_READ | SECTION_QUERY, &attr )))
+        {
+            status = map_shared_session_section( session, handle );
+            NtClose( handle );
+        }
+
+        if (status)
+        {
+            ERR( "Failed to map session mapping, status %#x\n", status );
+            free( session );
+        }
+        else
+        {
+            if (shared_session) shared_session_release( shared_session );
+            shared_session = session;
+        }
+    }
+
+    session = shared_session_acquire( shared_session );
+
+    pthread_mutex_unlock( &session_lock );
+
+    return session;
+}
+
 BOOL is_virtual_desktop(void)
 {
     HANDLE desktop = NtUserGetThreadDesktop( GetCurrentThreadId() );
@@ -636,6 +745,8 @@ void winstation_init(void)

static const WCHAR winsta0[] = {'W','i','n','S','t','a','0',0};

+    shared_session = get_shared_session( FALSE );
+
     if (params->Desktop.Length)
     {
         buffer = malloc( params->Desktop.Length + sizeof(WCHAR) );