Get rid of ISC_MAGIC and ISC_MAGIC_VALID macros.

While pulling on that it turns out we can / need git rid of a isc_task
-> isc__task, isc_taskmgr -> isc__taskmgr, isc_timer -> isc__timer and
isc_socket -> isc__socket indirection.
OK millert

1 files changed, 38 insertions, 151 deletions

diff --git a/usr.bin/dig/lib/isc/timer.c b/usr.bin/dig/lib/isc/timer.c
index 20e472b99f9..b99db8147eb 100644
--- a/usr.bin/dig/lib/isc/timer.c
+++ b/usr.bin/dig/lib/isc/timer.c
@@ -14,14 +14,13 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-/* $Id: timer.c,v 1.18 2020/02/16 21:11:02 florian Exp $ */
+/* $Id: timer.c,v 1.19 2020/02/18 18:11:27 florian Exp $ */
 
 /*! \file */
 
 
 #include <stdlib.h>
 #include <isc/heap.h>
-#include <isc/magic.h>
 #include <isc/task.h>
 #include <isc/time.h>
 #include <isc/timer.h>
@@ -29,16 +28,12 @@
 
 #include "timer_p.h"
 
-#define TIMER_MAGIC			ISC_MAGIC('T', 'I', 'M', 'R')
-#define VALID_TIMER(t)			ISC_MAGIC_VALID(t, TIMER_MAGIC)
+typedef struct isc_timer isc_timer_t;
+typedef struct isc_timermgr isc_timermgr_t;
 
