wine/wine-staging
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-staging.git synced 2024-09-13 09:17:20 -07:00
Code Issues Packages Projects Releases Wiki Activity

SRWLock patch is now included in upstream Wine.

Browse Source
This commit is contained in:
Erich E. Hoover 2014-01-17 11:26:48 -07:00
parent 24af73d1d2
commit 6274002623
3 changed files with 1 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
patches/08-SRWLock/0001-ntdll-Implement-SRWLock-functions-using-keyed-events.patch
View File

@ -1,207 +0,0 @@
From 7324234ddce315b21a31e9e810593ea0c6917384 Mon Sep 17 00:00:00 2001
From: Sebastian Lackner <sebastian@fds-team.de>
Date: Sat, 11 Jan 2014 02:18:10 +0100
Subject: ntdll: Implement SRWLock functions using keyed events
---
dlls/kernel32/tests/sync.c | 6 ---
dlls/ntdll/sync.c | 119 ++++++++++++++++++++++++++++++++++++++++++--
2 files changed, 115 insertions(+), 10 deletions(-)
diff --git a/dlls/kernel32/tests/sync.c b/dlls/kernel32/tests/sync.c
index e5d1353..c7cceaa 100644
--- a/dlls/kernel32/tests/sync.c
+++ b/dlls/kernel32/tests/sync.c
@@ -1890,9 +1890,6 @@ static void test_srwlock_base(void)
WaitForSingleObject(h2, 100);
WaitForSingleObject(h3, 100);
- /* the current implementation just consists of stubs and all tests fail */
- todo_wine
- {
ok(!srwlock_base_errors.wrong_execution_order,
"thread commands were executed in the wrong order (occurred %d times).\n",
srwlock_base_errors.wrong_execution_order);
@@ -1916,7 +1913,6 @@ static void test_srwlock_base(void)
ok(!srwlock_base_errors.excl_not_preferred,
"thread waiting for exclusive access to the SHMLock was not preferred (occurred %d times).\n",
srwlock_base_errors.excl_not_preferred);
- }
}
static SRWLOCK srwlock_example;
@@ -1994,8 +1990,6 @@ static void test_srwlock_example(void)
WaitForSingleObject(h3, 1000);
ok(!srwlock_inside, "threads didn't terminate properly, srwlock_inside is %d.\n", srwlock_inside);
-
- todo_wine
ok(!srwlock_example_errors, "errors occured while running SRWLock example test (number of errors: %d)\n",
srwlock_example_errors);
diff --git a/dlls/ntdll/sync.c b/dlls/ntdll/sync.c
index c94d9c4..d68be50 100644
--- a/dlls/ntdll/sync.c
+++ b/dlls/ntdll/sync.c
@@ -1382,8 +1382,88 @@ DWORD WINAPI RtlRunOnceExecuteOnce( RTL_RUN_ONCE *once, PRTL_RUN_ONCE_INIT_FN fu
return RtlRunOnceComplete( once, 0, context ? *context : NULL );
}
+#define SRWLOCK_MASK_IN_EXCLUSIVE 0x80000000
+#define SRWLOCK_MASK_EXCLUSIVE_QUEUE 0x7fff0000
+#define SRWLOCK_MASK_SHARED_QUEUE 0x0000ffff
+#define SRWLOCK_RES_EXCLUSIVE 0x00010000
+#define SRWLOCK_RES_SHARED 0x00000001
+
+#ifdef WORDS_BIGENDIAN
+#define srwlock_key_exclusive(lock) (&lock->Ptr)
+#define srwlock_key_shared(lock) ((void *)((char *)&lock->Ptr + 2))
+#else
+#define srwlock_key_exclusive(lock) ((void *)((char *)&lock->Ptr + 2))
+#define srwlock_key_shared(lock) (&lock->Ptr)
+#endif
+
+static inline unsigned int srwlock_lock_exclusive( unsigned int *dest, int incr )
+{
+ unsigned int val, tmp;
+ /* Atomically modifies the value of *dest by adding incr. If the shared
+ * queue is empty and there are threads waiting for exclusive access, then
+ * sets the mark SRWLOCK_MASK_IN_EXCLUSIVE to signal other threads that
+ * they are allowed to use again the shared queue counter. */
+ for (val = *dest;; val = tmp)
+ {
+ tmp = val + incr;
+ if ((tmp & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(tmp & SRWLOCK_MASK_SHARED_QUEUE))
+ tmp |= SRWLOCK_MASK_IN_EXCLUSIVE;
+ if ((tmp = interlocked_cmpxchg( (int *)dest, tmp, val )) == val)
+ break;
+ }
+ return val;
+}
+
+static inline unsigned int srwlock_unlock_exclusive( unsigned int *dest, int incr )
+{
+ unsigned int val, tmp;
+ /* Atomically modifies the value of *dest by adding incr. If the queue of
+ * threads waiting for exclusive access is empty, then remove the
+ * SRWLOCK_MASK_IN_EXCLUSIVE flag (only the shared queue counter will
+ * remain). */
+ for (val = *dest;; val = tmp)
+ {
+ tmp = val + incr;
+ if (!(tmp & SRWLOCK_MASK_EXCLUSIVE_QUEUE))
+ tmp &= SRWLOCK_MASK_SHARED_QUEUE;
+ if ((tmp = interlocked_cmpxchg( (int *)dest, tmp, val )) == val)
+ break;
+ }
+ return val;
+}
+
+static inline void srwlock_leave_exclusive( RTL_SRWLOCK *lock, unsigned int val )
+{
+ /* Used when a thread leaves an exclusive section. If there are other
+ * exclusive access threads they are processed first, afterwards process
+ * the shared waiters. */
+ if (val & SRWLOCK_MASK_EXCLUSIVE_QUEUE)
+ NtReleaseKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
+ else
+ {
+ val &= SRWLOCK_MASK_SHARED_QUEUE; /* remove SRWLOCK_MASK_IN_EXCLUSIVE */
+ while (val--)
+ NtReleaseKeyedEvent( keyed_event, srwlock_key_shared(lock), FALSE, NULL );
+ }
+}
+
+static inline void srwlock_leave_shared( RTL_SRWLOCK *lock, unsigned int val )
+{
+ /* Wake up one exclusive thread as soon as the last shared access thread
+ * has left. */
+ if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_SHARED_QUEUE))
+ NtReleaseKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
+}
+
/***********************************************************************
* RtlInitializeSRWLock (NTDLL.@)
+ *
+ * NOTES
+ * Please note that SRWLocks do not keep track of the owner of a lock.
+ * It doesn't make any difference which thread for example unlocks an
+ * SRWLock (see corresponding tests). This implementation uses two
+ * keyed events (one for the exclusive waiters and one for the shared
+ * waiters) and is limited to 2^15-1 waiting threads.
*/
void WINAPI RtlInitializeSRWLock( RTL_SRWLOCK *lock )
{
@@ -1392,10 +1472,16 @@ void WINAPI RtlInitializeSRWLock( RTL_SRWLOCK *lock )
/***********************************************************************
* RtlAcquireSRWLockExclusive (NTDLL.@)
+ *
+ * NOTES
+ * Unlike RtlAcquireResourceExclusive this function doesn't allow
+ * nested calls from the same thread. "Upgrading" a shared access lock
+ * to an exclusive access lock also doesn't seem to be supported.
*/
void WINAPI RtlAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
{
- FIXME( "%p stub\n", lock );
+ if (srwlock_lock_exclusive( (unsigned int *)&lock->Ptr, SRWLOCK_RES_EXCLUSIVE ))
+ NtWaitForKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
}
/***********************************************************************
@@ -1403,7 +1489,30 @@ void WINAPI RtlAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
*/
void WINAPI RtlAcquireSRWLockShared( RTL_SRWLOCK *lock )
{
- FIXME( "%p stub\n", lock );
+ unsigned int val, tmp;
+ /* Acquires a shared lock. If its currently not possible to add elements to
+ * the shared queue, then request exclusive access instead. */
+ for (val = *(unsigned int *)&lock->Ptr;; val = tmp)
+ {
+ if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_IN_EXCLUSIVE))
+ tmp = val + SRWLOCK_RES_EXCLUSIVE;
+ else
+ tmp = val + SRWLOCK_RES_SHARED;
+ if ((tmp = interlocked_cmpxchg( (int *)&lock->Ptr, tmp, val )) == val)
+ break;
+ }
+
+ /* Drop exclusive access again and instead requeue for shared access. */
+ if ((val & SRWLOCK_MASK_EXCLUSIVE_QUEUE) && !(val & SRWLOCK_MASK_IN_EXCLUSIVE))
+ {
+ NtWaitForKeyedEvent( keyed_event, srwlock_key_exclusive(lock), FALSE, NULL );
+ val = srwlock_unlock_exclusive( (unsigned int *)&lock->Ptr, (SRWLOCK_RES_SHARED
+ - SRWLOCK_RES_EXCLUSIVE) ) - SRWLOCK_RES_EXCLUSIVE;
+ srwlock_leave_exclusive( lock, val );
+ }
+
+ if (val & SRWLOCK_MASK_EXCLUSIVE_QUEUE)
+ NtWaitForKeyedEvent( keyed_event, srwlock_key_shared(lock), FALSE, NULL );
}
/***********************************************************************
@@ -1411,7 +1520,8 @@ void WINAPI RtlAcquireSRWLockShared( RTL_SRWLOCK *lock )
*/
void WINAPI RtlReleaseSRWLockExclusive( RTL_SRWLOCK *lock )
{
- FIXME( "%p stub\n", lock );
+ srwlock_leave_exclusive( lock, srwlock_unlock_exclusive( (unsigned int *)&lock->Ptr,
+ - SRWLOCK_RES_EXCLUSIVE ) - SRWLOCK_RES_EXCLUSIVE );
}
/***********************************************************************
@@ -1419,7 +1529,8 @@ void WINAPI RtlReleaseSRWLockExclusive( RTL_SRWLOCK *lock )
*/
void WINAPI RtlReleaseSRWLockShared( RTL_SRWLOCK *lock )
{
- FIXME( "%p stub\n", lock );
+ srwlock_leave_shared( lock, srwlock_lock_exclusive( (unsigned int *)&lock->Ptr,
+ - SRWLOCK_RES_SHARED ) - SRWLOCK_RES_SHARED );
}
/***********************************************************************
--
1.7.9.5

3
patches/08-SRWLock/17545d49-1dfc-4294-bb30-2df2f29b0d95.def
View File

@ -1,3 +0,0 @@
Revision: 1
Author: Sebastian Lackner
Title: Implementation of SRWLock functions.

3
patches/patch-list.patch
View File

@ -33,7 +33,7 @@ diff --git a/libs/wine/config.c b/libs/wine/config.c
index a273502..5fa0cd5 100644
--- a/libs/wine/config.c
+++ b/libs/wine/config.c
@@ -478,6 +478,35 @@ const char *wine_get_version(void)
@@ -478,6 +478,34 @@ const char *wine_get_version(void)
return PACKAGE_VERSION;
}
@ -50,7 +50,6 @@ index a273502..5fa0cd5 100644
+ { "cbe240e8-2c58-430a-b61c-7fbb9d0e1e11:1", "Sebastian Lackner", "Change return value of stub SetNamedPipeHandleState to TRUE." },
+ { "00273da7-72f8-4025-9e96-0c2bc95dacdb:2", "Maarten Lankhorst", "Winepulse patches extracted from https://launchpad.net/~mlankhorst/+archive/ppa/+files/wine1.7_1.7.10-0ubuntu1~saucy1.debian.tar.gz." },
+ { "29b2af38-7edd-11e3-a08d-0090f5c75ad5:1", "Erich E. Hoover", "Add support for security access parameters for named pipes." },
+ { "17545d49-1dfc-4294-bb30-2df2f29b0d95:1", "Sebastian Lackner", "Implementation of SRWLock functions." },
+ { "5fb1f5c8-7f17-11e3-9b62-0090f5c75ad5:1", "Erich E. Hoover", "Implement TransmitFile." },
+ { "0b21d7ac-0387-4493-aa38-fbafe3e749f5:1", "Michael Müller", "Decrease minimum SetTimer interval from 15 to 5 ms." },
+ { "19835498-8d90-4673-867e-2376af4d7c76:1", "Sebastian Lackner", "Allow to set wined3d strictDrawOrdering via environment variable." },