mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-09-02 07:35:26 +00:00
Code Issues Releases Wiki Activity

Merge branch '3054-1-misc-pthreads-cleanups' into 'main'

Browse Source 
[1/3] Miscellaneous pthreads cleanups

See merge request isc-projects/bind9!6570
This commit is contained in:
Michał Kępień
2022-07-13 13:01:32 +00:00
parent 9968a6292d deae974366
commit 3ea3af37a4
13 changed files with 151 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
bin/dig/dighost.c
View File

@@ -160,18 +160,16 @@ dig_lookup_t *current_lookup = NULL;
* Apply and clear locks at the event level in global task.
* Can I get rid of these using shutdown events? XXX
*/
#define LOCK_LOOKUP \
{ \
debug("lock_lookup %s:%d", __FILE__, __LINE__); \
check_result(isc_mutex_lock((&lookup_lock)), "isc_mutex_" \
"lock"); \
debug("success"); \
#define LOCK_LOOKUP \
{ \
debug("lock_lookup %s:%d", __FILE__, __LINE__); \
isc_mutex_lock((&lookup_lock)); \
debug("success"); \
}
#define UNLOCK_LOOKUP \
{ \
debug("unlock_lookup %s:%d", __FILE__, __LINE__); \
check_result(isc_mutex_unlock((&lookup_lock)), "isc_mutex_" \
"unlock"); \
#define UNLOCK_LOOKUP \
{ \
debug("unlock_lookup %s:%d", __FILE__, __LINE__); \
isc_mutex_unlock((&lookup_lock)); \
}
static void

1
lib/isc/Makefile.am
View File

@@ -154,6 +154,7 @@ libisc_la_SOURCES = \
mem_p.h \
meminfo.c \
mutex.c \
mutex_p.h \
mutexblock.c \
net.c \
netaddr.c \

27
lib/isc/include/isc/condition.h
View File

@@ -21,34 +21,27 @@
#include <isc/lang.h>
#include <isc/mutex.h>
#include <isc/result.h>
#include <isc/strerr.h>
#include <isc/string.h>
#include <isc/types.h>
#include <isc/util.h>
typedef pthread_cond_t isc_condition_t;
#define isc_condition_init(cond) \
if (pthread_cond_init(cond, NULL) != 0) { \
char isc_condition_strbuf[ISC_STRERRORSIZE]; \
strerror_r(errno, isc_condition_strbuf, \
sizeof(isc_condition_strbuf)); \
isc_error_fatal(__FILE__, __LINE__, \
"pthread_cond_init failed: %s", \
isc_condition_strbuf); \
#define isc_condition_init(cond) \
{ \
int _ret = pthread_cond_init(cond, NULL); \
ERRNO_CHECK(pthread_cond_init, _ret); \
}
#define isc_condition_wait(cp, mp) \
((pthread_cond_wait((cp), (mp)) == 0) ? ISC_R_SUCCESS \
: ISC_R_UNEXPECTED)
#define isc_condition_wait(cp, mp) \
RUNTIME_CHECK(pthread_cond_wait((cp), (mp)) == 0)
#define isc_condition_signal(cp) \
((pthread_cond_signal((cp)) == 0) ? ISC_R_SUCCESS : ISC_R_UNEXPECTED)
#define isc_condition_signal(cp) RUNTIME_CHECK(pthread_cond_signal((cp)) == 0)
#define isc_condition_broadcast(cp) \
((pthread_cond_broadcast((cp)) == 0) ? ISC_R_SUCCESS : ISC_R_UNEXPECTED)
RUNTIME_CHECK(pthread_cond_broadcast((cp)) == 0)
#define isc_condition_destroy(cp) \
((pthread_cond_destroy((cp)) == 0) ? ISC_R_SUCCESS : ISC_R_UNEXPECTED)
#define isc_condition_destroy(cp) RUNTIME_CHECK(pthread_cond_destroy((cp)) == 0)
ISC_LANG_BEGINDECLS

10
lib/isc/include/isc/mutex.h
View File

@@ -26,15 +26,13 @@ ISC_LANG_BEGINDECLS
typedef pthread_mutex_t isc_mutex_t;
void
isc__mutex_init(isc_mutex_t *mp, const char *file, unsigned int line);
isc__mutex_init(isc_mutex_t *mp);
#define isc_mutex_init(mp) isc__mutex_init((mp), __FILE__, __LINE__)
#define isc_mutex_init(mp) isc__mutex_init((mp))
#define isc_mutex_lock(mp) \
((pthread_mutex_lock((mp)) == 0) ? ISC_R_SUCCESS : ISC_R_UNEXPECTED)
#define isc_mutex_lock(mp) RUNTIME_CHECK(pthread_mutex_lock((mp)) == 0)
#define isc_mutex_unlock(mp) \
((pthread_mutex_unlock((mp)) == 0) ? ISC_R_SUCCESS : ISC_R_UNEXPECTED)
#define isc_mutex_unlock(mp) RUNTIME_CHECK(pthread_mutex_unlock((mp)) == 0)
#define isc_mutex_trylock(mp) \
((pthread_mutex_trylock((mp)) == 0) ? ISC_R_SUCCESS : ISC_R_LOCKBUSY)

4
lib/isc/include/isc/rwlock.h
View File

@@ -82,13 +82,13 @@ void
isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
unsigned int write_quota);
isc_result_t
void
isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type);
isc_result_t
isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type);
isc_result_t
void
isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type);
isc_result_t

