Quelle  ntsync.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Various unit tests for the "ntsync" synchronization primitive driver.
 *
 * Copyright (C) 2021-2022 Elizabeth Figura <zfigura@codeweavers.com>
 */

#define _GNU_SOURCE
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <pthread.h>
#include <linux/ntsync.h>
#include "../../kselftest_harness.h"

static int read_sem_state(int sem, __u32 *count, __u32 *max)
{
 struct ntsync_sem_args args;
 int ret;

 memset(&args, 0xcc, sizeof(args));
 ret = ioctl(sem, NTSYNC_IOC_SEM_READ, &args);
 *count = args.count;
 *max = args.max;
 return ret;
}

#define check_sem_state(sem, count, max) \
 ({ \
  __u32 __count, __max; \
  int ret = read_sem_state((sem), &__count, &__max); \
  EXPECT_EQ(0, ret); \
  EXPECT_EQ((count), __count); \
  EXPECT_EQ((max), __max); \
 })

static int release_sem(int sem, __u32 *count)
{
 return ioctl(sem, NTSYNC_IOC_SEM_RELEASE, count);
}

static int read_mutex_state(int mutex, __u32 *count, __u32 *owner)
{
 struct ntsync_mutex_args args;
 int ret;

 memset(&args, 0xcc, sizeof(args));
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &args);
 *count = args.count;
 *owner = args.owner;
 return ret;
}

#define check_mutex_state(mutex, count, owner) \
 ({ \
  __u32 __count, __owner; \
  int ret = read_mutex_state((mutex), &__count, &__owner); \
  EXPECT_EQ(0, ret); \
  EXPECT_EQ((count), __count); \
  EXPECT_EQ((owner), __owner); \
 })

static int unlock_mutex(int mutex, __u32 owner, __u32 *count)
{
 struct ntsync_mutex_args args;
 int ret;

 args.owner = owner;
 args.count = 0xdeadbeef;
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_UNLOCK, &args);
 *count = args.count;
 return ret;
}

static int read_event_state(int event, __u32 *signaled, __u32 *manual)
{
 struct ntsync_event_args args;
 int ret;

 memset(&args, 0xcc, sizeof(args));
 ret = ioctl(event, NTSYNC_IOC_EVENT_READ, &args);
 *signaled = args.signaled;
 *manual = args.manual;
 return ret;
}

#define check_event_state(event, signaled, manual) \
 ({ \
  __u32 __signaled, __manual; \
  int ret = read_event_state((event), &__signaled, &__manual); \
  EXPECT_EQ(0, ret); \
  EXPECT_EQ((signaled), __signaled); \
  EXPECT_EQ((manual), __manual); \
 })

static int wait_objs(int fd, unsigned long request, __u32 count,
       const int *objs, __u32 owner, int alert, __u32 *index)
{
 struct ntsync_wait_args args = {0};
 struct timespec timeout;
 int ret;

 clock_gettime(CLOCK_MONOTONIC, &timeout);

 args.timeout = timeout.tv_sec * 1000000000 + timeout.tv_nsec;
 args.count = count;
 args.objs = (uintptr_t)objs;
 args.owner = owner;
 args.index = 0xdeadbeef;
 args.alert = alert;
 ret = ioctl(fd, request, &args);
 *index = args.index;
 return ret;
}

static int wait_any(int fd, __u32 count, const int *objs, __u32 owner, __u32 *index)
{
 return wait_objs(fd, NTSYNC_IOC_WAIT_ANY, count, objs, owner, 0, index);
}

static int wait_all(int fd, __u32 count, const int *objs, __u32 owner, __u32 *index)
{
 return wait_objs(fd, NTSYNC_IOC_WAIT_ALL, count, objs, owner, 0, index);
}

static int wait_any_alert(int fd, __u32 count, const int *objs,
     __u32 owner, int alert, __u32 *index)
{
 return wait_objs(fd, NTSYNC_IOC_WAIT_ANY,
    count, objs, owner, alert, index);
}

