From nobody Tue Nov 10 00:22:19 2026 X-Original-To: dev-commits-src-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4jNnQz5pGQz70l3P for ; Tue, 10 Nov 2026 00:22:19 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange x25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by mx1.freebsd.org (Postfix) with ESMTPS id 4jNnQz4gjfz3R9v for ; Tue, 10 Nov 2026 00:22:19 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1794270139; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=yvF+/XR5OFgz+I++gEysPXbDLXIPCQOh8zW0ac7Zhro=; b=SZ6ChaI+ZCh2sSq10hTjJuEtLtsNptr1YEXgCY9tE5eNpE83p3fP3bgutm+QzmijvZTPNa FO7WgIOc2dwOcDxtKw83sRbfjB6YVOD+CZnlO72Fac+U2fjsQ5Aqhdfd7CMdMzeJsA+mz6 VgZFFLUVUZF+i0Q9Pzvc5EiItgBrxuHbDkJwtcfTkP9yDFySFsK5BiYYmCSrI2sW8aouZk fsCYFlXk73KDQbH5NR6RroyQ5FjWZPXu7JAjjUE6mHmH3/VdyzAUtTzQ98v7G/FXdw+b7h SOVZMxs3NW6dkStSS3TJs0UZvsugQzi7Tcsske8ww0D6DHGCTk04ykKfjPQ/cw== ARC-Seal: i=1; a=rsa-sha256; d=freebsd.org; s=dkim; cv=none; t=1794270139; b=ShKa8rHkhx+MHFmGzJdTt0l3toq582MsHicKg6KNoijEXCRbsQkZF/x7lobSOdShlQZVxq vxX3yVrfdW2unp++nZ65VnM65O5g7sMkEOE02Tu1ri3yLYB88A5ifdw2ZOTRXeejUzVN5E 2u+gzRUx2LBJBpfCXQSRZHBxD42duqdIRoSWVyz4EFC4Y/GGJS+lZJi4A1dYPH5RtSxv5K sUfABiX8eno8DUu2Bt1nwaVoA0mfomjCj2Klt2nivTraEh1R5ashO10+agxJSunqI0YmCC qrsFEK338m+Vo2hxDcgA2vltVw373X/pSoRr3PszF7oXxLHG/KUswu2cuQsHZQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1794270139; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=yvF+/XR5OFgz+I++gEysPXbDLXIPCQOh8zW0ac7Zhro=; b=nj/B9aEH7EC2X3i1DhNfGQk6rpGNZ/qXL4N1rlvKZ5xukeqMB4B/V4bpaXKcJuW16XSw+t u2kEvLx/IltblTwMY+2HnA/faO470Q+iVOcBsEL17I8B2Fp5BvxqmIZD8o1NhJCx31uR1W C4djGWAiVP5UbLs4yYfrRNXbxNFWWvaPMGp2RYlG0xKqXQB1TAHdy5+a4bl4zQzFaWE4Ba a/y1KrGle1DqLow9inLr69yP55SLvhA3fpV2qRRFSoQQ0h+m0+4kbaVikzxG3ejAtVhH8R o2C2ZMZYknszbZ96/+5x5UmI6Npk3MDZCybnXVYDCQ7jneX2szcDdIx7ylW0ew== ARC-Authentication-Results: i=1; mx1.freebsd.org; none Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) by mxrelay.nyi.freebsd.org (Postfix) with ESMTP id 4jNnQz4Kj3z13lJ for ; Tue, 10 Nov 2026 00:22:19 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from git (uid 1279) (envelope-from git@FreeBSD.org) id fa20 by gitrepo.freebsd.org (DragonFly Mail Agent v0.13+ on gitrepo.freebsd.org); Tue, 10 Nov 2026 00:22:19 +0000 To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org From: Konstantin Belousov Subject: git: 083b44ddc07c - main - libthr: add tests for pthread_rwlock_clock{rd,wr}lock(3) List-Archive: https://lists.freebsd.org/archives/dev-commits-src-all X-BeenThere: dev-commits-src-all@freebsd.org Sender: owner-dev-commits-src-all@FreeBSD.org List-Id: Commit messages for all branches of the src repository List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: kib X-Git-Repository: src X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: 083b44ddc07c6e07bcf889aa1f38c240d9dc0fc6 Auto-Submitted: auto-generated Date: Tue, 10 Nov 2026 00:22:19 +0000 Message-Id: <6af263bb.fa20.57085697@gitrepo.freebsd.org> The branch main has been updated by kib: URL: https://cgit.FreeBSD.org/src/commit/?id=083b44ddc07c6e07bcf889aa1f38c240d9dc0fc6 commit 083b44ddc07c6e07bcf889aa1f38c240d9dc0fc6 Author: Konstantin Belousov AuthorDate: 2026-11-06 01:38:17 +0000 Commit: Konstantin Belousov CommitDate: 2026-11-10 00:21:19 +0000 libthr: add tests for pthread_rwlock_clock{rd,wr}lock(3) Reviewed by: markj Sponsored by: The FreeBSD Foundation MFC after: 1 week Differential revision: https://reviews.freebsd.org/D61253 --- lib/libthr/tests/Makefile | 1 + lib/libthr/tests/pthread_rwlock_clocklock_test.c | 528 +++++++++++++++++++++++ 2 files changed, 529 insertions(+) diff --git a/lib/libthr/tests/Makefile b/lib/libthr/tests/Makefile index f99622c324a4..286d46feac45 100644 --- a/lib/libthr/tests/Makefile +++ b/lib/libthr/tests/Makefile @@ -39,6 +39,7 @@ ATF_TESTS_C+= pthread_sigqueue_test ATF_TESTS_C+= pthread_tryjoin_test ATF_TESTS_C+= pthread_query_test ATF_TESTS_C+= pthread_mutex_clocklock_test +ATF_TESTS_C+= pthread_rwlock_clocklock_test LIBADD+= pthread LIBADD.fpu_test+= m diff --git a/lib/libthr/tests/pthread_rwlock_clocklock_test.c b/lib/libthr/tests/pthread_rwlock_clocklock_test.c new file mode 100644 index 000000000000..11d2be34bdc6 --- /dev/null +++ b/lib/libthr/tests/pthread_rwlock_clocklock_test.c @@ -0,0 +1,528 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright 2026 The FreeBSD Foundation + * + * This software was developed by Konstantin Belousov + * under sponsorship from the FreeBSD Foundation. + */ + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#define TIMEOUT_MS 250 + +static const struct test_clock { + clockid_t id; + const char *name; +} accepted_clocks[] = { +#define CLK(c) { .id = (c), .name = #c } + CLK(CLOCK_REALTIME), + CLK(CLOCK_REALTIME_PRECISE), + CLK(CLOCK_REALTIME_FAST), + CLK(CLOCK_MONOTONIC), + CLK(CLOCK_MONOTONIC_PRECISE), + CLK(CLOCK_MONOTONIC_FAST), + CLK(CLOCK_UPTIME), + CLK(CLOCK_UPTIME_PRECISE), + CLK(CLOCK_UPTIME_FAST), + CLK(CLOCK_SECOND), + CLK(CLOCK_VIRTUAL), + CLK(CLOCK_PROF), + CLK(CLOCK_PROCESS_CPUTIME_ID), + CLK(CLOCK_TAI), +#undef CLK +}; + +struct locker { + pthread_rwlock_t *rw; + bool write; + clockid_t clock; + struct timespec abstime; + int error; + bool reached; /* clock reached abstime on return */ +}; + +/* + * Set *ts to the time msec milliseconds after the current time of + * the clock. + */ +static void +deadline(clockid_t clock, long msec, struct timespec *ts) +{ + ATF_REQUIRE_INTEQ(0, clock_gettime(clock, ts)); + ts->tv_sec += msec / 1000; + ts->tv_nsec += (msec % 1000) * 1000000; + if (ts->tv_nsec >= 1000000000) { + ts->tv_sec++; + ts->tv_nsec -= 1000000000; + } +} + +static bool +clock_reached(clockid_t clock, const struct timespec *ts) +{ + struct timespec now; + + return (clock_gettime(clock, &now) == 0 && + timespeccmp(&now, ts, >=)); +} + +static int +clocklock(pthread_rwlock_t *rw, bool write, clockid_t clock, + const struct timespec *abstime) +{ + return (write ? pthread_rwlock_clockwrlock(rw, clock, abstime) : + pthread_rwlock_clockrdlock(rw, clock, abstime)); +} + +/* + * Lock the rwlock so that the lock for the given mode cannot be + * granted: a reader is blocked by a writer, and a writer by a reader. + */ +static void +block_mode(pthread_rwlock_t *rw, bool write) +{ + if (write) + ATF_REQUIRE_INTEQ(0, pthread_rwlock_rdlock(rw)); + else + ATF_REQUIRE_INTEQ(0, pthread_rwlock_wrlock(rw)); +} + +static void * +locker_thread(void *arg) +{ + struct locker *l; + + l = arg; + l->error = clocklock(l->rw, l->write, l->clock, &l->abstime); + l->reached = clock_reached(l->clock, &l->abstime); + if (l->error == 0) + (void)pthread_rwlock_unlock(l->rw); + return (NULL); +} + +static void +locker_start(struct locker *l, pthread_t *thr, pthread_rwlock_t *rw, + bool write, clockid_t clock, const struct timespec *abstime) +{ + l->rw = rw; + l->write = write; + l->clock = clock; + l->abstime = *abstime; + l->error = -1; + l->reached = false; + ATF_REQUIRE_INTEQ(0, pthread_create(thr, NULL, locker_thread, l)); +} + +/* + * Try to lock from another thread, while the calling thread holds + * the lock in the conflicting mode. + */ +static void +clocklock_contended(pthread_rwlock_t *rw, bool write, clockid_t clock, + const struct timespec *abstime, struct locker *l) +{ + pthread_t thr; + + locker_start(l, &thr, rw, write, clock, abstime); + ATF_REQUIRE_INTEQ(0, pthread_join(thr, NULL)); +} + +static const char * +mode_name(bool write) +{ + return (write ? "pthread_rwlock_clockwrlock" : + "pthread_rwlock_clockrdlock"); +} + +static void +check_uncontended(bool write) +{ + pthread_rwlock_t rw; + struct timespec ts; + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_init(&rw, NULL)); + + deadline(CLOCK_REALTIME, TIMEOUT_MS, &ts); + ATF_CHECK_INTEQ(0, clocklock(&rw, write, CLOCK_REALTIME, &ts)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + + deadline(CLOCK_MONOTONIC, TIMEOUT_MS, &ts); + ATF_CHECK_INTEQ(0, clocklock(&rw, write, CLOCK_MONOTONIC, &ts)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + + /* Not validated when the lock is granted without blocking. */ + ATF_CHECK_INTEQ(0, clocklock(&rw, write, CLOCK_THREAD_CPUTIME_ID, + &ts)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + + ts.tv_nsec = 1000000000; + ATF_CHECK_INTEQ(0, clocklock(&rw, write, CLOCK_MONOTONIC, &ts)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_destroy(&rw)); +} + +static void +check_timeout(bool write, clockid_t clock) +{ + pthread_rwlock_t rw; + struct timespec ts; + struct locker l; + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_init(&rw, NULL)); + block_mode(&rw, write); + deadline(clock, TIMEOUT_MS, &ts); + clocklock_contended(&rw, write, clock, &ts, &l); + ATF_CHECK_INTEQ(ETIMEDOUT, l.error); + ATF_CHECK_MSG(l.reached, "returned before the timeout expired"); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_destroy(&rw)); +} + +static void +check_wakeup(bool write) +{ + pthread_rwlock_t rw; + pthread_t thr; + struct timespec ts; + struct locker l; + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_init(&rw, NULL)); + block_mode(&rw, write); + deadline(CLOCK_MONOTONIC, 60 * 1000, &ts); + locker_start(&l, &thr, &rw, write, CLOCK_MONOTONIC, &ts); + usleep(100 * 1000); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + ATF_REQUIRE_INTEQ(0, pthread_join(thr, NULL)); + ATF_CHECK_INTEQ(0, l.error); + ATF_CHECK_MSG(!l.reached, "returned after the timeout expired"); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_destroy(&rw)); +} + +static void +check_accepted_clocks(bool write) +{ + const struct test_clock *c; + pthread_rwlock_t rw; + struct timespec ts; + struct locker l; + u_int i; + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_init(&rw, NULL)); + block_mode(&rw, write); + for (i = 0; i < nitems(accepted_clocks); i++) { + c = &accepted_clocks[i]; + + /* + * The deadline is the current time, so the wait times + * out right away. CLOCK_TAI cannot be read until the + * TAI-UTC offset is known. + */ + if (clock_gettime(c->id, &ts) != 0) { + ATF_REQUIRE_MSG(c->id == CLOCK_TAI, + "clock_gettime(%s): %s", c->name, strerror(errno)); + continue; + } + clocklock_contended(&rw, write, c->id, &ts, &l); + ATF_CHECK_INTEQ_MSG(ETIMEDOUT, l.error, "%s %s", + mode_name(write), c->name); + } + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_destroy(&rw)); +} + +static void +check_rejected_clocks(bool write) +{ + pthread_rwlock_t rw; + struct timespec ts; + struct locker l; + clockid_t clocks[4]; + u_int i; + + clocks[0] = CLOCK_THREAD_CPUTIME_ID; + clocks[1] = INT_MAX; /* not a clock */ + ATF_REQUIRE_INTEQ(0, clock_getcpuclockid(getpid(), &clocks[2])); + ATF_REQUIRE_INTEQ(0, pthread_getcpuclockid(pthread_self(), + &clocks[3])); + deadline(CLOCK_REALTIME, TIMEOUT_MS, &ts); + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_init(&rw, NULL)); + block_mode(&rw, write); + for (i = 0; i < nitems(clocks); i++) { + clocklock_contended(&rw, write, clocks[i], &ts, &l); + ATF_CHECK_INTEQ_MSG(EINVAL, l.error, "%s clock %d", + mode_name(write), clocks[i]); + } + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_destroy(&rw)); +} + +static void +check_invalid_abstime(bool write) +{ + pthread_rwlock_t rw; + struct timespec ts; + struct locker l; + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_init(&rw, NULL)); + block_mode(&rw, write); + deadline(CLOCK_MONOTONIC, TIMEOUT_MS, &ts); + ts.tv_nsec = 1000000000; + clocklock_contended(&rw, write, CLOCK_MONOTONIC, &ts, &l); + ATF_CHECK_INTEQ_MSG(EINVAL, l.error, "%s", mode_name(write)); + ts.tv_nsec = -1; + clocklock_contended(&rw, write, CLOCK_MONOTONIC, &ts, &l); + ATF_CHECK_INTEQ_MSG(EINVAL, l.error, "%s", mode_name(write)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_destroy(&rw)); +} + +static void +check_zero_deadline(bool write) +{ + static const struct test_clock clocks[] = { + { .id = CLOCK_REALTIME, .name = "CLOCK_REALTIME" }, + { .id = CLOCK_MONOTONIC, .name = "CLOCK_MONOTONIC" }, + { .id = CLOCK_UPTIME, .name = "CLOCK_UPTIME" }, + }; + pthread_rwlock_t rw; + struct timespec ts; + struct locker l; + u_int i; + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_init(&rw, NULL)); + block_mode(&rw, write); + ts.tv_sec = 0; + ts.tv_nsec = 0; + for (i = 0; i < nitems(clocks); i++) { + clocklock_contended(&rw, write, clocks[i].id, &ts, &l); + ATF_CHECK_INTEQ_MSG(ETIMEDOUT, l.error, "%s %s", + mode_name(write), clocks[i].name); + } + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_destroy(&rw)); +} + +ATF_TC(clockrdlock_uncontended); +ATF_TC_HEAD(clockrdlock_uncontended, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that a free rwlock is read-locked without validating " + "the clock and the timeout"); +} + +ATF_TC_BODY(clockrdlock_uncontended, tc) +{ + check_uncontended(false); +} + +ATF_TC(clockwrlock_uncontended); +ATF_TC_HEAD(clockwrlock_uncontended, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that a free rwlock is write-locked without validating " + "the clock and the timeout"); +} + +ATF_TC_BODY(clockwrlock_uncontended, tc) +{ + check_uncontended(true); +} + +ATF_TC(clockrdlock_timeout_realtime); +ATF_TC_HEAD(clockrdlock_timeout_realtime, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks the CLOCK_REALTIME timeout for a read lock"); +} + +ATF_TC_BODY(clockrdlock_timeout_realtime, tc) +{ + check_timeout(false, CLOCK_REALTIME); +} + +ATF_TC(clockrdlock_timeout_monotonic); +ATF_TC_HEAD(clockrdlock_timeout_monotonic, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks the CLOCK_MONOTONIC timeout for a read lock"); +} + +ATF_TC_BODY(clockrdlock_timeout_monotonic, tc) +{ + check_timeout(false, CLOCK_MONOTONIC); +} + +ATF_TC(clockwrlock_timeout_realtime); +ATF_TC_HEAD(clockwrlock_timeout_realtime, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks the CLOCK_REALTIME timeout for a write lock"); +} + +ATF_TC_BODY(clockwrlock_timeout_realtime, tc) +{ + check_timeout(true, CLOCK_REALTIME); +} + +ATF_TC(clockwrlock_timeout_monotonic); +ATF_TC_HEAD(clockwrlock_timeout_monotonic, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks the CLOCK_MONOTONIC timeout for a write lock"); +} + +ATF_TC_BODY(clockwrlock_timeout_monotonic, tc) +{ + check_timeout(true, CLOCK_MONOTONIC); +} + +ATF_TC(clockrdlock_wakeup); +ATF_TC_HEAD(clockrdlock_wakeup, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that a reader gets the lock when the writer unlocks " + "it before the timeout"); +} + +ATF_TC_BODY(clockrdlock_wakeup, tc) +{ + check_wakeup(false); +} + +ATF_TC(clockwrlock_wakeup); +ATF_TC_HEAD(clockwrlock_wakeup, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that a writer gets the lock when the reader unlocks " + "it before the timeout"); +} + +ATF_TC_BODY(clockwrlock_wakeup, tc) +{ + check_wakeup(true); +} + +ATF_TC(clocklock_accepted_clocks); +ATF_TC_HEAD(clocklock_accepted_clocks, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that all clocks accepted by _umtx_op(2) can be used"); +} + +ATF_TC_BODY(clocklock_accepted_clocks, tc) +{ + check_accepted_clocks(false); + check_accepted_clocks(true); +} + +ATF_TC(clocklock_rejected_clocks); +ATF_TC_HEAD(clocklock_rejected_clocks, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that EINVAL is returned for unsupported clocks when " + "the lock cannot be granted"); + atf_tc_set_md_var(tc, "timeout", "30"); +} + +ATF_TC_BODY(clocklock_rejected_clocks, tc) +{ + check_rejected_clocks(false); + check_rejected_clocks(true); +} + +ATF_TC(clocklock_invalid_abstime); +ATF_TC_HEAD(clocklock_invalid_abstime, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that EINVAL is returned for an invalid timeout when " + "the lock cannot be granted"); +} + +ATF_TC_BODY(clocklock_invalid_abstime, tc) +{ + check_invalid_abstime(false); + check_invalid_abstime(true); +} + +ATF_TC(clocklock_zero_deadline); +ATF_TC_HEAD(clocklock_zero_deadline, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that the absolute time zero is treated as expired"); + atf_tc_set_md_var(tc, "timeout", "30"); +} + +ATF_TC_BODY(clocklock_zero_deadline, tc) +{ + check_zero_deadline(false); + check_zero_deadline(true); +} + +ATF_TC(clocklock_self_deadlock); +ATF_TC_HEAD(clocklock_self_deadlock, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Checks that locking an rwlock write-locked by the calling " + "thread fails with EDEADLK without waiting"); +} + +ATF_TC_BODY(clocklock_self_deadlock, tc) +{ + pthread_rwlock_t rw; + struct timespec ts; + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_init(&rw, NULL)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_wrlock(&rw)); + deadline(CLOCK_MONOTONIC, 60 * 1000, &ts); + ATF_CHECK_INTEQ(EDEADLK, pthread_rwlock_clockrdlock(&rw, + CLOCK_MONOTONIC, &ts)); + ATF_CHECK_INTEQ(EDEADLK, pthread_rwlock_clockwrlock(&rw, + CLOCK_MONOTONIC, &ts)); + ATF_CHECK_MSG(!clock_reached(CLOCK_MONOTONIC, &ts), + "waited for the timeout"); + + /* The calls do not block, so the arguments are not validated. */ + ATF_CHECK_INTEQ(EDEADLK, pthread_rwlock_clockrdlock(&rw, + CLOCK_THREAD_CPUTIME_ID, &ts)); + ATF_CHECK_INTEQ(EDEADLK, pthread_rwlock_clockwrlock(&rw, + CLOCK_THREAD_CPUTIME_ID, &ts)); + ts.tv_nsec = 1000000000; + ATF_CHECK_INTEQ(EDEADLK, pthread_rwlock_clockrdlock(&rw, + CLOCK_MONOTONIC, &ts)); + ATF_CHECK_INTEQ(EDEADLK, pthread_rwlock_clockwrlock(&rw, + CLOCK_MONOTONIC, &ts)); + + ATF_REQUIRE_INTEQ(0, pthread_rwlock_unlock(&rw)); + ATF_REQUIRE_INTEQ(0, pthread_rwlock_destroy(&rw)); +} + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, clockrdlock_uncontended); + ATF_TP_ADD_TC(tp, clockwrlock_uncontended); + ATF_TP_ADD_TC(tp, clockrdlock_timeout_realtime); + ATF_TP_ADD_TC(tp, clockrdlock_timeout_monotonic); + ATF_TP_ADD_TC(tp, clockwrlock_timeout_realtime); + ATF_TP_ADD_TC(tp, clockwrlock_timeout_monotonic); + ATF_TP_ADD_TC(tp, clockrdlock_wakeup); + ATF_TP_ADD_TC(tp, clockwrlock_wakeup); + ATF_TP_ADD_TC(tp, clocklock_accepted_clocks); + ATF_TP_ADD_TC(tp, clocklock_rejected_clocks); + ATF_TP_ADD_TC(tp, clocklock_invalid_abstime); + ATF_TP_ADD_TC(tp, clocklock_zero_deadline); + ATF_TP_ADD_TC(tp, clocklock_self_deadlock); + return (atf_no_error()); +}