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

[Rémi Bernon]

From: Rémi Bernon

---
 server/file.h       |  4 +++
 server/mapping.c    | 76 +++++++++++++++++++++++++++++++++++++++++++++
 server/protocol.def |  6 ++++
 server/user.h       |  1 +
 server/winstation.c |  8 +++++
 5 files changed, 95 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..c55cd1efda9 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,80 @@ 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;
+    assert( capacity > session.shared->object_capacity );
+    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 */