static int wait_all_alert(int fd, __u32 count, const int *objs,
     __u32 owner, int alert, __u32 *index)
{
 return wait_objs(fd, NTSYNC_IOC_WAIT_ALL,
    count, objs, owner, alert, index);
}

TEST(semaphore_state)
{
 struct ntsync_sem_args sem_args;
 struct timespec timeout;
 __u32 count, index;
 int fd, ret, sem;

 clock_gettime(CLOCK_MONOTONIC, &timeout);

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 sem_args.count = 3;
 sem_args.max = 2;
 sem = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_EQ(-1, sem);
 EXPECT_EQ(EINVAL, errno);

 sem_args.count = 2;
 sem_args.max = 2;
 sem = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, sem);
 check_sem_state(sem, 2, 2);

 count = 0;
 ret = release_sem(sem, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(2, count);
 check_sem_state(sem, 2, 2);

 count = 1;
 ret = release_sem(sem, &count);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOVERFLOW, errno);
 check_sem_state(sem, 2, 2);

 ret = wait_any(fd, 1, &sem, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(sem, 1, 2);

 ret = wait_any(fd, 1, &sem, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(sem, 0, 2);

 ret = wait_any(fd, 1, &sem, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 count = 3;
 ret = release_sem(sem, &count);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOVERFLOW, errno);
 check_sem_state(sem, 0, 2);

 count = 2;
 ret = release_sem(sem, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, count);
 check_sem_state(sem, 2, 2);

 ret = wait_any(fd, 1, &sem, 123, &index);
 EXPECT_EQ(0, ret);
 ret = wait_any(fd, 1, &sem, 123, &index);
 EXPECT_EQ(0, ret);

 count = 1;
 ret = release_sem(sem, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, count);
 check_sem_state(sem, 1, 2);

 count = ~0u;
 ret = release_sem(sem, &count);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOVERFLOW, errno);
 check_sem_state(sem, 1, 2);

 close(sem);

 close(fd);
}

