CCF_100/linux-tkg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
429e8ee9be
linux-tkg/linux-tkg-patches/5.12/0007-v5.12-winesync.patch

3128 lines
86 KiB
Diff
Raw Normal View History

linux512-tkg: Import winesync patchset - https://repo.or.cz/linux/zf.git/shortlog/refs/heads/winesync
2021-05-07 11:57:33 -05:00
diff --git a/Documentation/admin-guide/devices.txt b/Documentation/admin-guide/devices.txt
index 63fd4e6a014b..dc9a30b5f1a2 100644
--- a/Documentation/admin-guide/devices.txt
+++ b/Documentation/admin-guide/devices.txt
@@ -376,8 +376,9 @@
240 = /dev/userio Serio driver testing device
241 = /dev/vhost-vsock Host kernel driver for virtio vsock
242 = /dev/rfkill Turning off radio transmissions (rfkill)
+ 243 = /dev/winesync Wine synchronization primitive device
- 243-254 Reserved for local use
+ 244-254 Reserved for local use
255 Reserved for MISC_DYNAMIC_MINOR
11 char Raw keyboard device (Linux/SPARC only)
diff --git a/Documentation/userspace-api/index.rst b/Documentation/userspace-api/index.rst
index d29b020e5622..d2ddbf9ad8cb 100644
--- a/Documentation/userspace-api/index.rst
+++ b/Documentation/userspace-api/index.rst
@@ -25,6 +25,7 @@ place where this information is gathered.
iommu
media/index
sysfs-platform_profile
+ winesync
.. only:: subproject and html
diff --git a/Documentation/userspace-api/ioctl/ioctl-number.rst b/Documentation/userspace-api/ioctl/ioctl-number.rst
index 599bd4493944..825c6b2d2623 100644
--- a/Documentation/userspace-api/ioctl/ioctl-number.rst
+++ b/Documentation/userspace-api/ioctl/ioctl-number.rst
@@ -366,6 +366,8 @@ Code Seq# Include File Comments
<mailto:thomas@winischhofer.net>
0xF6 all LTTng Linux Trace Toolkit Next Generation
<mailto:mathieu.desnoyers@efficios.com>
+0xF7 00-0F uapi/linux/winesync.h Wine synchronization primitives
+ <mailto:wine-devel@winehq.org>
0xFD all linux/dm-ioctl.h
0xFE all linux/isst_if.h
==== ===== ======================================================= ================================================================
diff --git a/Documentation/userspace-api/winesync.rst b/Documentation/userspace-api/winesync.rst
new file mode 100644
index 000000000000..751c70f1ffce
--- /dev/null
+++ b/Documentation/userspace-api/winesync.rst
@@ -0,0 +1,373 @@
+=====================================
+Wine synchronization primitive driver
+=====================================
+
+This page documents the user-space API for the winesync driver.
+
+winesync is a support driver for emulation of NT synchronization
+primitives by the Wine project. It exists because implementation in
+user-space, using existing tools, cannot satisfy performance,
+correctness, and security constraints. It is implemented entirely in
+software, and does not drive any hardware device.
+
+This interface is meant as a compatibility tool only and should not be
+used for general synchronization; instead use generic, versatile
+interfaces such as futex(2) and poll(2).
+
+Synchronization primitives
+==========================
+
+The winesync driver exposes two types of synchronization primitives,
+semaphores and mutexes.
+
+A semaphore holds a single volatile 32-bit counter, and a static
+32-bit integer denoting the maximum value. It is considered signaled
+when the counter is nonzero. The counter is decremented by one when a
+wait is satisfied. Both the initial and maximum count are established
+when the semaphore is created.
+
+A mutex holds a volatile 32-bit recursion count, and a volatile 32-bit
+identifier denoting its owner. The latter is intended to identify the
+thread holding the mutex; however, it is not actually validated
+against earlier calls made by the same thread. A mutex is considered
+signaled when its owner is zero (indicating that it is not owned). The
+recursion count is incremented when a wait is satisfied, and ownership
+is set to the given identifier. A mutex also holds an internal flag
+denoting whether its previous owner has died; such a mutex is said to
+be inconsistent. Owner death is not tracked automatically based on
+thread death, but rather must be communicated using
+``WINESYNC_IOC_KILL_OWNER``.
+
+Objects are represented by signed 32-bit integers. A valid object
+identifier will always be nonnegative.
+
+Char device
+===========
+
+The winesync driver creates a single char device /dev/winesync. Each
+file description opened on the device represents a unique namespace.
+That is, objects created on one open file description are shared
+across all its individual descriptors, but are not shared with other
+open() calls on the same device.
+
+ioctl reference
+===============
+
+All operations on the device are done through ioctls. There are three
+structures used in ioctl calls::
+
+ struct winesync_sem_args {
+ __s32 sem;
+ __u32 count;
+ __u32 max;
+ __u32 flags;
+ };
+
+ struct winesync_mutex_args {
+ __s32 mutex;
+ __u32 owner;
+ __u32 count;
+ };
+
+ struct winesync_wait_args {
+ __u64 timeout;
+ __u64 objs;
+ __u32 count;
+ __u32 owner;
+ __u32 index;
+ __u32 pad;
+ };
+
+Depending on the ioctl, members of the structure may be used as input,
+output, or not at all.
+
+All ioctls return 0 on success, and -1 on error, in which case `errno`
+will be set to a nonzero error code.
+
+The ioctls are as follows:
+
+.. c:macro:: WINESYNC_IOC_CREATE_SEM
+
+ Create a semaphore object. Takes a pointer to struct
+ :c:type:`winesync_sem_args`, which is used as follows:
+
+ ``count`` and ``max`` are input-only arguments, denoting the
+ initial and maximum count of the semaphore.
+
+ ``flags`` is an input-only argument, which specifies additional
+ flags modifying the behaviour of the semaphore. There is only one
+ flag defined, ``WINESYNC_SEM_GETONWAIT``. If present, wait
+ operations on this semaphore will acquire it, decrementing its
+ count by one; otherwise, wait operations will not affect the
+ semaphore's state.
+
+ ``sem`` is an output-only argument, which will be filled with the
+ allocated identifier if successful.
+
+ Fails with ``EINVAL`` if ``count`` is greater than ``max``, or
+ ``ENOMEM`` if not enough memory is available.
+
+.. c:macro:: WINESYNC_IOC_CREATE_MUTEX
+
+ Create a mutex object. Takes a pointer to struct
+ :c:type:`winesync_mutex_args`, which is used as follows:
+
+ ``owner`` is an input-only argument denoting the initial owner of
+ the mutex.
+
+ ``count`` is an input-only argument denoting the initial recursion
+ count of the mutex. If ``owner`` is nonzero and ``count`` is zero,
+ or if ``owner`` is zero and ``count`` is nonzero, the function
+ fails with ``EINVAL``.
+
+ ``mutex`` is an output-only argument, which will be filled with
+ the allocated identifier if successful.
+
+ Fails with ``ENOMEM`` if not enough memory is available.
+
+.. c:macro:: WINESYNC_IOC_DELETE
+
+ Delete an object of any type. Takes an input-only pointer to a
+ 32-bit integer denoting the object to delete. Fails with ``EINVAL``
+ if the object is not valid. Further ioctls attempting to use the
+ object return ``EINVAL``, unless the object identifier is reused.
+ However, wait ioctls currently in progress are not interrupted, and
+ behave as if the object remains valid.
+
+.. c:macro:: WINESYNC_IOC_PUT_SEM
+
+ Post to a semaphore object. Takes a pointer to struct
+ :c:type:`winesync_sem_args`, which is used as follows:
+
+ ``sem`` is an input-only argument denoting the semaphore object.
+ If ``sem`` is not a valid semaphore object, the ioctl fails with
+ ``EINVAL``.
+
+ ``count`` contains on input the count to add to the semaphore, and
+ on output is filled with its previous count.
+
+ ``max`` and ``flags`` are not used.
+
+ The operation is atomic and totally ordered with respect to other
+ operations on the same semaphore. If adding ``count`` to the
+ semaphore's current count would raise the latter past the
+ semaphore's maximum count, the ioctl fails with ``EOVERFLOW`` and
+ the semaphore is not affected. If raising the semaphore's count
+ causes it to become signaled, eligible threads waiting on this
+ semaphore will be woken and the semaphore's count decremented
+ appropriately.
+
+.. c:macro:: WINESYNC_IOC_PULSE_SEM
+
+ This operation is identical to ``WINESYNC_IOC_PUT_SEM``, with one
+ notable exception: the semaphore is always left in an *unsignaled*
+ state, regardless of the initial count or the count added by the
+ ioctl. That is, the count after a pulse operation will always be
+ zero. The entire operation is atomic.
+
+ Hence, if the semaphore was created with the
+ ``WINESYNC_SEM_GETONWAIT`` flag set, and an unsignaled semaphore is
+ "pulsed" with a count of 2, at most two eligible threads (i.e.
+ threads not otherwise constrained due to ``WINESYNC_IOC_WAIT_ALL``)
+ will be woken up, and any others will remain sleeping. If less than
+ two eligible threads are waiting on the semaphore, all of them will
+ be woken up, and the semaphore's count will remain at zero. On the
+ other hand, if the semaphore was created without the
+ ``WINESYNC_SEM_GETONWAIT``, all eligible threads will be woken up,
+ making ``count`` effectively redundant. In either case, a
+ simultaneous ``WINESYNC_IOC_READ_SEM`` ioctl from another thread
+ will always report a count of zero.
+
+ If adding ``count`` to the semaphore's current count would raise the
+ latter past the semaphore's maximum count, the ioctl fails with
+ ``EOVERFLOW``. However, in this case the semaphore's count will
+ still be reset to zero.
+
+.. c:macro:: WINESYNC_IOC_GET_SEM
+
+ Attempt to acquire a semaphore object. Takes an input-only pointer
+ to a 32-bit integer denoting the semaphore to acquire.
+
+ This operation does not block. If the semaphore's count was zero, it
+ fails with ``EWOULDBLOCK``. Otherwise, the semaphore's count is
+ decremented by one. The behaviour of this operation is unaffected by
+ whether the semaphore was created with the
+ ``WINESYNC_SEM_GETONWAIT`` flag set.
+
+ The operation is atomic and totally ordered with respect to other
+ operations on the same semaphore.
+
+.. c:macro:: WINESYNC_IOC_PUT_MUTEX
+
+ Release a mutex object. Takes a pointer to struct
+ :c:type:`winesync_mutex_args`, which is used as follows:
+
+ ``mutex`` is an input-only argument denoting the mutex object. If
+ ``mutex`` is not a valid mutex object, the ioctl fails with
+ ``EINVAL``.
+
+ ``owner`` is an input-only argument denoting the mutex owner.
+ ``owner`` must be nonzero, else the ioctl fails with ``EINVAL``.
+ If ``owner`` is not the current owner of the mutex, the ioctl
+ fails with ``EPERM``.
+
+ ``count`` is an output-only argument which will be filled on
+ success with the mutex's previous recursion count.
+
+ The mutex's count will be decremented by one. The operation is
+ atomic and totally ordered with respect to other operations on the
+ same mutex. If decrementing the mutex's count causes it to become
+ zero, the mutex is marked as unowned and signaled, and eligible
+ threads waiting on it will be woken as appropriate.
+
+.. c:macro:: WINESYNC_IOC_READ_SEM
+
+ Read the current state of a semaphore object. Takes a pointer to
+ struct :c:type:`winesync_sem_args`, which is used as follows:
+
+ ``sem`` is an input-only argument denoting the semaphore object.
+ If ``sem`` is not a valid semaphore object, the ioctl fails with
+ ``EINVAL``.
+
+ ``count`` and ``max`` are output-only arguments, which will be
+ filled with the current and maximum count of the given semaphore.
+
+ ``flags`` is an output-only argument, which will be filled with
+ the flags used to create the semaphore.
+
+ The operation is atomic and totally ordered with respect to other
+ operations on the same semaphore.
+
+.. c:macro:: WINESYNC_IOC_READ_MUTEX
+
+ Read the current state of a mutex object. Takes a pointer to struct
+ :c:type:`winesync_mutex_args`, which is used as follows:
+
+ ``mutex`` is an input-only argument denoting the mutex object. If
+ ``mutex`` is not a valid mutex object, the ioctl fails with
+ ``EINVAL``.
+
+ ``count`` and ``owner`` are output-only arguments, which will be
+ filled with the current recursion count and owner of the given
+ mutex. If the mutex is not owned, both ``count`` and ``owner`` are
+ set to zero.
+
+ If the mutex is marked as inconsistent, the function fails with
+ ``EOWNERDEAD``.
+
+ The operation is atomic and totally ordered with respect to other
+ operations on the same mutex.
+
+.. c:macro:: WINESYNC_IOC_KILL_OWNER
+
+ Mark any mutexes owned by the given identifier as unowned and
+ inconsistent. Takes an input-only pointer to a 32-bit integer
+ denoting the owner. If the owner is zero, the ioctl fails with
+ ``EINVAL``.
+
+.. c:macro:: WINESYNC_IOC_WAIT_ANY
+
+ Poll on any of a list of objects, atomically acquiring (at most)
+ one. Takes a pointer to struct :c:type:`winesync_wait_args`, which
+ is used as follows:
+
+ ``timeout`` is an optional input-only pointer to a 64-bit struct
+ :c:type:`timespec` (specified as an integer so that the structure
+ has the same size regardless of architecture). The timeout is
+ specified in absolute format, as measured against the MONOTONIC
+ clock. If the timeout is equal to or earlier than the current
+ time, the function returns immediately without sleeping. If
+ ``timeout`` is zero, i.e. NULL, the function will sleep until an
+ object is signaled, and will not fail with ``ETIMEDOUT``.
+
+ ``objs`` is a input-only pointer to an array of ``count`` 32-bit
+ object identifiers (specified as an integer so that the structure
+ has the same size regardless of architecture). If any identifier
+ is invalid, the function fails with ``EINVAL``.
+
+ ``count`` is an input-only argument denoting the number of
+ elements in ``objs``.
+
+ ``owner`` is an input-only argument denoting the mutex owner
+ identifier. If any object in ``objs`` is a mutex, the ioctl will
+ attempt to acquire that mutex on behalf of ``owner``. If ``owner``
+ is zero, the ioctl fails with ``EINVAL``.
+
+ ``index`` is an output-only argument which, if the ioctl is
+ successful, is filled with the index of the object actually
+ signaled.
+
+ ``pad`` is unused, and exists to keep a consistent structure size.
+
+ This function attempts to acquire one of the given objects. If
+ unable to do so, it sleeps until an object becomes signaled,
+ subsequently acquiring it, or the timeout expires. In the latter
+ case the ioctl fails with ``ETIMEDOUT``. The function only acquires
+ one object, even if multiple objects are signaled.
+
+ A semaphore is considered to be signaled if its count is nonzero. It
+ is acquired by decrementing its count by one if the
+ ``WINESYNC_SEM_GETONWAIT`` flag was used to create it; otherwise no
+ operation is done to acquire the semaphore. A mutex is considered to
+ be signaled if it is unowned or if its owner matches the ``owner``
+ argument, and is acquired by incrementing its recursion count by one
+ and setting its owner to the ``owner`` argument.
+
+ Acquisition is atomic and totally ordered with respect to other
+ operations on the same object. If two wait operations (with
+ different ``owner`` identifiers) are queued on the same mutex, only
+ one is signaled. If two wait operations are queued on the same
+ semaphore (which was not created with the ``WINESYNC_SEM_GETONWAIT``
+ flag set), and a value of one is posted to it, only one is signaled.
+ The order in which threads are signaled is not guaranteed.
+
+ (If two wait operations are queued on the same semaphore, and the
+ semaphore was created with the ``WINESYNC_SEM_GETONWAIT`` flag set,
+ and a value of one is posted to it, both threads are signaled, and
+ the semaphore retains a count of one.)
+
+ If an inconsistent mutex is acquired, the ioctl fails with
+ ``EOWNERDEAD``. Although this is a failure return, the function may
+ otherwise be considered successful. The mutex is marked as owned by
+ the given owner (with a recursion count of 1) and as no longer
+ inconsistent. ``index`` is still set to the index of the mutex.
+
+ Unlike ``WINESYNC_IOC_WAIT_ALL``, it is valid to pass the same
+ object more than once. If a wakeup occurs due to that object being
+ signaled, ``index`` is set to the index of the first instance of the
+ object.
+
+ Fails with ``ENOMEM`` if not enough memory is available, or
+ ``EINTR`` if a signal is received.
+
+.. c:macro:: WINESYNC_IOC_WAIT_ALL
+
+ Poll on a list of objects, atomically acquiring all of them. Takes a
+ pointer to struct :c:type:`winesync_wait_args`, which is used
+ identically to ``WINESYNC_IOC_WAIT_ANY``, except that ``index`` is
+ unused.
+
+ This function attempts to simultaneously acquire all of the given
+ objects. If unable to do so, it sleeps until all objects become
+ simultaneously signaled, subsequently acquiring them, or the timeout
+ expires. In the latter case the ioctl fails with ``ETIMEDOUT`` and
+ no objects are modified.
+
+ Objects may become signaled and subsequently designaled (through
+ acquisition by other threads) while this thread is sleeping. Only
+ once all objects are simultaneously signaled does the ioctl return.
+ The acquisition is atomic and totally ordered with respect to other
+ operations on any of the given objects.
+
+ If an inconsistent mutex is acquired, the ioctl fails with
+ ``EOWNERDEAD``. Similarly to ``WINESYNC_IOC_WAIT_ANY``, all objects
+ are nevertheless marked as acquired. Note that if multiple mutex
+ objects are specified, there is no way to know which were marked as
+ inconsistent.
+
+ Unlike ``WINESYNC_IOC_WAIT_ALL``, it is not valid to pass the same
+ object more than once. If this is attempted, the function fails with
+ ``EINVAL``.
+
+ Fails with ``ENOMEM`` if not enough memory is available, or
+ ``EINTR`` if a signal is received.
diff --git a/MAINTAINERS b/MAINTAINERS
index 9450e052f1b1..d33e317759bf 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -19351,6 +19351,15 @@ M: David Härdeman <david@hardeman.nu>
S: Maintained
F: drivers/media/rc/winbond-cir.c
+WINESYNC SYNCHRONIZATION PRIMITIVE DRIVER
+M: Zebediah Figura <zfigura@codeweavers.com>
+L: wine-devel@winehq.org
+S: Supported
+F: Documentation/userspace-api/winesync.rst
+F: drivers/misc/winesync.c
+F: include/uapi/linux/winesync.c
+F: tools/testing/selftests/drivers/winesync/
+
WINSYSTEMS EBC-C384 WATCHDOG DRIVER
M: William Breathitt Gray <vilhelm.gray@gmail.com>
L: linux-watchdog@vger.kernel.org
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index f532c59bb59b..496f20d69914 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -445,6 +445,17 @@ config HISI_HIKEY_USB
switching between the dual-role USB-C port and the USB-A host ports
using only one USB controller.
+config WINESYNC
+ tristate "Synchronization primitives for Wine"
+ help
+ This module provides kernel support for synchronization primitives
+ used by Wine. It is not a hardware driver.
+
+ To compile this driver as a module, choose M here: the
+ module will be called winesync.
+
+ If unsure, say N.
+
source "drivers/misc/c2port/Kconfig"
source "drivers/misc/eeprom/Kconfig"
source "drivers/misc/cb710/Kconfig"
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index 99b6f15a3c70..327c9628c479 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -56,3 +56,4 @@ obj-$(CONFIG_HABANA_AI) += habanalabs/
obj-$(CONFIG_UACCE) += uacce/
obj-$(CONFIG_XILINX_SDFEC) += xilinx_sdfec.o
obj-$(CONFIG_HISI_HIKEY_USB) += hisi_hikey_usb.o
+obj-$(CONFIG_WINESYNC) += winesync.o
diff --git a/drivers/misc/winesync.c b/drivers/misc/winesync.c
new file mode 100644
index 000000000000..ff5749206aa9
--- /dev/null
+++ b/drivers/misc/winesync.c
@@ -0,0 +1,1047 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * winesync.c - Kernel driver for Wine synchronization primitives
+ *
+ * Copyright (C) 2021 Zebediah Figura
+ */
+
+#include <linux/fs.h>
+#include <linux/idr.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <uapi/linux/winesync.h>
+
+#define WINESYNC_NAME "winesync"
+
+enum winesync_type {
+ WINESYNC_TYPE_SEM,
+ WINESYNC_TYPE_MUTEX,
+};
+
+struct winesync_obj {
+ struct kref refcount;
+ spinlock_t lock;
+
+ /*
+ * any_waiters is protected by the object lock, but all_waiters is
+ * protected by the device wait_all_lock.
+ */
+ struct list_head any_waiters;
+ struct list_head all_waiters;
+
+ /*
+ * Hint describing how many tasks are queued on this object in a
+ * wait-all operation.
+ *
+ * Any time we do a wake, we may need to wake "all" waiters as well as
+ * "any" waiters. In order to atomically wake "all" waiters, we must
+ * lock all of the objects, and that means grabbing the wait_all_lock
+ * below (and, due to lock ordering rules, before locking this object).
+ * However, wait-all is a rare operation, and grabbing the wait-all
+ * lock for every wake would create unnecessary contention. Therefore we
+ * first check whether all_hint is one, and, if it is, we skip trying
+ * to wake "all" waiters.
+ *
+ * This "refcount" isn't protected by any lock. It might change during
+ * the course of a wake, but there's no meaningful race there; it's only
+ * a hint.
+ *
+ * Use refcount_t rather than atomic_t to take advantage of saturation.
+ * This does mean that the "no waiters" case is signified by all_hint
+ * being one, rather than zero (otherwise we would get spurious
+ * warnings).
+ */
+ refcount_t all_hint;
+
+ enum winesync_type type;
+
+ /* The following fields are protected by the object lock. */
+ union {
+ struct {
+ __u32 count;
+ __u32 max;
+ __u32 flags;
+ } sem;
+ struct {
+ __u32 count;
+ __u32 owner;
+ bool ownerdead;
+ } mutex;
+ } u;
+};
+
+struct winesync_q_entry {
+ struct list_head node;
+ struct winesync_q *q;
+ struct winesync_obj *obj;
+ __u32 index;
+};
+
+struct winesync_q {
+ struct task_struct *task;
+ __u32 owner;
+
+ /*
+ * Protected via atomic_cmpxchg(). Only the thread that wins the
+ * compare-and-swap may actually change object states and wake this
+ * task.
+ */
+ atomic_t signaled;
+
+ bool all;
+ bool ownerdead;
+ __u32 count;
+ struct winesync_q_entry entries[];
+};
+
+struct winesync_device {
+ /*
+ * Wait-all operations must atomically grab all objects, and be totally
+ * ordered with respect to each other and wait-any operations. If one
+ * thread is trying to acquire several objects, another thread cannot
+ * touch the object at the same time.
+ *
+ * We achieve this by grabbing multiple object locks at the same time.
+ * However, this creates a lock ordering problem. To solve that problem,
+ * wait_all_lock is taken first whenever multiple objects must be locked
+ * at the same time.
+ */
+ spinlock_t wait_all_lock;
+ struct mutex table_lock;
+ struct idr objects;
+};
+
+static struct winesync_obj *get_obj(struct winesync_device *dev, int id)
+{
+ struct winesync_obj *obj;
+
+ rcu_read_lock();
+ obj = idr_find(&dev->objects, id);
+ if (obj && !kref_get_unless_zero(&obj->refcount))
+ obj = NULL;
+ rcu_read_unlock();
+
+ return obj;
+}
+
+static void destroy_obj(struct kref *ref)
+{
+ struct winesync_obj *obj;
+
+ obj = container_of(ref, struct winesync_obj, refcount);
+ kfree(obj);
+}
+
+static void put_obj(struct winesync_obj *obj)
+{
+ kref_put(&obj->refcount, destroy_obj);
+}
+
+static int winesync_char_open(struct inode *inode, struct file *file)
+{
+ struct winesync_device *dev;
+
+ dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+ if (!dev)
+ return -ENOMEM;
+
+ idr_init(&dev->objects);
+ spin_lock_init(&dev->wait_all_lock);
+ mutex_init(&dev->table_lock);
+
+ file->private_data = dev;
+ return nonseekable_open(inode, file);
+}
+
+static int winesync_char_release(struct inode *inode, struct file *file)
+{
+ struct winesync_device *dev = file->private_data;
+ struct winesync_obj *obj;
+ int id;
+
+ mutex_lock(&dev->table_lock);
+ idr_for_each_entry(&dev->objects, obj, id) {
+ idr_remove(&dev->objects, id);
+ synchronize_rcu();
+ put_obj(obj);
+ }
+ mutex_unlock(&dev->table_lock);
+
+ kfree(dev);
+
+ return 0;
+}
+
+static void winesync_init_obj(struct winesync_obj *obj)
+{
+ kref_init(&obj->refcount);
+ refcount_set(&obj->all_hint, 1);
+ spin_lock_init(&obj->lock);
+ INIT_LIST_HEAD(&obj->any_waiters);
+ INIT_LIST_HEAD(&obj->all_waiters);
+}
+
+static bool is_signaled(struct winesync_obj *obj, __u32 owner)
+{
+ lockdep_assert_held(&obj->lock);
+
+ switch (obj->type) {
+ case WINESYNC_TYPE_SEM:
+ return !!obj->u.sem.count;
+ case WINESYNC_TYPE_MUTEX:
+ if (obj->u.mutex.owner && obj->u.mutex.owner != owner)
+ return false;
+ return obj->u.mutex.count < UINT_MAX;
+ }
+
+ WARN(1, "bad object type %#x\n", obj->type);
+ return false;
+}
+
+/*
+ * "locked_obj" is an optional pointer to an object which is already locked and
+ * should not be locked again. This is necessary so that changing an object's
+ * state and waking it can be a single atomic operation.
+ */
+static void try_wake_all(struct winesync_device *dev, struct winesync_q *q,
+ struct winesync_obj *locked_obj)
+{
+ __u32 count = q->count;
+ bool can_wake = true;
+ __u32 i;
+
+ lockdep_assert_held(&dev->wait_all_lock);
+ if (locked_obj)
+ lockdep_assert_held(&locked_obj->lock);
+
+ for (i = 0; i < count; i++) {
+ if (q->entries[i].obj != locked_obj)
+ spin_lock(&q->entries[i].obj->lock);
+ }
+
+ for (i = 0; i < count; i++) {
+ if (!is_signaled(q->entries[i].obj, q->owner)) {
+ can_wake = false;
+ break;
+ }
+ }
+
+ if (can_wake && atomic_cmpxchg(&q->signaled, -1, 0) == -1) {
+ for (i = 0; i < count; i++) {
+ struct winesync_obj *obj = q->entries[i].obj;
+
+ switch (obj->type) {
+ case WINESYNC_TYPE_SEM:
+ if (obj->u.sem.flags & WINESYNC_SEM_GETONWAIT)
+ obj->u.sem.count--;
+ break;
+ case WINESYNC_TYPE_MUTEX:
+ if (obj->u.mutex.ownerdead)
+ q->ownerdead = true;
+ obj->u.mutex.ownerdead = false;
+ obj->u.mutex.count++;
+ obj->u.mutex.owner = q->owner;
+ break;
+ }
+ }
+ wake_up_process(q->task);
+ }
+
+ for (i = 0; i < count; i++) {
+ if (q->entries[i].obj != locked_obj)
+ spin_unlock(&q->entries[i].obj->lock);
+ }
+}
+
+static void try_wake_all_obj(struct winesync_device *dev,
+ struct winesync_obj *obj)
+{
+ struct winesync_q_entry *entry;
+
+ lockdep_assert_held(&dev->wait_all_lock);
+ lockdep_assert_held(&obj->lock);
+
+ list_for_each_entry(entry, &obj->all_waiters, node)
+ try_wake_all(dev, entry->q, obj);
+}
+
+static void try_wake_any_sem(struct winesync_obj *sem)
+{
+ struct winesync_q_entry *entry;
+
+ lockdep_assert_held(&sem->lock);
+
+ list_for_each_entry(entry, &sem->any_waiters, node) {
+ struct winesync_q *q = entry->q;
+
+ if (!sem->u.sem.count)
+ break;
+
+ if (atomic_cmpxchg(&q->signaled, -1, entry->index) == -1) {
+ if (sem->u.sem.flags & WINESYNC_SEM_GETONWAIT)
+ sem->u.sem.count--;
+ wake_up_process(q->task);
+ }
+ }
+}
+
+static void try_wake_any_mutex(struct winesync_obj *mutex)
+{
+ struct winesync_q_entry *entry;
+
+ lockdep_assert_held(&mutex->lock);
+
+ list_for_each_entry(entry, &mutex->any_waiters, node) {
+ struct winesync_q *q = entry->q;
+
+ if (mutex->u.mutex.count == UINT_MAX)
+ break;
+ if (mutex->u.mutex.owner && mutex->u.mutex.owner != q->owner)
+ continue;
+
+ if (atomic_cmpxchg(&q->signaled, -1, entry->index) == -1) {
+ if (mutex->u.mutex.ownerdead)
+ q->ownerdead = true;
+ mutex->u.mutex.ownerdead = false;
+ mutex->u.mutex.count++;
+ mutex->u.mutex.owner = q->owner;
+ wake_up_process(q->task);
+ }
+ }
+}
+
+static int winesync_create_sem(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_sem_args __user *user_args = argp;
+ struct winesync_sem_args args;
+ struct winesync_obj *sem;
+ int ret;
+
+ if (copy_from_user(&args, argp, sizeof(args)))
+ return -EFAULT;
+
+ if (args.count > args.max)
+ return -EINVAL;
+
+ if (args.flags & ~WINESYNC_SEM_GETONWAIT)
+ return -EINVAL;
+
+ sem = kzalloc(sizeof(*sem), GFP_KERNEL);
+ if (!sem)
+ return -ENOMEM;
+
+ winesync_init_obj(sem);
+ sem->type = WINESYNC_TYPE_SEM;
+ sem->u.sem.count = args.count;
+ sem->u.sem.max = args.max;
+ sem->u.sem.flags = args.flags;
+
+ mutex_lock(&dev->table_lock);
+ ret = idr_alloc(&dev->objects, sem, 0, 0, GFP_KERNEL);
+ mutex_unlock(&dev->table_lock);
+
+ if (ret < 0) {
+ kfree(sem);
+ return ret;
+ }
+
+ return put_user(ret, &user_args->sem);
+}
+
+static int winesync_create_mutex(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_mutex_args __user *user_args = argp;
+ struct winesync_mutex_args args;
+ struct winesync_obj *mutex;
+ int ret;
+
+ if (copy_from_user(&args, argp, sizeof(args)))
+ return -EFAULT;
+
+ if (!args.owner != !args.count)
+ return -EINVAL;
+
+ mutex = kzalloc(sizeof(*mutex), GFP_KERNEL);
+ if (!mutex)
+ return -ENOMEM;
+
+ winesync_init_obj(mutex);
+ mutex->type = WINESYNC_TYPE_MUTEX;
+ mutex->u.mutex.count = args.count;
+ mutex->u.mutex.owner = args.owner;
+
+ mutex_lock(&dev->table_lock);
+ ret = idr_alloc(&dev->objects, mutex, 0, 0, GFP_KERNEL);
+ mutex_unlock(&dev->table_lock);
+
+ if (ret < 0) {
+ kfree(mutex);
+ return ret;
+ }
+
+ return put_user(ret, &user_args->mutex);
+}
+
+static int winesync_delete(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_obj *obj;
+ __s32 id;
+
+ if (get_user(id, (__s32 __user *)argp))
+ return -EFAULT;
+
+ mutex_lock(&dev->table_lock);
+ obj = idr_remove(&dev->objects, id);
+ mutex_unlock(&dev->table_lock);
+
+ if (!obj)
+ return -EINVAL;
+
+ put_obj(obj);
+ return 0;
+}
+
+static int winesync_get_sem(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_obj *sem;
+ int ret = -EWOULDBLOCK;
+ __s32 id;
+
+ if (get_user(id, (__s32 __user *)argp))
+ return -EFAULT;
+
+ sem = get_obj(dev, id);
+ if (!sem)
+ return -EINVAL;
+ if (sem->type != WINESYNC_TYPE_SEM) {
+ put_obj(sem);
+ return -EINVAL;
+ }
+
+ spin_lock(&sem->lock);
+
+ if (sem->u.sem.count) {
+ /*
+ * Decrement the semaphore's count, regardless of whether it
+ * has the WINESYNC_SEM_GETONWAIT flag set.
+ */
+ sem->u.sem.count--;
+ ret = 0;
+ }
+
+ spin_unlock(&sem->lock);
+
+ put_obj(sem);
+
+ return ret;
+}
+
+/*
+ * Actually change the semaphore state, returning -EOVERFLOW if it is made
+ * invalid.
+ */
+static int put_sem_state(struct winesync_obj *sem, __u32 count)
+{
+ lockdep_assert_held(&sem->lock);
+
+ if (sem->u.sem.count + count < sem->u.sem.count ||
+ sem->u.sem.count + count > sem->u.sem.max)
+ return -EOVERFLOW;
+
+ sem->u.sem.count += count;
+ return 0;
+}
+
+static int winesync_put_sem(struct winesync_device *dev, void __user *argp,
+ bool pulse)
+{
+ struct winesync_sem_args __user *user_args = argp;
+ struct winesync_sem_args args;
+ struct winesync_obj *sem;
+ __u32 prev_count;
+ int ret;
+
+ if (copy_from_user(&args, argp, sizeof(args)))
+ return -EFAULT;
+
+ sem = get_obj(dev, args.sem);
+ if (!sem)
+ return -EINVAL;
+ if (sem->type != WINESYNC_TYPE_SEM) {
+ put_obj(sem);
+ return -EINVAL;
+ }
+
+ if (refcount_read(&sem->all_hint) > 1) {
+ spin_lock(&dev->wait_all_lock);
+ spin_lock(&sem->lock);
+
+ prev_count = sem->u.sem.count;
+ ret = put_sem_state(sem, args.count);
+ if (!ret) {
+ try_wake_all_obj(dev, sem);
+ try_wake_any_sem(sem);
+ }
+
+ if (pulse)
+ sem->u.sem.count = 0;
+
+ spin_unlock(&sem->lock);
+ spin_unlock(&dev->wait_all_lock);
+ } else {
+ spin_lock(&sem->lock);
+
+ prev_count = sem->u.sem.count;
+ ret = put_sem_state(sem, args.count);
+ if (!ret)
+ try_wake_any_sem(sem);
+
+ if (pulse)
+ sem->u.sem.count = 0;
+
+ spin_unlock(&sem->lock);
+ }
+
+ put_obj(sem);
+
+ if (!ret && put_user(prev_count, &user_args->count))
+ ret = -EFAULT;
+
+ return ret;
+}
+
+/*
+ * Actually change the mutex state, returning -EPERM if not the owner.
+ */
+static int put_mutex_state(struct winesync_obj *mutex,
+ const struct winesync_mutex_args *args)
+{
+ lockdep_assert_held(&mutex->lock);
+
+ if (mutex->u.mutex.owner != args->owner)
+ return -EPERM;
+
+ if (!--mutex->u.mutex.count)
+ mutex->u.mutex.owner = 0;
+ return 0;
+}
+
+static int winesync_put_mutex(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_mutex_args __user *user_args = argp;
+ struct winesync_mutex_args args;
+ struct winesync_obj *mutex;
+ __u32 prev_count;
+ int ret;
+
+ if (copy_from_user(&args, argp, sizeof(args)))
+ return -EFAULT;
+ if (!args.owner)
+ return -EINVAL;
+
+ mutex = get_obj(dev, args.mutex);
+ if (!mutex)
+ return -EINVAL;
+ if (mutex->type != WINESYNC_TYPE_MUTEX) {
+ put_obj(mutex);
+ return -EINVAL;
+ }
+
+ if (refcount_read(&mutex->all_hint) > 1) {
+ spin_lock(&dev->wait_all_lock);
+ spin_lock(&mutex->lock);
+
+ prev_count = mutex->u.mutex.count;
+ ret = put_mutex_state(mutex, &args);
+ if (!ret) {
+ try_wake_all_obj(dev, mutex);
+ try_wake_any_mutex(mutex);
+ }
+
+ spin_unlock(&mutex->lock);
+ spin_unlock(&dev->wait_all_lock);
+ } else {
+ spin_lock(&mutex->lock);
+
+ prev_count = mutex->u.mutex.count;
+ ret = put_mutex_state(mutex, &args);
+ if (!ret)
+ try_wake_any_mutex(mutex);
+
+ spin_unlock(&mutex->lock);
+ }
+
+ put_obj(mutex);
+
+ if (!ret && put_user(prev_count, &user_args->count))
+ ret = -EFAULT;
+
+ return ret;
+}
+
+static int winesync_read_sem(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_sem_args __user *user_args = argp;
+ struct winesync_sem_args args;
+ struct winesync_obj *sem;
+ __s32 id;
+
+ if (get_user(id, &user_args->sem))
+ return -EFAULT;
+
+ sem = get_obj(dev, id);
+ if (!sem)
+ return -EINVAL;
+ if (sem->type != WINESYNC_TYPE_SEM) {
+ put_obj(sem);
+ return -EINVAL;
+ }
+
+ args.sem = id;
+ spin_lock(&sem->lock);
+ args.count = sem->u.sem.count;
+ args.max = sem->u.sem.max;
+ args.flags = sem->u.sem.flags;
+ spin_unlock(&sem->lock);
+
+ put_obj(sem);
+
+ if (copy_to_user(user_args, &args, sizeof(args)))
+ return -EFAULT;
+ return 0;
+}
+
+static int winesync_read_mutex(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_mutex_args __user *user_args = argp;
+ struct winesync_mutex_args args;
+ struct winesync_obj *mutex;
+ __s32 id;
+ int ret;
+
+ if (get_user(id, &user_args->mutex))
+ return -EFAULT;
+
+ mutex = get_obj(dev, id);
+ if (!mutex)
+ return -EINVAL;
+ if (mutex->type != WINESYNC_TYPE_MUTEX) {
+ put_obj(mutex);
+ return -EINVAL;
+ }
+
+ args.mutex = id;
+ spin_lock(&mutex->lock);
+ args.count = mutex->u.mutex.count;
+ args.owner = mutex->u.mutex.owner;
+ ret = mutex->u.mutex.ownerdead ? -EOWNERDEAD : 0;
+ spin_unlock(&mutex->lock);
+
+ put_obj(mutex);
+
+ if (copy_to_user(user_args, &args, sizeof(args)))
+ return -EFAULT;
+ return ret;
+}
+
+/*
+ * Actually change the mutex state to mark its owner as dead.
+ */
+static void put_mutex_ownerdead_state(struct winesync_obj *mutex)
+{
+ lockdep_assert_held(&mutex->lock);
+
+ mutex->u.mutex.ownerdead = true;
+ mutex->u.mutex.owner = 0;
+ mutex->u.mutex.count = 0;
+}
+
+static int winesync_kill_owner(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_obj *obj;
+ __u32 owner;
+ int id;
+
+ if (get_user(owner, (__u32 __user *)argp))
+ return -EFAULT;
+ if (!owner)
+ return -EINVAL;
+
+ rcu_read_lock();
+
+ idr_for_each_entry(&dev->objects, obj, id) {
+ if (!kref_get_unless_zero(&obj->refcount))
+ continue;
+
+ if (obj->type != WINESYNC_TYPE_MUTEX) {
+ put_obj(obj);
+ continue;
+ }
+
+ if (refcount_read(&obj->all_hint) > 1) {
+ spin_lock(&dev->wait_all_lock);
+ spin_lock(&obj->lock);
+
+ if (obj->u.mutex.owner == owner) {
+ put_mutex_ownerdead_state(obj);
+ try_wake_all_obj(dev, obj);
+ try_wake_any_mutex(obj);
+ }
+
+ spin_unlock(&obj->lock);
+ spin_unlock(&dev->wait_all_lock);
+ } else {
+ spin_lock(&obj->lock);
+
+ if (obj->u.mutex.owner == owner) {
+ put_mutex_ownerdead_state(obj);
+ try_wake_any_mutex(obj);
+ }
+
+ spin_unlock(&obj->lock);
+ }
+
+ put_obj(obj);
+ }
+
+ rcu_read_unlock();
+
+ return 0;
+}
+
+static int winesync_schedule(const struct winesync_q *q, ktime_t *timeout)
+{
+ int ret = 0;
+
+ do {
+ if (signal_pending(current)) {
+ ret = -ERESTARTSYS;
+ break;
+ }
+
+ set_current_state(TASK_INTERRUPTIBLE);
+ if (atomic_read(&q->signaled) != -1) {
+ ret = 0;
+ break;
+ }
+ ret = schedule_hrtimeout(timeout, HRTIMER_MODE_ABS);
+ } while (ret < 0);
+ __set_current_state(TASK_RUNNING);
+
+ return ret;
+}
+
+/*
+ * Allocate and initialize most of the winesync_q structure, but do not queue us
+ * yet. Also, calculate the relative timeout in jiffies.
+ */
+static int setup_wait(struct winesync_device *dev,
+ const struct winesync_wait_args *args, bool all,
+ ktime_t *ret_timeout, struct winesync_q **ret_q)
+{
+ const __u32 count = args->count;
+ struct winesync_q *q;
+ ktime_t timeout = 0;
+ __s32 *ids;
+ __u32 i, j;
+
+ if (args->timeout) {
+ struct timespec64 to;
+
+ if (get_timespec64(&to, u64_to_user_ptr(args->timeout)))
+ return -EFAULT;
+ if (!timespec64_valid(&to))
+ return -EINVAL;
+
+ timeout = timespec64_to_ns(&to);
+ }
+
+ ids = kmalloc_array(args->count, sizeof(*ids), GFP_KERNEL);
+ if (!ids)
+ return -ENOMEM;
+ if (copy_from_user(ids, u64_to_user_ptr(args->objs),
+ array_size(args->count, sizeof(*ids)))) {
+ kfree(ids);
+ return -EFAULT;
+ }
+
+ q = kmalloc(struct_size(q, entries, count), GFP_KERNEL);
+ if (!q) {
+ kfree(ids);
+ return -ENOMEM;
+ }
+ q->task = current;
+ q->owner = args->owner;
+ atomic_set(&q->signaled, -1);
+ q->all = all;
+ q->ownerdead = false;
+ q->count = count;
+
+ for (i = 0; i < count; i++) {
+ struct winesync_q_entry *entry = &q->entries[i];
+ struct winesync_obj *obj = get_obj(dev, ids[i]);
+
+ if (!obj)
+ goto err;
+
+ if (all) {
+ /* Check that the objects are all distinct. */
+ for (j = 0; j < i; j++) {
+ if (obj == q->entries[j].obj) {
+ put_obj(obj);
+ goto err;
+ }
+ }
+ }
+
+ entry->obj = obj;
+ entry->q = q;
+ entry->index = i;
+ }
+
+ kfree(ids);
+
+ *ret_q = q;
+ *ret_timeout = timeout;
+ return 0;
+
+err:
+ for (j = 0; j < i; j++)
+ put_obj(q->entries[j].obj);
+ kfree(ids);
+ kfree(q);
+ return -EINVAL;
+}
+
+static void try_wake_any_obj(struct winesync_obj *obj)
+{
+ switch (obj->type) {
+ case WINESYNC_TYPE_SEM:
+ try_wake_any_sem(obj);
+ break;
+ case WINESYNC_TYPE_MUTEX:
+ try_wake_any_mutex(obj);
+ break;
+ }
+}
+
+static int winesync_wait_any(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_wait_args args;
+ struct winesync_q *q;
+ ktime_t timeout;
+ __u32 i;
+ int ret;
+
+ if (copy_from_user(&args, argp, sizeof(args)))
+ return -EFAULT;
+ if (!args.owner)
+ return -EINVAL;
+
+ ret = setup_wait(dev, &args, false, &timeout, &q);
+ if (ret < 0)
+ return ret;
+
+ /* queue ourselves */
+
+ for (i = 0; i < args.count; i++) {
+ struct winesync_q_entry *entry = &q->entries[i];
+ struct winesync_obj *obj = q->entries[i].obj;
+
+ spin_lock(&obj->lock);
+ list_add_tail(&entry->node, &obj->any_waiters);
+ spin_unlock(&obj->lock);
+ }
+
+ /* check if we are already signaled */
+
+ for (i = 0; i < args.count; i++) {
+ struct winesync_obj *obj = q->entries[i].obj;
+
+ if (atomic_read(&q->signaled) != -1)
+ break;
+
+ spin_lock(&obj->lock);
+ try_wake_any_obj(obj);
+ spin_unlock(&obj->lock);
+ }
+
+ /* sleep */
+
+ ret = winesync_schedule(q, args.timeout ? &timeout : NULL);
+
+ /* and finally, unqueue */
+
+ for (i = 0; i < args.count; i++) {
+ struct winesync_obj *obj = q->entries[i].obj;
+
+ spin_lock(&obj->lock);
+ list_del(&q->entries[i].node);
+ spin_unlock(&obj->lock);
+
+ put_obj(obj);
+ }
+
+ if (atomic_read(&q->signaled) != -1) {
+ struct winesync_wait_args __user *user_args = argp;
+
+ /* even if we caught a signal, we need to communicate success */
+ ret = q->ownerdead ? -EOWNERDEAD : 0;
+
+ if (put_user(atomic_read(&q->signaled), &user_args->index))
+ ret = -EFAULT;
+ } else if (!ret) {
+ ret = -ETIMEDOUT;
+ }
+
+ kfree(q);
+ return ret;
+}
+
+static int winesync_wait_all(struct winesync_device *dev, void __user *argp)
+{
+ struct winesync_wait_args args;
+ struct winesync_q *q;
+ ktime_t timeout;
+ __u32 i;
+ int ret;
+
+ if (copy_from_user(&args, argp, sizeof(args)))
+ return -EFAULT;
+ if (!args.owner)
+ return -EINVAL;
+
+ ret = setup_wait(dev, &args, true, &timeout, &q);
+ if (ret < 0)
+ return ret;
+
+ /* queue ourselves */
+
+ spin_lock(&dev->wait_all_lock);
+
+ for (i = 0; i < args.count; i++) {
+ struct winesync_q_entry *entry = &q->entries[i];
+ struct winesync_obj *obj = q->entries[i].obj;
+
+ refcount_inc(&obj->all_hint);
+
+ /*
+ * obj->all_waiters is protected by dev->wait_all_lock rather
+ * than obj->lock, so there is no need to acquire it here.
+ */
+ list_add_tail(&entry->node, &obj->all_waiters);
+ }
+
+ /* check if we are already signaled */
+
+ try_wake_all(dev, q, NULL);
+
+ spin_unlock(&dev->wait_all_lock);
+
+ /* sleep */
+
+ ret = winesync_schedule(q, args.timeout ? &timeout : NULL);
+
+ /* and finally, unqueue */
+
+ spin_lock(&dev->wait_all_lock);
+
+ for (i = 0; i < args.count; i++) {
+ struct winesync_q_entry *entry = &q->entries[i];
+ struct winesync_obj *obj = q->entries[i].obj;
+
+ /*
+ * obj->all_waiters is protected by dev->wait_all_lock rather
+ * than obj->lock, so there is no need to acquire it here.
+ */
+ list_del(&entry->node);
+
+ refcount_dec(&obj->all_hint);
+
+ put_obj(obj);
+ }
+
+ spin_unlock(&dev->wait_all_lock);
+
+ if (atomic_read(&q->signaled) != -1) {
+ /* even if we caught a signal, we need to communicate success */
+ ret = q->ownerdead ? -EOWNERDEAD : 0;
+ } else if (!ret) {
+ ret = -ETIMEDOUT;
+ }
+
+ kfree(q);
+ return ret;
+}
+
+static long winesync_char_ioctl(struct file *file, unsigned int cmd,
+ unsigned long parm)
+{
+ struct winesync_device *dev = file->private_data;
+ void __user *argp = (void __user *)parm;
+
+ switch (cmd) {
+ case WINESYNC_IOC_CREATE_SEM:
+ return winesync_create_sem(dev, argp);
+ case WINESYNC_IOC_CREATE_MUTEX:
+ return winesync_create_mutex(dev, argp);
+ case WINESYNC_IOC_DELETE:
+ return winesync_delete(dev, argp);
+ case WINESYNC_IOC_GET_SEM:
+ return winesync_get_sem(dev, argp);
+ case WINESYNC_IOC_PUT_SEM:
+ return winesync_put_sem(dev, argp, false);
+ case WINESYNC_IOC_PULSE_SEM:
+ return winesync_put_sem(dev, argp, true);
+ case WINESYNC_IOC_PUT_MUTEX:
+ return winesync_put_mutex(dev, argp);
+ case WINESYNC_IOC_READ_SEM:
+ return winesync_read_sem(dev, argp);
+ case WINESYNC_IOC_READ_MUTEX:
+ return winesync_read_mutex(dev, argp);
+ case WINESYNC_IOC_KILL_OWNER:
+ return winesync_kill_owner(dev, argp);
+ case WINESYNC_IOC_WAIT_ANY:
+ return winesync_wait_any(dev, argp);
+ case WINESYNC_IOC_WAIT_ALL:
+ return winesync_wait_all(dev, argp);
+ default:
+ return -ENOSYS;
+ }
+}
+
+static const struct file_operations winesync_fops = {
+ .owner = THIS_MODULE,
+ .open = winesync_char_open,
+ .release = winesync_char_release,
+ .unlocked_ioctl = winesync_char_ioctl,
+ .compat_ioctl = winesync_char_ioctl,
+ .llseek = no_llseek,
+};
+
+static struct miscdevice winesync_misc = {
+ .minor = WINESYNC_MINOR,
+ .name = WINESYNC_NAME,
+ .fops = &winesync_fops,
+};
+
+static int __init winesync_init(void)
+{
+ return misc_register(&winesync_misc);
+}
+
+static void __exit winesync_exit(void)
+{
+ misc_deregister(&winesync_misc);
+}
+
+module_init(winesync_init);
+module_exit(winesync_exit);
+
+MODULE_AUTHOR("Zebediah Figura");
+MODULE_DESCRIPTION("Kernel driver for Wine synchronization primitives");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("devname:" WINESYNC_NAME);
+MODULE_ALIAS_MISCDEV(WINESYNC_MINOR);
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
index 0676f18093f9..350aecfcfb29 100644
--- a/include/linux/miscdevice.h
+++ b/include/linux/miscdevice.h
@@ -71,6 +71,7 @@
#define USERIO_MINOR 240
#define VHOST_VSOCK_MINOR 241
#define RFKILL_MINOR 242
+#define WINESYNC_MINOR 243
#define MISC_DYNAMIC_MINOR 255
struct device;
diff --git a/include/uapi/linux/winesync.h b/include/uapi/linux/winesync.h
new file mode 100644
index 000000000000..efc591795249
--- /dev/null
+++ b/include/uapi/linux/winesync.h
@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Kernel support for Wine synchronization primitives
+ *
+ * Copyright (C) 2021 Zebediah Figura
+ */
+
+#ifndef __LINUX_WINESYNC_H
+#define __LINUX_WINESYNC_H
+
+#include <linux/types.h>
+
+#define WINESYNC_SEM_GETONWAIT 1
+
+struct winesync_sem_args {
+ __s32 sem;
+ __u32 count;
+ __u32 max;
+ __u32 flags;
+};
+
+struct winesync_mutex_args {
+ __s32 mutex;
+ __u32 owner;
+ __u32 count;
+};
+
+struct winesync_wait_args {
+ __u64 timeout;
+ __u64 objs;
+ __u32 count;
+ __u32 owner;
+ __u32 index;
+ __u32 pad;
+};
+
+#define WINESYNC_IOC_BASE 0xf7
+
+#define WINESYNC_IOC_CREATE_SEM _IOWR(WINESYNC_IOC_BASE, 0, \
+ struct winesync_sem_args)
+#define WINESYNC_IOC_DELETE _IOW (WINESYNC_IOC_BASE, 1, __s32)
+#define WINESYNC_IOC_PUT_SEM _IOWR(WINESYNC_IOC_BASE, 2, \
+ struct winesync_sem_args)
+#define WINESYNC_IOC_WAIT_ANY _IOWR(WINESYNC_IOC_BASE, 3, \
+ struct winesync_wait_args)
+#define WINESYNC_IOC_WAIT_ALL _IOW (WINESYNC_IOC_BASE, 4, \
+ struct winesync_wait_args)
+#define WINESYNC_IOC_CREATE_MUTEX _IOWR(WINESYNC_IOC_BASE, 5, \
+ struct winesync_mutex_args)
+#define WINESYNC_IOC_PUT_MUTEX _IOWR(WINESYNC_IOC_BASE, 6, \
+ struct winesync_mutex_args)
+#define WINESYNC_IOC_KILL_OWNER _IOW (WINESYNC_IOC_BASE, 7, __u32)
+#define WINESYNC_IOC_READ_SEM _IOWR(WINESYNC_IOC_BASE, 8, \
+ struct winesync_sem_args)
+#define WINESYNC_IOC_READ_MUTEX _IOWR(WINESYNC_IOC_BASE, 9, \
+ struct winesync_mutex_args)
+#define WINESYNC_IOC_GET_SEM _IOW (WINESYNC_IOC_BASE, 10, __s32)
+#define WINESYNC_IOC_PULSE_SEM _IOWR(WINESYNC_IOC_BASE, 11, \
+ struct winesync_sem_args)
+
+#endif
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 6c575cf34a71..7f43a50ee19e 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -9,6 +9,7 @@ TARGETS += core
TARGETS += cpufreq
TARGETS += cpu-hotplug
TARGETS += drivers/dma-buf
+TARGETS += drivers/winesync
TARGETS += efivarfs
TARGETS += exec
TARGETS += filesystems
diff --git a/tools/testing/selftests/drivers/winesync/Makefile b/tools/testing/selftests/drivers/winesync/Makefile
new file mode 100644
index 000000000000..43b39fdeea10
--- /dev/null
+++ b/tools/testing/selftests/drivers/winesync/Makefile
@@ -0,0 +1,8 @@
+# SPDX-LICENSE-IDENTIFIER: GPL-2.0-only
+TEST_GEN_PROGS := winesync
+
+top_srcdir =../../../../..
+CFLAGS += -I$(top_srcdir)/usr/include
+LDLIBS += -lpthread
+
+include ../../lib.mk
diff --git a/tools/testing/selftests/drivers/winesync/config b/tools/testing/selftests/drivers/winesync/config
new file mode 100644
index 000000000000..60539c826d06
--- /dev/null
+++ b/tools/testing/selftests/drivers/winesync/config
@@ -0,0 +1 @@
+CONFIG_WINESYNC=y
diff --git a/tools/testing/selftests/drivers/winesync/winesync.c b/tools/testing/selftests/drivers/winesync/winesync.c
new file mode 100644
index 000000000000..52373fcd5c8c
--- /dev/null
+++ b/tools/testing/selftests/drivers/winesync/winesync.c
@@ -0,0 +1,1486 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Various unit tests for the "winesync" synchronization primitive driver.
+ *
+ * Copyright (C) 2021 Zebediah Figura
+ */
+
+#define _GNU_SOURCE
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+#include <pthread.h>
+#include <linux/winesync.h>
+#include "../../kselftest_harness.h"
+
+TEST(semaphore_state)
+{
+ struct winesync_wait_args wait_args;
+ struct winesync_sem_args sem_args;
+ struct timespec timeout;
+ int fd, ret;
+
+ clock_gettime(CLOCK_MONOTONIC, &timeout);
+
+ fd = open("/dev/winesync", O_CLOEXEC | O_RDONLY);
+ ASSERT_LE(0, fd);
+
+ sem_args.count = 3;
+ sem_args.max = 2;
+ sem_args.sem = 0xdeadbeef;
+ sem_args.flags = 0;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ sem_args.count = 2;
+ sem_args.max = 2;
+ sem_args.sem = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, sem_args.sem);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ sem_args.flags = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+ EXPECT_EQ(0, sem_args.flags);
+
+ sem_args.count = 0;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOVERFLOW, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ wait_args.timeout = (uintptr_t)&timeout;
+ wait_args.objs = (uintptr_t)&sem_args.sem;
+ wait_args.count = 1;
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EWOULDBLOCK, errno);
+
+ sem_args.count = 3;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOVERFLOW, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ /* Test PULSE. */
+
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOVERFLOW, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+
+ close(fd);
+}
+
+TEST(semaphore_state_getonwait)
+{
+ struct winesync_wait_args wait_args;
+ struct winesync_sem_args sem_args;
+ struct timespec timeout;
+ int fd, ret;
+
+ clock_gettime(CLOCK_MONOTONIC, &timeout);
+
+ fd = open("/dev/winesync", O_CLOEXEC | O_RDONLY);
+ ASSERT_LE(0, fd);
+
+ sem_args.count = 3;
+ sem_args.max = 2;
+ sem_args.sem = 0xdeadbeef;
+ sem_args.flags = WINESYNC_SEM_GETONWAIT;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ sem_args.count = 2;
+ sem_args.max = 2;
+ sem_args.sem = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, sem_args.sem);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 0;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOVERFLOW, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ wait_args.timeout = (uintptr_t)&timeout;
+ wait_args.objs = (uintptr_t)&sem_args.sem;
+ wait_args.count = 1;
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(ETIMEDOUT, errno);
+
+ sem_args.count = 3;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOVERFLOW, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ /* Test GET. */
+
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EWOULDBLOCK, errno);
+
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ /* Test PULSE. */
+
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOVERFLOW, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(2, sem_args.max);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+
+ close(fd);
+}
+
+TEST(mutex_state)
+{
+ struct winesync_wait_args wait_args;
+ struct winesync_mutex_args mutex_args;
+ struct timespec timeout;
+ __u32 owner;
+ int fd, ret;
+
+ clock_gettime(CLOCK_MONOTONIC, &timeout);
+
+ fd = open("/dev/winesync", O_CLOEXEC | O_RDONLY);
+ ASSERT_LE(0, fd);
+
+ mutex_args.owner = 123;
+ mutex_args.count = 0;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ mutex_args.owner = 0;
+ mutex_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ mutex_args.owner = 123;
+ mutex_args.count = 2;
+ mutex_args.mutex = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, mutex_args.mutex);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 456;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EPERM, errno);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, mutex_args.count);
+ EXPECT_EQ(0, mutex_args.owner);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EPERM, errno);
+
+ wait_args.timeout = (uintptr_t)&timeout;
+ wait_args.objs = (uintptr_t)&mutex_args.mutex;
+ wait_args.count = 1;
+ wait_args.owner = 456;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(456, mutex_args.owner);
+
+ wait_args.owner = 456;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+ EXPECT_EQ(456, mutex_args.owner);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 456;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(456, mutex_args.owner);
+
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(ETIMEDOUT, errno);
+
+ owner = 0;
+ ret = ioctl(fd, WINESYNC_IOC_KILL_OWNER, &owner);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_KILL_OWNER, &owner);
+ EXPECT_EQ(0, ret);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(456, mutex_args.owner);
+
+ owner = 456;
+ ret = ioctl(fd, WINESYNC_IOC_KILL_OWNER, &owner);
+ EXPECT_EQ(0, ret);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOWNERDEAD, errno);
+ EXPECT_EQ(0, mutex_args.count);
+ EXPECT_EQ(0, mutex_args.owner);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOWNERDEAD, errno);
+ EXPECT_EQ(0, mutex_args.count);
+ EXPECT_EQ(0, mutex_args.owner);
+
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOWNERDEAD, errno);
+ EXPECT_EQ(0, wait_args.index);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_KILL_OWNER, &owner);
+ EXPECT_EQ(0, ret);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOWNERDEAD, errno);
+ EXPECT_EQ(0, mutex_args.count);
+ EXPECT_EQ(0, mutex_args.owner);
+
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOWNERDEAD, errno);
+ EXPECT_EQ(0, wait_args.index);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &mutex_args.mutex);
+ EXPECT_EQ(0, ret);
+
+ mutex_args.owner = 0;
+ mutex_args.count = 0;
+ mutex_args.mutex = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, mutex_args.mutex);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, mutex_args.count);
+ EXPECT_EQ(0, mutex_args.owner);
+
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &mutex_args.mutex);
+ EXPECT_EQ(0, ret);
+
+ close(fd);
+}
+
+TEST(wait_any)
+{
+ struct winesync_mutex_args mutex_args = {0};
+ struct winesync_wait_args wait_args = {0};
+ struct winesync_sem_args sem_args = {0};
+ struct timespec timeout;
+ __s32 objs[2];
+ __u32 owner;
+ int fd, ret;
+
+ clock_gettime(CLOCK_MONOTONIC, &timeout);
+
+ fd = open("/dev/winesync", O_CLOEXEC | O_RDONLY);
+ ASSERT_LE(0, fd);
+
+ sem_args.count = 2;
+ sem_args.max = 3;
+ sem_args.sem = 0xdeadbeef;
+ sem_args.flags = WINESYNC_SEM_GETONWAIT;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, sem_args.sem);
+
+ mutex_args.owner = 0;
+ mutex_args.count = 0;
+ mutex_args.mutex = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, mutex_args.mutex);
+
+ objs[0] = sem_args.sem;
+ objs[1] = mutex_args.mutex;
+
+ wait_args.timeout = (uintptr_t)&timeout;
+ wait_args.objs = (uintptr_t)objs;
+ wait_args.count = 2;
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+ EXPECT_EQ((uintptr_t)objs, wait_args.objs);
+ EXPECT_EQ(2, wait_args.count);
+ EXPECT_EQ(123, wait_args.owner);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, mutex_args.count);
+ EXPECT_EQ(0, mutex_args.owner);
+
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, mutex_args.count);
+ EXPECT_EQ(0, mutex_args.owner);
+
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, wait_args.index);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ wait_args.owner = 123;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, wait_args.index);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ wait_args.owner = 456;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(ETIMEDOUT, errno);
+
+ owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_KILL_OWNER, &owner);
+ EXPECT_EQ(0, ret);
+
+ wait_args.owner = 456;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOWNERDEAD, errno);
+ EXPECT_EQ(1, wait_args.index);
+
+ wait_args.owner = 456;
+ wait_args.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, wait_args.index);
+
+ /* test waiting on the same object twice */
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ objs[0] = objs[1] = sem_args.sem;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ wait_args.count = 0;
+ wait_args.objs = (uintptr_t)NULL;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(ETIMEDOUT, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &mutex_args.mutex);
+ EXPECT_EQ(0, ret);
+
+ close(fd);
+}
+
+TEST(wait_all)
+{
+ struct winesync_mutex_args mutex_args = {0};
+ struct winesync_wait_args wait_args = {0};
+ struct winesync_sem_args sem_args = {0};
+ struct timespec timeout;
+ __s32 objs[2];
+ __u32 owner;
+ int fd, ret;
+
+ clock_gettime(CLOCK_MONOTONIC, &timeout);
+
+ fd = open("/dev/winesync", O_CLOEXEC | O_RDONLY);
+ ASSERT_LE(0, fd);
+
+ sem_args.count = 2;
+ sem_args.max = 3;
+ sem_args.sem = 0xdeadbeef;
+ sem_args.flags = WINESYNC_SEM_GETONWAIT;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, sem_args.sem);
+
+ mutex_args.owner = 0;
+ mutex_args.count = 0;
+ mutex_args.mutex = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, mutex_args.mutex);
+
+ objs[0] = sem_args.sem;
+ objs[1] = mutex_args.mutex;
+
+ wait_args.timeout = (uintptr_t)&timeout;
+ wait_args.objs = (uintptr_t)objs;
+ wait_args.count = 2;
+ wait_args.owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ((uintptr_t)objs, wait_args.objs);
+ EXPECT_EQ(2, wait_args.count);
+ EXPECT_EQ(123, wait_args.owner);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ wait_args.owner = 456;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(ETIMEDOUT, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ wait_args.owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(0, ret);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(ETIMEDOUT, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ sem_args.count = 3;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_KILL_OWNER, &owner);
+ EXPECT_EQ(0, ret);
+
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EOWNERDEAD, errno);
+
+ sem_args.count = 0xdeadbeef;
+ sem_args.max = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, sem_args.count);
+ EXPECT_EQ(3, sem_args.max);
+
+ mutex_args.count = 0xdeadbeef;
+ mutex_args.owner = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(123, mutex_args.owner);
+
+ /* test waiting on the same object twice */
+ objs[0] = objs[1] = sem_args.sem;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &mutex_args.mutex);
+ EXPECT_EQ(0, ret);
+
+ close(fd);
+}
+
+TEST(invalid_objects)
+{
+ struct winesync_mutex_args mutex_args = {0};
+ struct winesync_wait_args wait_args = {0};
+ struct winesync_sem_args sem_args = {0};
+ __s32 objs[2] = {0};
+ int fd, ret;
+
+ fd = open("/dev/winesync", O_CLOEXEC | O_RDONLY);
+ ASSERT_LE(0, fd);
+
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_GET_SEM, &sem_args.sem);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ wait_args.objs = (uintptr_t)objs;
+ wait_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &objs[0]);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ sem_args.max = 1;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+
+ mutex_args.mutex = sem_args.sem;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ objs[0] = sem_args.sem;
+ objs[1] = sem_args.sem + 1;
+ wait_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ objs[0] = sem_args.sem + 1;
+ objs[1] = sem_args.sem;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ALL, &wait_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+
+ sem_args.sem = mutex_args.mutex;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(-1, ret);
+ EXPECT_EQ(EINVAL, errno);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &mutex_args.mutex);
+ EXPECT_EQ(0, ret);
+
+ close(fd);
+}
+
+struct wake_args
+{
+ int fd;
+ __s32 obj;
+};
+
+struct wait_args
+{
+ int fd;
+ unsigned long request;
+ struct winesync_wait_args *args;
+ int ret;
+ int err;
+};
+
+static void *wait_thread(void *arg)
+{
+ struct wait_args *args = arg;
+
+ args->ret = ioctl(args->fd, args->request, args->args);
+ args->err = errno;
+ return NULL;
+}
+
+static void get_abs_timeout(struct timespec *timeout, clockid_t clock,
+ unsigned int ms)
+{
+ clock_gettime(clock, timeout);
+ timeout->tv_nsec += ms * 1000000;
+ timeout->tv_sec += (timeout->tv_nsec / 1000000000);
+ timeout->tv_nsec %= 1000000000;
+}
+
+static int wait_for_thread(pthread_t thread, unsigned int ms)
+{
+ struct timespec timeout;
+ get_abs_timeout(&timeout, CLOCK_REALTIME, ms);
+ return pthread_timedjoin_np(thread, NULL, &timeout);
+}
+
+TEST(wake_any)
+{
+ struct winesync_mutex_args mutex_args = {0};
+ struct winesync_wait_args wait_args = {0};
+ struct winesync_sem_args sem_args = {0};
+ struct wait_args thread_args;
+ struct timespec timeout;
+ pthread_t thread;
+ __s32 objs[2];
+ __u32 owner;
+ int fd, ret;
+
+ fd = open("/dev/winesync", O_CLOEXEC | O_RDONLY);
+ ASSERT_LE(0, fd);
+
+ sem_args.count = 0;
+ sem_args.max = 3;
+ sem_args.sem = 0xdeadbeef;
+ sem_args.flags = WINESYNC_SEM_GETONWAIT;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, sem_args.sem);
+
+ mutex_args.owner = 123;
+ mutex_args.count = 1;
+ mutex_args.mutex = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, mutex_args.mutex);
+
+ objs[0] = sem_args.sem;
+ objs[1] = mutex_args.mutex;
+
+ /* test waking the semaphore */
+
+ get_abs_timeout(&timeout, CLOCK_MONOTONIC, 1000);
+ wait_args.timeout = (uintptr_t)&timeout;
+ wait_args.objs = (uintptr_t)objs;
+ wait_args.count = 2;
+ wait_args.owner = 456;
+ wait_args.index = 0xdeadbeef;
+ thread_args.fd = fd;
+ thread_args.args = &wait_args;
+ thread_args.request = WINESYNC_IOC_WAIT_ANY;
+ ret = pthread_create(&thread, NULL, wait_thread, &thread_args);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(ETIMEDOUT, ret);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, thread_args.ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ /* test waking the semaphore via pulse */
+
+ get_abs_timeout(&timeout, CLOCK_MONOTONIC, 1000);
+ wait_args.owner = 456;
+ ret = pthread_create(&thread, NULL, wait_thread, &thread_args);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(ETIMEDOUT, ret);
+
+ sem_args.count = 2;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, thread_args.ret);
+ EXPECT_EQ(0, wait_args.index);
+
+ /* test waking the mutex */
+
+ /* first grab it again for owner 123 */
+ wait_args.owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, wait_args.index);
+
+ get_abs_timeout(&timeout, CLOCK_MONOTONIC, 1000);
+ wait_args.owner = 456;
+ ret = pthread_create(&thread, NULL, wait_thread, &thread_args);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(ETIMEDOUT, ret);
+
+ mutex_args.owner = 123;
+ mutex_args.count = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(2, mutex_args.count);
+
+ ret = pthread_tryjoin_np(thread, NULL);
+ EXPECT_EQ(EBUSY, ret);
+
+ mutex_args.owner = 123;
+ mutex_args.count = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(456, mutex_args.owner);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, thread_args.ret);
+ EXPECT_EQ(1, wait_args.index);
+
+ /* delete an object while it's being waited on */
+
+ get_abs_timeout(&timeout, CLOCK_MONOTONIC, 200);
+ wait_args.owner = 123;
+ ret = pthread_create(&thread, NULL, wait_thread, &thread_args);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(ETIMEDOUT, ret);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &mutex_args.mutex);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 200);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(-1, thread_args.ret);
+ EXPECT_EQ(ETIMEDOUT, thread_args.err);
+
+ close(fd);
+}
+
+TEST(wake_all)
+{
+ struct winesync_wait_args wait_args = {0}, wait_args2 = {0};
+ struct winesync_mutex_args mutex_args = {0};
+ struct winesync_sem_args sem_args = {0};
+ struct timespec timeout, timeout2;
+ struct wait_args thread_args;
+ pthread_t thread;
+ __s32 objs[2];
+ __u32 owner;
+ int fd, ret;
+
+ fd = open("/dev/winesync", O_CLOEXEC | O_RDONLY);
+ ASSERT_LE(0, fd);
+
+ sem_args.count = 0;
+ sem_args.max = 3;
+ sem_args.sem = 0xdeadbeef;
+ sem_args.flags = WINESYNC_SEM_GETONWAIT;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, sem_args.sem);
+
+ mutex_args.owner = 123;
+ mutex_args.count = 1;
+ mutex_args.mutex = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_CREATE_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_NE(0xdeadbeef, mutex_args.mutex);
+
+ objs[0] = sem_args.sem;
+ objs[1] = mutex_args.mutex;
+
+ get_abs_timeout(&timeout, CLOCK_MONOTONIC, 1000);
+ wait_args.timeout = (uintptr_t)&timeout;
+ wait_args.objs = (uintptr_t)objs;
+ wait_args.count = 2;
+ wait_args.owner = 456;
+ thread_args.fd = fd;
+ thread_args.args = &wait_args;
+ thread_args.request = WINESYNC_IOC_WAIT_ALL;
+ ret = pthread_create(&thread, NULL, wait_thread, &thread_args);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(ETIMEDOUT, ret);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ ret = pthread_tryjoin_np(thread, NULL);
+ EXPECT_EQ(EBUSY, ret);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, sem_args.count);
+
+ get_abs_timeout(&timeout2, CLOCK_MONOTONIC, 0);
+ wait_args2.timeout = (uintptr_t)&timeout2;
+ wait_args2.objs = (uintptr_t)&sem_args.sem;
+ wait_args2.count = 1;
+ wait_args2.owner = 123;
+ wait_args2.index = 0xdeadbeef;
+ ret = ioctl(fd, WINESYNC_IOC_WAIT_ANY, &wait_args2);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, wait_args2.index);
+
+ mutex_args.owner = 123;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+
+ ret = pthread_tryjoin_np(thread, NULL);
+ EXPECT_EQ(EBUSY, ret);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, mutex_args.count);
+ EXPECT_EQ(0, mutex_args.owner);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PUT_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ ret = ioctl(fd, WINESYNC_IOC_READ_MUTEX, &mutex_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(1, mutex_args.count);
+ EXPECT_EQ(456, mutex_args.owner);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, thread_args.ret);
+
+ /* test waking the semaphore via pulse */
+
+ get_abs_timeout(&timeout, CLOCK_MONOTONIC, 1000);
+ wait_args.owner = 456;
+ ret = pthread_create(&thread, NULL, wait_thread, &thread_args);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(ETIMEDOUT, ret);
+
+ sem_args.count = 1;
+ ret = ioctl(fd, WINESYNC_IOC_PULSE_SEM, &sem_args);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, sem_args.count);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(0, thread_args.ret);
+
+ /* delete an object while it's being waited on */
+
+ get_abs_timeout(&timeout, CLOCK_MONOTONIC, 200);
+ wait_args.owner = 123;
+ ret = pthread_create(&thread, NULL, wait_thread, &thread_args);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 100);
+ EXPECT_EQ(ETIMEDOUT, ret);
+
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &sem_args.sem);
+ EXPECT_EQ(0, ret);
+ ret = ioctl(fd, WINESYNC_IOC_DELETE, &mutex_args.mutex);
+ EXPECT_EQ(0, ret);
+
+ ret = wait_for_thread(thread, 200);
+ EXPECT_EQ(0, ret);
+ EXPECT_EQ(-1, thread_args.ret);
+ EXPECT_EQ(ETIMEDOUT, thread_args.err);
+
+ close(fd);
+}
+
+TEST_HARNESS_MAIN
Reference in New Issue Copy Permalink