72
lib/isc/include/isc/util.h
View File

@@ -122,8 +122,6 @@
/*%
* We use macros instead of calling the routines directly because
* the capital letters make the locking stand out.
* We RUNTIME_CHECK for success since in general there's no way
* for us to continue if they fail.
*/
#ifdef ISC_UTIL_TRACEON
@@ -136,42 +134,40 @@
#include <isc/result.h> /* Contractual promise. */
#define LOCK(lp) \
do { \
{ \
ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \
__FILE__, __LINE__)); \
RUNTIME_CHECK(isc_mutex_lock((lp)) == ISC_R_SUCCESS); \
isc_mutex_lock((lp)); \
ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \
__FILE__, __LINE__)); \
} while (0)
}
#define UNLOCK(lp) \
do { \
RUNTIME_CHECK(isc_mutex_unlock((lp)) == ISC_R_SUCCESS); \
{ \
isc_mutex_unlock((lp)); \
ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \
__FILE__, __LINE__)); \
} while (0)
}
#define BROADCAST(cvp) \
do { \
{ \
ISC_UTIL_TRACE(fprintf(stderr, "BROADCAST %p %s %d\n", (cvp), \
__FILE__, __LINE__)); \
RUNTIME_CHECK(isc_condition_broadcast((cvp)) == \
ISC_R_SUCCESS); \
} while (0)
#define SIGNAL(cvp) \
do { \
ISC_UTIL_TRACE(fprintf(stderr, "SIGNAL %p %s %d\n", (cvp), \
__FILE__, __LINE__)); \
RUNTIME_CHECK(isc_condition_signal((cvp)) == ISC_R_SUCCESS); \
} while (0)
isc_condition_broadcast((cvp)); \
}
#define SIGNAL(cvp) \
{ \
ISC_UTIL_TRACE(fprintf(stderr, "SIGNAL %p %s %d\n", (cvp), \
__FILE__, __LINE__)); \
isc_condition_signal((cvp)); \
}
#define WAIT(cvp, lp) \
do { \
{ \
ISC_UTIL_TRACE(fprintf(stderr, "WAIT %p LOCK %p %s %d\n", \
(cvp), (lp), __FILE__, __LINE__)); \
RUNTIME_CHECK(isc_condition_wait((cvp), (lp)) == \
ISC_R_SUCCESS); \
isc_condition_wait((cvp), (lp)); \
ISC_UTIL_TRACE(fprintf(stderr, "WAITED %p LOCKED %p %s %d\n", \
(cvp), (lp), __FILE__, __LINE__)); \
} while (0)
}
/*
* isc_condition_waituntil can return ISC_R_TIMEDOUT, so we
@@ -183,19 +179,19 @@
#define WAITUNTIL(cvp, lp, tp) isc_condition_waituntil((cvp), (lp), (tp))
#define RWLOCK(lp, t) \
do { \
{ \
ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \
(t), __FILE__, __LINE__)); \
RUNTIME_CHECK(isc_rwlock_lock((lp), (t)) == ISC_R_SUCCESS); \
isc_rwlock_lock((lp), (t)); \
ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \
(lp), (t), __FILE__, __LINE__)); \
} while (0)
#define RWUNLOCK(lp, t) \
do { \
ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \
(lp), (t), __FILE__, __LINE__)); \
RUNTIME_CHECK(isc_rwlock_unlock((lp), (t)) == ISC_R_SUCCESS); \
} while (0)
}
#define RWUNLOCK(lp, t) \
{ \
ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \
(lp), (t), __FILE__, __LINE__)); \
isc_rwlock_unlock((lp), (t)); \
}
/*
* List Macros.
@@ -309,7 +305,10 @@ mock_assert(const int result, const char *const expression,
/*
* Errors
*/
#include <isc/error.h> /* Contractual promise. */
#include <errno.h> /* for errno */
#include <isc/error.h> /* Contractual promise. */
#include <isc/strerr.h> /* for ISC_STRERRORSIZE */
/*% Unexpected Error */
#define UNEXPECTED_ERROR isc_error_unexpected
@@ -330,6 +329,15 @@ mock_assert(const int result, const char *const expression,
#endif /* UNIT_TESTING */
/*% Runtime check which logs the error string corresponding to errno */
#define ERRNO_CHECK(func, ret) \
if ((ret) != 0) { \
char _strerrorbuf[ISC_STRERRORSIZE]; \
strerror_r(errno, _strerrorbuf, sizeof(_strerrorbuf)); \
isc_error_fatal(__FILE__, __LINE__, "%s() failed in %s(): %s", \
#func, __func__, _strerrorbuf); \
}
/*%
* Time
*/

3
lib/isc/lib.c
View File

@@ -21,6 +21,7 @@
#include "config.h"
#include "mem_p.h"
#include "mutex_p.h"
#include "os_p.h"
#include "tls_p.h"
#include "trampoline_p.h"
@@ -41,6 +42,7 @@ isc__shutdown(void) ISC_DESTRUCTOR;
void
isc__initialize(void) {
isc__os_initialize();
isc__mutex_initialize();
isc__mem_initialize();
isc__tls_initialize();
isc__trampoline_initialize();
@@ -52,5 +54,6 @@ isc__shutdown(void) {
isc__trampoline_shutdown();
isc__tls_shutdown();
isc__mem_shutdown();
isc__mutex_shutdown();
isc__os_shutdown();
}

51
lib/isc/mutex.c
View File

@@ -26,37 +26,36 @@
#include <isc/string.h>
#include <isc/util.h>
#ifdef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
static bool attr_initialized = false;
static pthread_mutexattr_t attr;
static isc_once_t once_attr = ISC_ONCE_INIT;
#include "mutex_p.h"
pthread_mutexattr_t isc__mutex_init_attr;
static isc_once_t init_once = ISC_ONCE_INIT;
static void
initialize_attr(void) {
RUNTIME_CHECK(pthread_mutexattr_init(&attr) == 0);
RUNTIME_CHECK(pthread_mutexattr_settype(
&attr, PTHREAD_MUTEX_ADAPTIVE_NP) == 0);
attr_initialized = true;
}
mutex_initialize(void) {
RUNTIME_CHECK(pthread_mutexattr_init(&isc__mutex_init_attr) == 0);
#ifdef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
RUNTIME_CHECK(pthread_mutexattr_settype(&isc__mutex_init_attr,
PTHREAD_MUTEX_ADAPTIVE_NP) ==
0);
#endif /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
}
void
isc__mutex_init(isc_mutex_t *mp, const char *file, unsigned int line) {
isc__mutex_initialize(void) {
RUNTIME_CHECK(isc_once_do(&init_once, mutex_initialize) ==
ISC_R_SUCCESS);
}
void
isc__mutex_init(isc_mutex_t *mp) {
int err;
#ifdef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
isc_result_t result = ISC_R_SUCCESS;
result = isc_once_do(&once_attr, initialize_attr);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
err = pthread_mutex_init(mp, &attr);
#else /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
err = pthread_mutex_init(mp, NULL);
#endif /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
if (err != 0) {
char strbuf[ISC_STRERRORSIZE];
strerror_r(err, strbuf, sizeof(strbuf));
isc_error_fatal(file, line, "pthread_mutex_init failed: %s",
strbuf);
}
err = pthread_mutex_init(mp, &isc__mutex_init_attr);
ERRNO_CHECK(pthread_mutex_init, err);
}
void
isc__mutex_shutdown(void) {
/* noop */;
}

22
lib/isc/mutex_p.h Normal file
View File

@@ -0,0 +1,22 @@
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* SPDX-License-Identifier: MPL-2.0
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#pragma once
/*! \file */
void
isc__mutex_initialize(void);
void
isc__mutex_shutdown(void);

52
lib/isc/rwlock.c
View File

@@ -35,25 +35,29 @@
void
isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
unsigned int write_quota) {
int ret;
UNUSED(read_quota);
UNUSED(write_quota);
REQUIRE(pthread_rwlock_init(&rwl->rwlock, NULL) == 0);
ret = pthread_rwlock_init(&rwl->rwlock, NULL);
ERRNO_CHECK(pthread_rwlock_init, ret);
atomic_init(&rwl->downgrade, false);
}
isc_result_t
void
isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
switch (type) {
case isc_rwlocktype_read:
REQUIRE(pthread_rwlock_rdlock(&rwl->rwlock) == 0);
RUNTIME_CHECK(pthread_rwlock_rdlock(&rwl->rwlock) == 0);
break;
case isc_rwlocktype_write:
while (true) {
REQUIRE(pthread_rwlock_wrlock(&rwl->rwlock) == 0);
RUNTIME_CHECK(pthread_rwlock_wrlock(&rwl->rwlock) == 0);
/* Unlock if in middle of downgrade operation */
if (atomic_load_acquire(&rwl->downgrade)) {
REQUIRE(pthread_rwlock_unlock(&rwl->rwlock) ==
0);
RUNTIME_CHECK(pthread_rwlock_unlock(
&rwl->rwlock) == 0);
while (atomic_load_acquire(&rwl->downgrade)) {
}
continue;
@@ -64,7 +68,6 @@ isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
default:
UNREACHABLE();
}
return (ISC_R_SUCCESS);
}
isc_result_t
@@ -77,7 +80,7 @@ isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
case isc_rwlocktype_write:
ret = pthread_rwlock_trywrlock(&rwl->rwlock);
if ((ret == 0) && atomic_load_acquire(&rwl->downgrade)) {
isc_rwlock_unlock(rwl, type);
RUNTIME_CHECK(pthread_rwlock_unlock(&rwl->rwlock) == 0);
return (ISC_R_LOCKBUSY);
}
break;
@@ -97,11 +100,10 @@ isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
}
}
isc_result_t
void
isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
UNUSED(type);
REQUIRE(pthread_rwlock_unlock(&rwl->rwlock) == 0);
return (ISC_R_SUCCESS);
RUNTIME_CHECK(pthread_rwlock_unlock(&rwl->rwlock) == 0);
}
isc_result_t
@@ -112,12 +114,9 @@ isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
void
isc_rwlock_downgrade(isc_rwlock_t *rwl) {
isc_result_t result;
atomic_store_release(&rwl->downgrade, true);
result = isc_rwlock_unlock(rwl, isc_rwlocktype_write);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
result = isc_rwlock_lock(rwl, isc_rwlocktype_read);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
RUNTIME_CHECK(pthread_rwlock_unlock(&rwl->rwlock) == 0);
RUNTIME_CHECK(pthread_rwlock_rdlock(&rwl->rwlock) == 0);
atomic_store_release(&rwl->downgrade, false);
}
@@ -166,7 +165,7 @@ isc_rwlock_destroy(isc_rwlock_t *rwl) {
#define isc_rwlock_pause()
#endif /* if defined(_MSC_VER) */
static isc_result_t
static void
isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type);
#ifdef ISC_RWLOCK_TRACE
@@ -234,8 +233,8 @@ isc_rwlock_destroy(isc_rwlock_t *rwl) {
rwl->readers_waiting == 0);
rwl->magic = 0;
(void)isc_condition_destroy(&rwl->readable);
(void)isc_condition_destroy(&rwl->writeable);
isc_condition_destroy(&rwl->readable);
isc_condition_destroy(&rwl->writeable);
isc_mutex_destroy(&rwl->lock);
}
@@ -304,7 +303,7 @@ isc_rwlock_destroy(isc_rwlock_t *rwl) {
#define WRITER_ACTIVE 0x1
#define READER_INCR 0x2
static isc_result_t
static void
isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
int32_t cntflag;
@@ -419,28 +418,23 @@ isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
#ifdef ISC_RWLOCK_TRACE
print_lock("postlock", rwl, type);
#endif /* ifdef ISC_RWLOCK_TRACE */
return (ISC_R_SUCCESS);
}
isc_result_t
void
isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
int32_t cnt = 0;
int32_t spins = atomic_load_acquire(&rwl->spins) * 2 + 10;
int32_t max_cnt = ISC_MAX(spins, RWLOCK_MAX_ADAPTIVE_COUNT);
isc_result_t result = ISC_R_SUCCESS;
do {
if (cnt++ >= max_cnt) {
result = isc__rwlock_lock(rwl, type);
isc__rwlock_lock(rwl, type);
break;
}
isc_rwlock_pause();
} while (isc_rwlock_trylock(rwl, type) != ISC_R_SUCCESS);
atomic_fetch_add_release(&rwl->spins, (cnt - spins) / 8);
return (result);
}
isc_result_t
@@ -563,7 +557,7 @@ isc_rwlock_downgrade(isc_rwlock_t *rwl) {
UNLOCK(&rwl->lock);
}
isc_result_t
void
isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
int32_t prev_cnt;
@@ -634,8 +628,6 @@ isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
#ifdef ISC_RWLOCK_TRACE
print_lock("postunlock", rwl, type);
#endif /* ifdef ISC_RWLOCK_TRACE */
return (ISC_R_SUCCESS);
}
#endif /* USE_PTHREAD_RWLOCK */