TEST(mutex_state)
{
 struct ntsync_mutex_args mutex_args;
 __u32 owner, count, index;
 struct timespec timeout;
 int fd, ret, mutex;

 clock_gettime(CLOCK_MONOTONIC, &timeout);

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 mutex_args.owner = 123;
 mutex_args.count = 0;
 mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_EQ(-1, mutex);
 EXPECT_EQ(EINVAL, errno);

 mutex_args.owner = 0;
 mutex_args.count = 2;
 mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_EQ(-1, mutex);
 EXPECT_EQ(EINVAL, errno);

 mutex_args.owner = 123;
 mutex_args.count = 2;
 mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_LE(0, mutex);
 check_mutex_state(mutex, 2, 123);

 ret = unlock_mutex(mutex, 0, &count);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EINVAL, errno);

 ret = unlock_mutex(mutex, 456, &count);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EPERM, errno);
 check_mutex_state(mutex, 2, 123);

 ret = unlock_mutex(mutex, 123, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(2, count);
 check_mutex_state(mutex, 1, 123);

 ret = unlock_mutex(mutex, 123, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, count);
 check_mutex_state(mutex, 0, 0);

 ret = unlock_mutex(mutex, 123, &count);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EPERM, errno);

 ret = wait_any(fd, 1, &mutex, 456, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_mutex_state(mutex, 1, 456);

 ret = wait_any(fd, 1, &mutex, 456, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_mutex_state(mutex, 2, 456);

 ret = unlock_mutex(mutex, 456, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(2, count);
 check_mutex_state(mutex, 1, 456);

 ret = wait_any(fd, 1, &mutex, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 owner = 0;
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EINVAL, errno);

 owner = 123;
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EPERM, errno);
 check_mutex_state(mutex, 1, 456);

 owner = 456;
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner);
 EXPECT_EQ(0, ret);

 memset(&mutex_args, 0xcc, sizeof(mutex_args));
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOWNERDEAD, errno);
 EXPECT_EQ(0, mutex_args.count);
 EXPECT_EQ(0, mutex_args.owner);

 memset(&mutex_args, 0xcc, sizeof(mutex_args));
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOWNERDEAD, errno);
 EXPECT_EQ(0, mutex_args.count);
 EXPECT_EQ(0, mutex_args.owner);

 ret = wait_any(fd, 1, &mutex, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOWNERDEAD, errno);
 EXPECT_EQ(0, index);
 check_mutex_state(mutex, 1, 123);

 owner = 123;
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner);
 EXPECT_EQ(0, ret);

 memset(&mutex_args, 0xcc, sizeof(mutex_args));
 ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOWNERDEAD, errno);
 EXPECT_EQ(0, mutex_args.count);
 EXPECT_EQ(0, mutex_args.owner);

 ret = wait_any(fd, 1, &mutex, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOWNERDEAD, errno);
 EXPECT_EQ(0, index);
 check_mutex_state(mutex, 1, 123);

 close(mutex);

 mutex_args.owner = 0;
 mutex_args.count = 0;
 mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_LE(0, mutex);
 check_mutex_state(mutex, 0, 0);

 ret = wait_any(fd, 1, &mutex, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_mutex_state(mutex, 1, 123);

 close(mutex);

 mutex_args.owner = 123;
 mutex_args.count = ~0u;
 mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_LE(0, mutex);
 check_mutex_state(mutex, ~0u, 123);

 ret = wait_any(fd, 1, &mutex, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 close(mutex);

 close(fd);
}

TEST(manual_event_state)
{
 struct ntsync_event_args event_args;
 __u32 index, signaled;
 int fd, event, ret;

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 event_args.manual = 1;
 event_args.signaled = 0;
 event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, event);
 check_event_state(event, 0, 1);

 signaled = 0xdeadbeef;
 ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(event, 1, 1);

 ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, signaled);
 check_event_state(event, 1, 1);

 ret = wait_any(fd, 1, &event, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_event_state(event, 1, 1);

 signaled = 0xdeadbeef;
 ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, signaled);
 check_event_state(event, 0, 1);

 ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(event, 0, 1);

 ret = wait_any(fd, 1, &event, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);

 ret = ioctl(event, NTSYNC_IOC_EVENT_PULSE, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, signaled);
 check_event_state(event, 0, 1);

 ret = ioctl(event, NTSYNC_IOC_EVENT_PULSE, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(event, 0, 1);

 close(event);

 close(fd);
}