-typedef struct isc__timer isc__timer_t;
-typedef struct isc__timermgr isc__timermgr_t;
-
-struct isc__timer {
+struct isc_timer {
 	/*! Not locked. */
-	isc_timer_t			common;
-	isc__timermgr_t *		manager;
+	isc_timermgr_t *		manager;
 	/*! Locked by timer lock. */
 	unsigned int			references;
 	struct timespec			idle;
@@ -49,18 +44,14 @@ struct isc__timer {
 	void *				arg;
 	unsigned int			index;
 	struct timespec			due;
-	LINK(isc__timer_t)		link;
+	LINK(isc_timer_t)		link;
 };
 
-#define TIMER_MANAGER_MAGIC		ISC_MAGIC('T', 'I', 'M', 'M')
-#define VALID_MANAGER(m)		ISC_MAGIC_VALID(m, TIMER_MANAGER_MAGIC)
-
-struct isc__timermgr {
+struct isc_timermgr {
 	/* Not locked. */
-	isc_timermgr_t			common;
 	/* Locked by manager lock. */
 	isc_boolean_t			done;
-	LIST(isc__timer_t)		timers;
+	LIST(isc_timer_t)		timers;
 	unsigned int			nscheduled;
 	struct timespec			due;
 	unsigned int			refs;
@@ -73,33 +64,15 @@ struct isc__timermgr {
  * unit tests etc.
  */
 
-isc_result_t
-isc__timer_create(isc_timermgr_t *manager, const struct timespec *interval,
-		  isc_task_t *task, isc_taskaction_t action, void *arg,
-		  isc_timer_t **timerp);
-isc_result_t
-isc__timer_reset(isc_timer_t *timer, const struct timespec *interval,
-		 isc_boolean_t purge);
-void
-isc__timer_touch(isc_timer_t *timer);
-void
-isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp);
-void
-isc__timer_detach(isc_timer_t **timerp);
-isc_result_t
-isc__timermgr_create(isc_timermgr_t **managerp);
-void
-isc__timermgr_destroy(isc_timermgr_t **managerp);
-
 /*!
  * If the manager is supposed to be shared, there can be only one.
  */
-static isc__timermgr_t *timermgr = NULL;
+static isc_timermgr_t *timermgr = NULL;
 
 static inline isc_result_t
-schedule(isc__timer_t *timer, struct timespec *now, isc_boolean_t signal_ok) {
+schedule(isc_timer_t *timer, struct timespec *now, isc_boolean_t signal_ok) {
 	isc_result_t result;
-	isc__timermgr_t *manager;
+	isc_timermgr_t *manager;
 	struct timespec due;
 
 	/*!
@@ -152,8 +125,8 @@ schedule(isc__timer_t *timer, struct timespec *now, isc_boolean_t signal_ok) {
 }
 
 static inline void
-deschedule(isc__timer_t *timer) {
-	isc__timermgr_t *manager;
+deschedule(isc_timer_t *timer) {
+	isc_timermgr_t *manager;
 
 	/*
 	 * The caller must ensure locking.
@@ -169,8 +142,8 @@ deschedule(isc__timer_t *timer) {
 }
 
 static void
-destroy(isc__timer_t *timer) {
-	isc__timermgr_t *manager = timer->manager;
+destroy(isc_timer_t *timer) {
+	isc_timermgr_t *manager = timer->manager;
 
 	/*
 	 * The caller must ensure it is safe to destroy the timer.
@@ -185,18 +158,16 @@ destroy(isc__timer_t *timer) {
 	UNLINK(manager->timers, timer, link);
 
 	isc_task_detach(&timer->task);
-	timer->common.impmagic = 0;
-	timer->common.magic = 0;
 	free(timer);
 }
 
 isc_result_t
-isc__timer_create(isc_timermgr_t *manager0, const struct timespec *interval,
+isc_timer_create(isc_timermgr_t *manager0, const struct timespec *interval,
 		  isc_task_t *task, isc_taskaction_t action, void *arg,
 		  isc_timer_t **timerp)
 {
-	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
-	isc__timer_t *timer;
+	isc_timermgr_t *manager = (isc_timermgr_t *)manager0;
+	isc_timer_t *timer;
 	isc_result_t result;
 	struct timespec now;
 
@@ -208,7 +179,6 @@ isc__timer_create(isc_timermgr_t *manager0, const struct timespec *interval,
 	 * in 'timerp'.
 	 */
 
-	REQUIRE(VALID_MANAGER(manager));
 	REQUIRE(task != NULL);
 	REQUIRE(action != NULL);
 	REQUIRE(interval != NULL);
@@ -247,16 +217,12 @@ isc__timer_create(isc_timermgr_t *manager0, const struct timespec *interval,
 	DE_CONST(arg, timer->arg);
 	timer->index = 0;
 	ISC_LINK_INIT(timer, link);
-	timer->common.impmagic = TIMER_MAGIC;
-	timer->common.magic = ISCAPI_TIMER_MAGIC;
 
 	result = schedule(timer, &now, ISC_TRUE);
 	if (result == ISC_R_SUCCESS)
 		APPEND(manager->timers, timer, link);
 
 	if (result != ISC_R_SUCCESS) {
-		timer->common.impmagic = 0;
-		timer->common.magic = 0;
 		isc_task_detach(&timer->task);
 		free(timer);
 		return (result);
@@ -268,12 +234,11 @@ isc__timer_create(isc_timermgr_t *manager0, const struct timespec *interval,
 }
 
 isc_result_t
-isc__timer_reset(isc_timer_t *timer0, const struct timespec *interval,
+isc_timer_reset(isc_timer_t *timer, const struct timespec *interval,
 		 isc_boolean_t purge)
 {
-	isc__timer_t *timer = (isc__timer_t *)timer0;
 	struct timespec now;
-	isc__timermgr_t *manager;
+	isc_timermgr_t *manager;
 	isc_result_t result;
 
 	/*
@@ -282,9 +247,7 @@ isc__timer_reset(isc_timer_t *timer0, const struct timespec *interval,
 	 * are purged from its task's event queue.
 	 */
 
-	REQUIRE(VALID_TIMER(timer));
 	manager = timer->manager;
-	REQUIRE(VALID_MANAGER(manager));
 	REQUIRE(interval != NULL);
 	REQUIRE(timespecisset(interval));
 
@@ -312,39 +275,21 @@ isc__timer_reset(isc_timer_t *timer0, const struct timespec *interval,
 }
 
 void
-isc__timer_touch(isc_timer_t *timer0) {
-	isc__timer_t *timer = (isc__timer_t *)timer0;
+isc_timer_touch(isc_timer_t *timer) {
 	struct timespec now;
 
 	/*
 	 * Set the last-touched time of 'timer' to the current time.
 	 */
 
-	REQUIRE(VALID_TIMER(timer));
 
 	clock_gettime(CLOCK_REALTIME, &now);
 	timespecadd(&now, &timer->interval, &timer->idle);
 }
 
 void
-isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) {
-	isc__timer_t *timer = (isc__timer_t *)timer0;
-
-	/*
-	 * Attach *timerp to timer.
-	 */
-
-	REQUIRE(VALID_TIMER(timer));
-	REQUIRE(timerp != NULL && *timerp == NULL);
-
-	timer->references++;
-
-	*timerp = (isc_timer_t *)timer;
-}
-
-void
-isc__timer_detach(isc_timer_t **timerp) {
-	isc__timer_t *timer;
+isc_timer_detach(isc_timer_t **timerp) {
+	isc_timer_t *timer;
 	isc_boolean_t free_timer = ISC_FALSE;
 
 	/*
@@ -352,8 +297,7 @@ isc__timer_detach(isc_timer_t **timerp) {
 	 */
 
 	REQUIRE(timerp != NULL);
-	timer = (isc__timer_t *)*timerp;
-	REQUIRE(VALID_TIMER(timer));
+	timer = (isc_timer_t *)*timerp;
 
 	REQUIRE(timer->references > 0);
 	timer->references--;
@@ -367,11 +311,11 @@ isc__timer_detach(isc_timer_t **timerp) {
 }
 
 static void
-dispatch(isc__timermgr_t *manager, struct timespec *now) {
+dispatch(isc_timermgr_t *manager, struct timespec *now) {
 	isc_boolean_t done = ISC_FALSE, post_event, need_schedule;
 	isc_timerevent_t *event;
 	isc_eventtype_t type = 0;
-	isc__timer_t *timer;
+	isc_timer_t *timer;
 	isc_result_t result;
 	isc_boolean_t idle;
 
@@ -443,12 +387,10 @@ dispatch(isc__timermgr_t *manager, struct timespec *now) {
 
 static isc_boolean_t
 sooner(void *v1, void *v2) {
-	isc__timer_t *t1, *t2;
+	isc_timer_t *t1, *t2;
 
 	t1 = v1;
 	t2 = v2;
-	REQUIRE(VALID_TIMER(t1));
-	REQUIRE(VALID_TIMER(t2));
 
 	if (timespeccmp(&t1->due, &t2->due, <))
 		return (ISC_TRUE);
@@ -457,17 +399,16 @@ sooner(void *v1, void *v2) {
 
 static void
 set_index(void *what, unsigned int index) {
-	isc__timer_t *timer;
+	isc_timer_t *timer;
 
 	timer = what;
-	REQUIRE(VALID_TIMER(timer));
 
 	timer->index = index;
 }
 
 isc_result_t
-isc__timermgr_create(isc_timermgr_t **managerp) {
-	isc__timermgr_t *manager;
+isc_timermgr_create(isc_timermgr_t **managerp) {
+	isc_timermgr_t *manager;
 	isc_result_t result;
 
 	/*
@@ -486,8 +427,6 @@ isc__timermgr_create(isc_timermgr_t **managerp) {
 	if (manager == NULL)
 		return (ISC_R_NOMEMORY);
 
-	manager->common.impmagic = TIMER_MANAGER_MAGIC;
-	manager->common.magic = ISCAPI_TIMERMGR_MAGIC;
 	manager->done = ISC_FALSE;
 	INIT_LIST(manager->timers);
 	manager->nscheduled = 0;
@@ -508,16 +447,15 @@ isc__timermgr_create(isc_timermgr_t **managerp) {
 }
 
 void
-isc__timermgr_destroy(isc_timermgr_t **managerp) {
-	isc__timermgr_t *manager;
+isc_timermgr_destroy(isc_timermgr_t **managerp) {
+	isc_timermgr_t *manager;
 
 	/*
 	 * Destroy a timer manager.
 	 */
 
 	REQUIRE(managerp != NULL);
-	manager = (isc__timermgr_t *)*managerp;
-	REQUIRE(VALID_MANAGER(manager));
+	manager = (isc_timermgr_t *)*managerp;
 
 	manager->refs--;
 	if (manager->refs > 0) {
@@ -526,7 +464,7 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) {
 	}
 	timermgr = NULL;
 
-	isc__timermgr_dispatch((isc_timermgr_t *)manager);
+	isc_timermgr_dispatch((isc_timermgr_t *)manager);
 
 	REQUIRE(EMPTY(manager->timers));
 	manager->done = ISC_TRUE;
@@ -535,8 +473,6 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) {
 	 * Clean up.
 	 */
 	isc_heap_destroy(&manager->heap);
-	manager->common.impmagic = 0;
-	manager->common.magic = 0;
 	free(manager);
 
 	*managerp = NULL;
@@ -545,8 +481,8 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) {
 }
 
 isc_result_t
-isc__timermgr_nextevent(isc_timermgr_t *manager0, struct timespec *when) {
-	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
+isc_timermgr_nextevent(isc_timermgr_t *manager0, struct timespec *when) {
+	isc_timermgr_t *manager = (isc_timermgr_t *)manager0;
 
 	if (manager == NULL)
 		manager = timermgr;
@@ -557,8 +493,8 @@ isc__timermgr_nextevent(isc_timermgr_t *manager0, struct timespec *when) {
 }
 
 void
-isc__timermgr_dispatch(isc_timermgr_t *manager0) {
-	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
+isc_timermgr_dispatch(isc_timermgr_t *manager0) {
+	isc_timermgr_t *manager = (isc_timermgr_t *)manager0;
 	struct timespec now;
 
 	if (manager == NULL)
@@ -569,52 +505,3 @@ isc__timermgr_dispatch(isc_timermgr_t *manager0) {
 	dispatch(manager, &now);
 }
 
-isc_result_t
-isc_timermgr_create(isc_timermgr_t **managerp) {
-	return (isc__timermgr_create(managerp));
-}
-
-void
-isc_timermgr_destroy(isc_timermgr_t **managerp) {
-	REQUIRE(*managerp != NULL && ISCAPI_TIMERMGR_VALID(*managerp));
-
-	isc__timermgr_destroy(managerp);
-
-	ENSURE(*managerp == NULL);
-}
-
-isc_result_t
-isc_timer_create(isc_timermgr_t *manager, const struct timespec *interval,
-		 isc_task_t *task, isc_taskaction_t action, void *arg,
-		 isc_timer_t **timerp)
-{
-	REQUIRE(ISCAPI_TIMERMGR_VALID(manager));
-
-	return (isc__timer_create(manager, interval,
-				  task, action, arg, timerp));
-}
-
-void
-isc_timer_detach(isc_timer_t **timerp) {
-	REQUIRE(timerp != NULL && ISCAPI_TIMER_VALID(*timerp));
-
-	isc__timer_detach(timerp);
-
-	ENSURE(*timerp == NULL);
-}
-
-isc_result_t
-isc_timer_reset(isc_timer_t *timer, const struct timespec *interval,
-		isc_boolean_t purge)
-{
-	REQUIRE(ISCAPI_TIMER_VALID(timer));
-
-	return (isc__timer_reset(timer, interval, purge));
-}
-
-void
-isc_timer_touch(isc_timer_t *timer) {
-	REQUIRE(ISCAPI_TIMER_VALID(timer));
-
-	isc__timer_touch(timer);
-}