24
lib/isc/thread.c
View File

@@ -38,13 +38,6 @@
#define THREAD_MINSTACKSIZE (1024U * 1024)
#endif /* ifndef THREAD_MINSTACKSIZE */
#define _FATAL(r, f) \
{ \
char strbuf[ISC_STRERRORSIZE]; \
strerror_r(r, strbuf, sizeof(strbuf)); \
isc_error_fatal(__FILE__, __LINE__, f " failed: %s", strbuf); \
}
void
isc_thread_create(isc_threadfunc_t func, isc_threadarg_t arg,
isc_thread_t *thread) {
@@ -65,24 +58,18 @@ isc_thread_create(isc_threadfunc_t func, isc_threadarg_t arg,
#if defined(HAVE_PTHREAD_ATTR_GETSTACKSIZE) && \
defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE)
ret = pthread_attr_getstacksize(&attr, &stacksize);
if (ret != 0) {
_FATAL(ret, "pthread_attr_getstacksize()");
}
ERRNO_CHECK(pthread_attr_getstacksize, ret);
if (stacksize < THREAD_MINSTACKSIZE) {
ret = pthread_attr_setstacksize(&attr, THREAD_MINSTACKSIZE);
if (ret != 0) {
_FATAL(ret, "pthread_attr_setstacksize()");
}
ERRNO_CHECK(pthread_attr_setstacksize, ret);
}
#endif /* if defined(HAVE_PTHREAD_ATTR_GETSTACKSIZE) && \
* defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) */
ret = pthread_create(thread, &attr, isc__trampoline_run,
trampoline_arg);
if (ret != 0) {
_FATAL(ret, "pthread_create()");
}
ERRNO_CHECK(pthread_create, ret);
pthread_attr_destroy(&attr);
@@ -92,9 +79,8 @@ isc_thread_create(isc_threadfunc_t func, isc_threadarg_t arg,
void
isc_thread_join(isc_thread_t thread, isc_threadresult_t *result) {
int ret = pthread_join(thread, result);
if (ret != 0) {
_FATAL(ret, "pthread_join()");
}
ERRNO_CHECK(pthread_join, ret);
}
void

2
lib/isc/timer.c
View File

@@ -570,7 +570,7 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) {
/*
* Clean up.
*/
(void)isc_condition_destroy(&manager->wakeup);
isc_condition_destroy(&manager->wakeup);
isc_mutex_destroy(&manager->lock);
isc_heap_destroy(&manager->heap);
manager->magic = 0;

21
tests/isc/timer_test.c
View File

@@ -74,19 +74,12 @@ _teardown(void **state) {
static void
test_shutdown(void) {
isc_result_t result;
/*
* Signal shutdown processing complete.
*/
result = isc_mutex_lock(&mx);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_condition_signal(&cv);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_mutex_unlock(&mx);
assert_int_equal(result, ISC_R_SUCCESS);
LOCK(&mx);
SIGNAL(&cv);
UNLOCK(&mx);
}
static void
@@ -109,9 +102,9 @@ setup_test(isc_timertype_t timertype, isc_interval_t *interval,
result = isc_task_create(taskmgr, 0, &task, 0);
assert_int_equal(result, ISC_R_SUCCESS);
isc_mutex_lock(&lasttime_mx);
LOCK(&lasttime_mx);
result = isc_time_now(&lasttime);
isc_mutex_unlock(&lasttime_mx);
UNLOCK(&lasttime_mx);
assert_int_equal(result, ISC_R_SUCCESS);
isc_timer_create(timermgr, task, action, (void *)timertype, &timer);
@@ -122,7 +115,7 @@ setup_test(isc_timertype_t timertype, isc_interval_t *interval,
* Wait for shutdown processing to complete.
*/
while (atomic_load(&eventcnt) != nevents) {
result = isc_condition_wait(&cv, &mx);
WAIT(&cv, &mx);
assert_int_equal(result, ISC_R_SUCCESS);
}
@@ -132,7 +125,7 @@ setup_test(isc_timertype_t timertype, isc_interval_t *interval,
isc_task_detach(&task);
isc_mutex_destroy(&mx);
(void)isc_condition_destroy(&cv);
isc_condition_destroy(&cv);
}
static void