TEST(auto_event_state)
{
 struct ntsync_event_args event_args;
 __u32 index, signaled;
 int fd, event, ret;

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 event_args.manual = 0;
 event_args.signaled = 1;
 event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, event);

 check_event_state(event, 1, 0);

 signaled = 0xdeadbeef;
 ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, signaled);
 check_event_state(event, 1, 0);

 ret = wait_any(fd, 1, &event, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_event_state(event, 0, 0);

 signaled = 0xdeadbeef;
 ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(event, 0, 0);

 ret = wait_any(fd, 1, &event, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);

 ret = ioctl(event, NTSYNC_IOC_EVENT_PULSE, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, signaled);
 check_event_state(event, 0, 0);

 ret = ioctl(event, NTSYNC_IOC_EVENT_PULSE, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(event, 0, 0);

 close(event);

 close(fd);
}

TEST(test_wait_any)
{
 int objs[NTSYNC_MAX_WAIT_COUNT + 1], fd, ret;
 struct ntsync_mutex_args mutex_args = {0};
 struct ntsync_sem_args sem_args = {0};
 __u32 owner, index, count, i;
 struct timespec timeout;

 clock_gettime(CLOCK_MONOTONIC, &timeout);

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 sem_args.count = 2;
 sem_args.max = 3;
 objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, objs[0]);

 mutex_args.owner = 0;
 mutex_args.count = 0;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_LE(0, objs[1]);

 ret = wait_any(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(objs[0], 1, 3);
 check_mutex_state(objs[1], 0, 0);

 ret = wait_any(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(objs[0], 0, 3);
 check_mutex_state(objs[1], 0, 0);

 ret = wait_any(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, index);
 check_sem_state(objs[0], 0, 3);
 check_mutex_state(objs[1], 1, 123);

 count = 1;
 ret = release_sem(objs[0], &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, count);

 ret = wait_any(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(objs[0], 0, 3);
 check_mutex_state(objs[1], 1, 123);

 ret = wait_any(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, index);
 check_sem_state(objs[0], 0, 3);
 check_mutex_state(objs[1], 2, 123);

 ret = wait_any(fd, 2, objs, 456, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 owner = 123;
 ret = ioctl(objs[1], NTSYNC_IOC_MUTEX_KILL, &owner);
 EXPECT_EQ(0, ret);

 ret = wait_any(fd, 2, objs, 456, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOWNERDEAD, errno);
 EXPECT_EQ(1, index);

 ret = wait_any(fd, 2, objs, 456, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, index);

 close(objs[1]);

 /* test waiting on the same object twice */

 count = 2;
 ret = release_sem(objs[0], &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, count);

 objs[1] = objs[0];
 ret = wait_any(fd, 2, objs, 456, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(objs[0], 1, 3);

 ret = wait_any(fd, 0, NULL, 456, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 for (i = 1; i < NTSYNC_MAX_WAIT_COUNT + 1; ++i)
  objs[i] = objs[0];

 ret = wait_any(fd, NTSYNC_MAX_WAIT_COUNT, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);

 ret = wait_any(fd, NTSYNC_MAX_WAIT_COUNT + 1, objs, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EINVAL, errno);

 ret = wait_any(fd, -1, objs, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EINVAL, errno);

 close(objs[0]);

 close(fd);
}

TEST(test_wait_all)
{
 struct ntsync_event_args event_args = {0};
 struct ntsync_mutex_args mutex_args = {0};
 struct ntsync_sem_args sem_args = {0};
 __u32 owner, index, count;
 int objs[2], fd, ret;

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 sem_args.count = 2;
 sem_args.max = 3;
 objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, objs[0]);

 mutex_args.owner = 0;
 mutex_args.count = 0;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_LE(0, objs[1]);

 ret = wait_all(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(objs[0], 1, 3);
 check_mutex_state(objs[1], 1, 123);

 ret = wait_all(fd, 2, objs, 456, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);
 check_sem_state(objs[0], 1, 3);
 check_mutex_state(objs[1], 1, 123);

 ret = wait_all(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(objs[0], 0, 3);
 check_mutex_state(objs[1], 2, 123);

 ret = wait_all(fd, 2, objs, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);
 check_sem_state(objs[0], 0, 3);
 check_mutex_state(objs[1], 2, 123);

 count = 3;
 ret = release_sem(objs[0], &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, count);

 ret = wait_all(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(objs[0], 2, 3);
 check_mutex_state(objs[1], 3, 123);

 owner = 123;
 ret = ioctl(objs[1], NTSYNC_IOC_MUTEX_KILL, &owner);
 EXPECT_EQ(0, ret);

 ret = wait_all(fd, 2, objs, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EOWNERDEAD, errno);
 check_sem_state(objs[0], 1, 3);
 check_mutex_state(objs[1], 1, 123);

 close(objs[1]);

 event_args.manual = true;
 event_args.signaled = true;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, objs[1]);

 ret = wait_all(fd, 2, objs, 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);
 check_sem_state(objs[0], 0, 3);
 check_event_state(objs[1], 1, 1);

 close(objs[1]);

 /* test waiting on the same object twice */
 objs[1] = objs[0];
 ret = wait_all(fd, 2, objs, 123, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(EINVAL, errno);

 close(objs[0]);

 close(fd);
}

struct wake_args {
 int fd;
 int obj;
};

struct wait_args {
 int fd;
 unsigned long request;
 struct ntsync_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 __u64 get_abs_timeout(unsigned int ms)
{
 struct timespec timeout;
 clock_gettime(CLOCK_MONOTONIC, &timeout);
 return (timeout.tv_sec * 1000000000) + timeout.tv_nsec + (ms * 1000000);
}

static int wait_for_thread(pthread_t thread, unsigned int ms)
{
 struct timespec timeout;

 clock_gettime(CLOCK_REALTIME, &timeout);
 timeout.tv_nsec += ms * 1000000;
 timeout.tv_sec += (timeout.tv_nsec / 1000000000);
 timeout.tv_nsec %= 1000000000;
 return pthread_timedjoin_np(thread, NULL, &timeout);
}

TEST(wake_any)
{
 struct ntsync_event_args event_args = {0};
 struct ntsync_mutex_args mutex_args = {0};
 struct ntsync_wait_args wait_args = {0};
 struct ntsync_sem_args sem_args = {0};
 struct wait_args thread_args;
 __u32 count, index, signaled;
 int objs[2], fd, ret;
 pthread_t thread;

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 sem_args.count = 0;
 sem_args.max = 3;
 objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, objs[0]);

 mutex_args.owner = 123;
 mutex_args.count = 1;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_LE(0, objs[1]);

 /* test waking the semaphore */

 wait_args.timeout = get_abs_timeout(1000);
 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 = NTSYNC_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);

 count = 1;
 ret = release_sem(objs[0], &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, count);
 check_sem_state(objs[0], 0, 3);

 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 */
 ret = wait_any(fd, 1, &objs[1], 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);

 wait_args.timeout = get_abs_timeout(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);

 ret = unlock_mutex(objs[1], 123, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(2, count);

 ret = pthread_tryjoin_np(thread, NULL);
 EXPECT_EQ(EBUSY, ret);

 ret = unlock_mutex(objs[1], 123, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, mutex_args.count);
 check_mutex_state(objs[1], 1, 456);

 ret = wait_for_thread(thread, 100);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, thread_args.ret);
 EXPECT_EQ(1, wait_args.index);

 close(objs[1]);

 /* test waking events */

 event_args.manual = false;
 event_args.signaled = false;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, objs[1]);

 wait_args.timeout = get_abs_timeout(1000);
 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(objs[1], NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(objs[1], 0, 0);

 ret = wait_for_thread(thread, 100);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, thread_args.ret);
 EXPECT_EQ(1, wait_args.index);

 wait_args.timeout = get_abs_timeout(1000);
 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(objs[1], NTSYNC_IOC_EVENT_PULSE, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(objs[1], 0, 0);

 ret = wait_for_thread(thread, 100);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, thread_args.ret);
 EXPECT_EQ(1, wait_args.index);

 close(objs[1]);

 event_args.manual = true;
 event_args.signaled = false;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, objs[1]);

 wait_args.timeout = get_abs_timeout(1000);
 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(objs[1], NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(objs[1], 1, 1);

 ret = wait_for_thread(thread, 100);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, thread_args.ret);
 EXPECT_EQ(1, wait_args.index);

 ret = ioctl(objs[1], NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, signaled);

 wait_args.timeout = get_abs_timeout(1000);
 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(objs[1], NTSYNC_IOC_EVENT_PULSE, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);
 check_event_state(objs[1], 0, 1);

 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 */

 wait_args.timeout = get_abs_timeout(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);

 close(objs[0]);
 close(objs[1]);

 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 ntsync_event_args manual_event_args = {0};
 struct ntsync_event_args auto_event_args = {0};
 struct ntsync_mutex_args mutex_args = {0};
 struct ntsync_wait_args wait_args = {0};
 struct ntsync_sem_args sem_args = {0};
 struct wait_args thread_args;
 __u32 count, index, signaled;
 int objs[4], fd, ret;
 pthread_t thread;

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 sem_args.count = 0;
 sem_args.max = 3;
 objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, objs[0]);

 mutex_args.owner = 123;
 mutex_args.count = 1;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_LE(0, objs[1]);

 manual_event_args.manual = true;
 manual_event_args.signaled = true;
 objs[2] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &manual_event_args);
 EXPECT_LE(0, objs[2]);

 auto_event_args.manual = false;
 auto_event_args.signaled = true;
 objs[3] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &auto_event_args);
 EXPECT_EQ(0, objs[3]);

 wait_args.timeout = get_abs_timeout(1000);
 wait_args.objs = (uintptr_t)objs;
 wait_args.count = 4;
 wait_args.owner = 456;
 thread_args.fd = fd;
 thread_args.args = &wait_args;
 thread_args.request = NTSYNC_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);

 count = 1;
 ret = release_sem(objs[0], &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, count);

 ret = pthread_tryjoin_np(thread, NULL);
 EXPECT_EQ(EBUSY, ret);

 check_sem_state(objs[0], 1, 3);

 ret = wait_any(fd, 1, &objs[0], 123, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);

 ret = unlock_mutex(objs[1], 123, &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, count);

 ret = pthread_tryjoin_np(thread, NULL);
 EXPECT_EQ(EBUSY, ret);

 check_mutex_state(objs[1], 0, 0);

 ret = ioctl(objs[2], NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, signaled);

 count = 2;
 ret = release_sem(objs[0], &count);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, count);
 check_sem_state(objs[0], 2, 3);

 ret = ioctl(objs[3], NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, signaled);

 ret = ioctl(objs[2], NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);

 ret = ioctl(objs[3], NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, signaled);

 check_sem_state(objs[0], 1, 3);
 check_mutex_state(objs[1], 1, 456);
 check_event_state(objs[2], 1, 1);
 check_event_state(objs[3], 0, 0);

 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 */

 wait_args.timeout = get_abs_timeout(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);

 close(objs[0]);
 close(objs[1]);
 close(objs[2]);
 close(objs[3]);

 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(alert_any)
{
 struct ntsync_event_args event_args = {0};
 struct ntsync_wait_args wait_args = {0};
 struct ntsync_sem_args sem_args = {0};
 __u32 index, count, signaled;
 struct wait_args thread_args;
 int objs[2], event, fd, ret;
 pthread_t thread;

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 sem_args.count = 0;
 sem_args.max = 2;
 objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, objs[0]);

 sem_args.count = 1;
 sem_args.max = 2;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, objs[1]);

 event_args.manual = true;
 event_args.signaled = true;
 event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, event);

 ret = wait_any_alert(fd, 0, NULL, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);

 ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);

 ret = wait_any_alert(fd, 0, NULL, 123, event, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);

 ret = wait_any_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(1, index);

 ret = wait_any_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(2, index);

 /* test wakeup via alert */

 ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);

 wait_args.timeout = get_abs_timeout(1000);
 wait_args.objs = (uintptr_t)objs;
 wait_args.count = 2;
 wait_args.owner = 123;
 wait_args.index = 0xdeadbeef;
 wait_args.alert = event;
 thread_args.fd = fd;
 thread_args.args = &wait_args;
 thread_args.request = NTSYNC_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);

 ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);

 ret = wait_for_thread(thread, 100);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, thread_args.ret);
 EXPECT_EQ(2, wait_args.index);

 close(event);

 /* test with an auto-reset event */

 event_args.manual = false;
 event_args.signaled = true;
 event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, event);

 count = 1;
 ret = release_sem(objs[0], &count);
 EXPECT_EQ(0, ret);

 ret = wait_any_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);

 ret = wait_any_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(2, index);

 ret = wait_any_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 close(event);

 close(objs[0]);
 close(objs[1]);

 close(fd);
}

TEST(alert_all)
{
 struct ntsync_event_args event_args = {0};
 struct ntsync_wait_args wait_args = {0};
 struct ntsync_sem_args sem_args = {0};
 struct wait_args thread_args;
 __u32 index, count, signaled;
 int objs[2], event, fd, ret;
 pthread_t thread;

 fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, fd);

 sem_args.count = 2;
 sem_args.max = 2;
 objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, objs[0]);

 sem_args.count = 1;
 sem_args.max = 2;
 objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args);
 EXPECT_LE(0, objs[1]);

 event_args.manual = true;
 event_args.signaled = true;
 event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, event);

 ret = wait_all_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);

 ret = wait_all_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(2, index);

 /* test wakeup via alert */

 ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled);
 EXPECT_EQ(0, ret);

 wait_args.timeout = get_abs_timeout(1000);
 wait_args.objs = (uintptr_t)objs;
 wait_args.count = 2;
 wait_args.owner = 123;
 wait_args.index = 0xdeadbeef;
 wait_args.alert = event;
 thread_args.fd = fd;
 thread_args.args = &wait_args;
 thread_args.request = NTSYNC_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);

 ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);

 ret = wait_for_thread(thread, 100);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, thread_args.ret);
 EXPECT_EQ(2, wait_args.index);

 close(event);

 /* test with an auto-reset event */

 event_args.manual = false;
 event_args.signaled = true;
 event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, event);

 count = 2;
 ret = release_sem(objs[1], &count);
 EXPECT_EQ(0, ret);

 ret = wait_all_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(0, index);

 ret = wait_all_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(0, ret);
 EXPECT_EQ(2, index);

 ret = wait_all_alert(fd, 2, objs, 123, event, &index);
 EXPECT_EQ(-1, ret);
 EXPECT_EQ(ETIMEDOUT, errno);

 close(event);

 close(objs[0]);
 close(objs[1]);

 close(fd);
}

#define STRESS_LOOPS 10000
#define STRESS_THREADS 4

static unsigned int stress_counter;
static int stress_device, stress_start_event, stress_mutex;

static void *stress_thread(void *arg)
{
 struct ntsync_wait_args wait_args = {0};
 __u32 index, count, i;
 int ret;

 wait_args.timeout = UINT64_MAX;
 wait_args.count = 1;
 wait_args.objs = (uintptr_t)&stress_start_event;
 wait_args.owner = gettid();
 wait_args.index = 0xdeadbeef;

 ioctl(stress_device, NTSYNC_IOC_WAIT_ANY, &wait_args);

 wait_args.objs = (uintptr_t)&stress_mutex;

 for (i = 0; i < STRESS_LOOPS; ++i) {
  ioctl(stress_device, NTSYNC_IOC_WAIT_ANY, &wait_args);

  ++stress_counter;

  unlock_mutex(stress_mutex, wait_args.owner, &count);
 }

 return NULL;
}

TEST(stress_wait)
{
 struct ntsync_event_args event_args;
 struct ntsync_mutex_args mutex_args;
 pthread_t threads[STRESS_THREADS];
 __u32 signaled, i;
 int ret;

 stress_device = open("/dev/ntsync", O_CLOEXEC | O_RDONLY);
 ASSERT_LE(0, stress_device);

 mutex_args.owner = 0;
 mutex_args.count = 0;
 stress_mutex = ioctl(stress_device, NTSYNC_IOC_CREATE_MUTEX, &mutex_args);
 EXPECT_LE(0, stress_mutex);

 event_args.manual = 1;
 event_args.signaled = 0;
 stress_start_event = ioctl(stress_device, NTSYNC_IOC_CREATE_EVENT, &event_args);
 EXPECT_LE(0, stress_start_event);

 for (i = 0; i < STRESS_THREADS; ++i)
  pthread_create(&threads[i], NULL, stress_thread, NULL);

 ret = ioctl(stress_start_event, NTSYNC_IOC_EVENT_SET, &signaled);
 EXPECT_EQ(0, ret);

 for (i = 0; i < STRESS_THREADS; ++i) {
  ret = pthread_join(threads[i], NULL);
  EXPECT_EQ(0, ret);
 }

 EXPECT_EQ(STRESS_LOOPS * STRESS_THREADS, stress_counter);

 close(stress_start_event);
 close(stress_mutex);
 close(stress_device);
}

TEST_HARNESS_MAIN