#define ISC_APPEVENT_SHUTDOWN (ISC_EVENTCLASS_APP + 1)
#define ISC_APPEVENT_LASTEVENT (ISC_EVENTCLASS_APP + 65535)
-/*%
- * This structure is actually just the common prefix of an application context
- * implementation's version of an isc_appctx_t.
- * \brief
- * Direct use of this structure by clients is forbidden. app implementations
- * may change the structure. 'magic' must be ISCAPI_APPCTX_MAGIC for any
- * of the isc_app_ routines to work. app implementations must maintain
- * all app context invariants.
- */
-struct isc_appctx;
-
ISC_LANG_BEGINDECLS
isc_result_t
#define ISC_SOCKFLAG_NORETRY 0x00000002 /*%< drop failed UDP sends */
/*@}*/
-/*%
- * This structure is actually just the common prefix of a socket manager
- * object implementation's version of an isc_socketmgr_t.
- * \brief
- * Direct use of this structure by clients is forbidden. socket implementations
- * may change the structure. 'magic' must be ISCAPI_SOCKETMGR_MAGIC for any
- * of the isc_socket_ routines to work. socket implementations must maintain
- * all socket invariants.
- * In effect, this definition is used only for non-BIND9 version ("export")
- * of the library, and the export version does not work for win32. So, to avoid
- * the definition conflict with win32/socket.c, we enable this definition only
- * for non-Win32 (i.e. Unix) platforms.
- */
-#ifndef WIN32
-struct isc_socketmgr {
- unsigned int impmagic;
- unsigned int magic;
-};
-#endif /* ifndef WIN32 */
-
-#define ISCAPI_SOCKETMGR_MAGIC ISC_MAGIC('A', 's', 'm', 'g')
-#define ISCAPI_SOCKETMGR_VALID(m) \
- ((m) != NULL && (m)->magic == ISCAPI_SOCKETMGR_MAGIC)
-
-/*%
- * This is the common prefix of a socket object. The same note as
- * that for the socketmgr structure applies.
- */
-#ifndef WIN32
-struct isc_socket {
- unsigned int impmagic;
- unsigned int magic;
-};
-#endif /* ifndef WIN32 */
-
-#define ISCAPI_SOCKET_MAGIC ISC_MAGIC('A', 's', 'c', 't')
-#define ISCAPI_SOCKET_VALID(s) \
- ((s) != NULL && (s)->magic == ISCAPI_SOCKET_MAGIC)
-
/***
*** Socket and Socket Manager Functions
***
isc_taskmgrmode_privileged
} isc_taskmgrmode_t;
-/*%
- * This structure is actually just the common prefix of a task manager
- * object implementation's version of an isc_taskmgr_t.
- * \brief
- * Direct use of this structure by clients is forbidden. task implementations
- * may change the structure. 'magic' must be ISCAPI_TASKMGR_MAGIC for any
- * of the isc_task_ routines to work. task implementations must maintain
- * all task invariants.
- */
-struct isc_taskmgr {
- unsigned int impmagic;
- unsigned int magic;
-};
-
-#define ISCAPI_TASKMGR_MAGIC ISC_MAGIC('A', 't', 'm', 'g')
-#define ISCAPI_TASKMGR_VALID(m) \
- ((m) != NULL && (m)->magic == ISCAPI_TASKMGR_MAGIC)
-
-/*%
- * This is the common prefix of a task object. The same note as
- * that for the taskmgr structure applies.
- */
-struct isc_task {
- unsigned int impmagic;
- unsigned int magic;
-};
-
-#define ISCAPI_TASK_MAGIC ISC_MAGIC('A', 't', 's', 't')
-#define ISCAPI_TASK_VALID(s) ((s) != NULL && (s)->magic == ISCAPI_TASK_MAGIC)
-
isc_result_t
isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
isc_task_t **taskp);
#define ISC_TIMEREVENT_LIFE (ISC_EVENTCLASS_TIMER + 3)
#define ISC_TIMEREVENT_LASTEVENT (ISC_EVENTCLASS_TIMER + 65535)
-/*%
- * This structure is actually just the common prefix of a timer manager
- * object implementation's version of an isc_timermgr_t.
- * \brief
- * Direct use of this structure by clients is forbidden. timer implementations
- * may change the structure. 'magic' must be ISCAPI_TIMERMGR_MAGIC for any
- * of the isc_timer_ routines to work. timer implementations must maintain
- * all timer invariants.
- */
-struct isc_timermgr {
- unsigned int impmagic;
- unsigned int magic;
-};
-
-#define ISCAPI_TIMERMGR_MAGIC ISC_MAGIC('A', 't', 'm', 'g')
-#define ISCAPI_TIMERMGR_VALID(m) \
- ((m) != NULL && (m)->magic == ISCAPI_TIMERMGR_MAGIC)
-
-/*%
- * This is the common prefix of a timer object. The same note as
- * that for the timermgr structure applies.
- */
-struct isc_timer {
- unsigned int impmagic;
- unsigned int magic;
-};
-
-#define ISCAPI_TIMER_MAGIC ISC_MAGIC('A', 't', 'm', 'r')
-#define ISCAPI_TIMER_VALID(s) ((s) != NULL && (s)->magic == ISCAPI_TIMER_MAGIC)
-
/***
*** Timer and Timer Manager Functions
***
#define TASK_MAGIC ISC_MAGIC('T', 'A', 'S', 'K')
#define VALID_TASK(t) ISC_MAGIC_VALID(t, TASK_MAGIC)
-typedef struct isc__task isc__task_t;
-typedef struct isc__taskmgr isc__taskmgr_t;
typedef struct isc__taskqueue isc__taskqueue_t;
-struct isc__task {
+struct isc_task {
/* Not locked. */
- isc_task_t common;
- isc__taskmgr_t *manager;
+ unsigned int magic;
+ isc_taskmgr_t *manager;
isc_mutex_t lock;
/* Locked by task lock. */
task_state_t state;
/* Protected by atomics */
atomic_uint_fast32_t flags;
/* Locked by task manager lock. */
- LINK(isc__task_t) link;
- LINK(isc__task_t) ready_link;
- LINK(isc__task_t) ready_priority_link;
+ LINK(isc_task_t) link;
+ LINK(isc_task_t) ready_link;
+ LINK(isc_task_t) ready_priority_link;
};
#define TASK_F_SHUTTINGDOWN 0x01
#define TASK_MANAGER_MAGIC ISC_MAGIC('T', 'S', 'K', 'M')
#define VALID_MANAGER(m) ISC_MAGIC_VALID(m, TASK_MANAGER_MAGIC)
-typedef ISC_LIST(isc__task_t) isc__tasklist_t;
+typedef ISC_LIST(isc_task_t) isc__tasklist_t;
struct isc__taskqueue {
/* Everything locked by lock */
isc_condition_t work_available;
isc_thread_t thread;
unsigned int threadid;
- isc__taskmgr_t *manager;
+ isc_taskmgr_t *manager;
};
-struct isc__taskmgr {
+struct isc_taskmgr {
/* Not locked. */
- isc_taskmgr_t common;
+ unsigned int magic;
isc_mem_t *mctx;
isc_mutex_t lock;
isc_mutex_t halt_lock;
/* Locked by task manager lock. */
unsigned int default_quantum;
- LIST(isc__task_t) tasks;
+ LIST(isc_task_t) tasks;
atomic_uint_fast32_t mode;
atomic_bool pause_req;
atomic_bool exclusive_req;
* will try to acquire it.
*/
isc_mutex_t excl_lock;
- isc__task_t *excl;
+ isc_task_t *excl;
};
void
*/
bool
-isc_task_purgeevent(isc_task_t *task0, isc_event_t *event);
+isc_task_purgeevent(isc_task_t *task, isc_event_t *event);
void
-isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0);
+isc_taskmgr_setexcltask(isc_taskmgr_t *mgr, isc_task_t *task);
isc_result_t
-isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp);
+isc_taskmgr_excltask(isc_taskmgr_t *mgr, isc_task_t **taskp);
static inline bool
-empty_readyq(isc__taskmgr_t *manager, int c);
+empty_readyq(isc_taskmgr_t *manager, int c);
-static inline isc__task_t *
-pop_readyq(isc__taskmgr_t *manager, int c);
+static inline isc_task_t *
+pop_readyq(isc_taskmgr_t *manager, int c);
static inline void
-push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c);
+push_readyq(isc_taskmgr_t *manager, isc_task_t *task, int c);
static inline void
-wake_all_queues(isc__taskmgr_t *manager);
+wake_all_queues(isc_taskmgr_t *manager);
/***
*** Tasks.
***/
static inline void
-wake_all_queues(isc__taskmgr_t *manager) {
+wake_all_queues(isc_taskmgr_t *manager) {
for (unsigned int i = 0; i < manager->workers; i++) {
LOCK(&manager->queues[i].lock);
BROADCAST(&manager->queues[i].work_available);
}
static void
-task_finished(isc__task_t *task) {
- isc__taskmgr_t *manager = task->manager;
+task_finished(isc_task_t *task) {
+ isc_taskmgr_t *manager = task->manager;
REQUIRE(EMPTY(task->events));
REQUIRE(task->nevents == 0);
REQUIRE(EMPTY(task->on_shutdown));
wake_all_queues(manager);
}
isc_mutex_destroy(&task->lock);
- task->common.impmagic = 0;
- task->common.magic = 0;
+ task->magic = 0;
isc_mem_put(manager->mctx, task, sizeof(*task));
}
isc_result_t
isc_task_create_bound(isc_taskmgr_t *manager0, unsigned int quantum,
isc_task_t **taskp, int threadid) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
- isc__task_t *task;
+ isc_taskmgr_t *manager = (isc_taskmgr_t *)manager0;
+ isc_task_t *task;
bool exiting;
REQUIRE(VALID_MANAGER(manager));
return (ISC_R_SHUTTINGDOWN);
}
- task->common.magic = ISCAPI_TASK_MAGIC;
- task->common.impmagic = TASK_MAGIC;
- *taskp = (isc_task_t *)task;
+ task->magic = TASK_MAGIC;
+ *taskp = task;
return (ISC_R_SUCCESS);
}
void
-isc_task_attach(isc_task_t *source0, isc_task_t **targetp) {
- isc__task_t *source = (isc__task_t *)source0;
-
+isc_task_attach(isc_task_t *source, isc_task_t **targetp) {
/*
* Attach *targetp to source.
*/
isc_refcount_increment(&source->references);
- *targetp = (isc_task_t *)source;
+ *targetp = source;
}
static inline bool
-task_shutdown(isc__task_t *task) {
+task_shutdown(isc_task_t *task) {
bool was_idle = false;
isc_event_t *event, *prev;
* Caller must NOT hold queue lock.
*/
static inline void
-task_ready(isc__task_t *task) {
- isc__taskmgr_t *manager = task->manager;
- bool has_privilege = isc_task_privilege((isc_task_t *)task);
+task_ready(isc_task_t *task) {
+ isc_taskmgr_t *manager = task->manager;
+ bool has_privilege = isc_task_privilege(task);
REQUIRE(VALID_MANAGER(manager));
}
static inline bool
-task_detach(isc__task_t *task) {
+task_detach(isc_task_t *task) {
/*
* Caller must be holding the task lock.
*/
void
isc_task_detach(isc_task_t **taskp) {
- isc__task_t *task;
+ isc_task_t *task;
bool was_idle;
/*
*/
REQUIRE(taskp != NULL);
- task = (isc__task_t *)*taskp;
+ task = *taskp;
REQUIRE(VALID_TASK(task));
XTRACE("isc_task_detach");
}
static inline bool
-task_send(isc__task_t *task, isc_event_t **eventp, int c) {
+task_send(isc_task_t *task, isc_event_t **eventp, int c) {
bool was_idle = false;
isc_event_t *event;
}
void
-isc_task_send(isc_task_t *task0, isc_event_t **eventp) {
- isc_task_sendto(task0, eventp, -1);
+isc_task_send(isc_task_t *task, isc_event_t **eventp) {
+ isc_task_sendto(task, eventp, -1);
}
void
}
void
-isc_task_sendto(isc_task_t *task0, isc_event_t **eventp, int c) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_sendto(isc_task_t *task, isc_event_t **eventp, int c) {
bool was_idle;
/*
void
isc_task_sendtoanddetach(isc_task_t **taskp, isc_event_t **eventp, int c) {
bool idle1, idle2;
- isc__task_t *task;
+ isc_task_t *task;
/*
* Send '*event' to '*taskp' and then detach '*taskp' from its
*/
REQUIRE(taskp != NULL);
- task = (isc__task_t *)*taskp;
+ task = *taskp;
REQUIRE(VALID_TASK(task));
XTRACE("isc_task_sendanddetach");
#define PURGE_OK(event) (((event)->ev_attributes & ISC_EVENTATTR_NOPURGE) == 0)
static unsigned int
-dequeue_events(isc__task_t *task, void *sender, isc_eventtype_t first,
+dequeue_events(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag, isc_eventlist_t *events,
bool purging) {
isc_event_t *event, *next_event;
}
unsigned int
-isc_task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
+isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag) {
- isc__task_t *task = (isc__task_t *)task0;
unsigned int count;
isc_eventlist_t events;
isc_event_t *event, *next_event;
}
bool
-isc_task_purgeevent(isc_task_t *task0, isc_event_t *event) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_purgeevent(isc_task_t *task, isc_event_t *event) {
isc_event_t *curr_event, *next_event;
/*
XTRACE("isc_task_unsendrange");
- return (dequeue_events((isc__task_t *)task, sender, first, last, tag,
+ return (dequeue_events((isc_task_t *)task, sender, first, last, tag,
events, false));
}
XTRACE("isc_task_unsend");
- return (dequeue_events((isc__task_t *)task, sender, type, type, tag,
+ return (dequeue_events((isc_task_t *)task, sender, type, type, tag,
events, false));
}
isc_result_t
-isc_task_onshutdown(isc_task_t *task0, isc_taskaction_t action, void *arg) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg) {
bool disallowed = false;
isc_result_t result = ISC_R_SUCCESS;
isc_event_t *event;
}
void
-isc_task_shutdown(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_shutdown(isc_task_t *task) {
bool was_idle;
/*
}
void
-isc_task_setname(isc_task_t *task0, const char *name, void *tag) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_setname(isc_task_t *task, const char *name, void *tag) {
/*
* Name 'task'.
*/
}
const char *
-isc_task_getname(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_getname(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
return (task->name);
}
void *
-isc_task_gettag(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_gettag(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
return (task->tag);
}
void
-isc_task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_getcurrenttime(isc_task_t *task, isc_stdtime_t *t) {
REQUIRE(VALID_TASK(task));
REQUIRE(t != NULL);
}
void
-isc_task_getcurrenttimex(isc_task_t *task0, isc_time_t *t) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_getcurrenttimex(isc_task_t *task, isc_time_t *t) {
REQUIRE(VALID_TASK(task));
REQUIRE(t != NULL);
* Caller must hold the task manager lock.
*/
static inline bool
-empty_readyq(isc__taskmgr_t *manager, int c) {
+empty_readyq(isc_taskmgr_t *manager, int c) {
isc__tasklist_t queue;
if (atomic_load_relaxed(&manager->mode) == isc_taskmgrmode_normal) {
*
* Caller must hold the task manager lock.
*/
-static inline isc__task_t *
-pop_readyq(isc__taskmgr_t *manager, int c) {
- isc__task_t *task;
+static inline isc_task_t *
+pop_readyq(isc_taskmgr_t *manager, int c) {
+ isc_task_t *task;
if (atomic_load_relaxed(&manager->mode) == isc_taskmgrmode_normal) {
task = HEAD(manager->queues[c].ready_tasks);
* Caller must hold the task queue lock.
*/
static inline void
-push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c) {
+push_readyq(isc_taskmgr_t *manager, isc_task_t *task, int c) {
if (ISC_LINK_LINKED(task, ready_link)) {
return;
}
}
static void
-dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
- isc__task_t *task;
+dispatch(isc_taskmgr_t *manager, unsigned int threadid) {
+ isc_task_t *task;
REQUIRE(VALID_MANAGER(manager));
#endif /* ifdef _WIN32 */
run(void *queuep) {
isc__taskqueue_t *tq = queuep;
- isc__taskmgr_t *manager = tq->manager;
+ isc_taskmgr_t *manager = tq->manager;
int threadid = tq->threadid;
isc_thread_setaffinity(threadid);
}
static void
-manager_free(isc__taskmgr_t *manager) {
+manager_free(isc_taskmgr_t *manager) {
for (unsigned int i = 0; i < manager->workers; i++) {
isc_mutex_destroy(&manager->queues[i].lock);
isc_condition_destroy(&manager->queues[i].work_available);
isc_condition_destroy(&manager->halt_cond);
isc_mem_put(manager->mctx, manager->queues,
manager->workers * sizeof(isc__taskqueue_t));
- manager->common.impmagic = 0;
- manager->common.magic = 0;
+ manager->magic = 0;
isc_mem_putanddetach(&manager->mctx, manager, sizeof(*manager));
}
unsigned int default_quantum, isc_nm_t *nm,
isc_taskmgr_t **managerp) {
unsigned int i;
- isc__taskmgr_t *manager;
+ isc_taskmgr_t *manager;
/*
* Create a new task manager.
REQUIRE(managerp != NULL && *managerp == NULL);
manager = isc_mem_get(mctx, sizeof(*manager));
- *manager = (isc__taskmgr_t){ .common.impmagic = TASK_MANAGER_MAGIC,
- .common.magic = ISCAPI_TASKMGR_MAGIC };
+ *manager = (isc_taskmgr_t){ .magic = TASK_MANAGER_MAGIC };
atomic_store(&manager->mode, isc_taskmgrmode_normal);
isc_mutex_init(&manager->lock);
void
isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
- isc__taskmgr_t *manager;
- isc__task_t *task;
+ isc_taskmgr_t *manager;
+ isc_task_t *task;
unsigned int i;
bool exiting;
*/
REQUIRE(managerp != NULL);
- manager = (isc__taskmgr_t *)*managerp;
+ manager = (isc_taskmgr_t *)*managerp;
REQUIRE(VALID_MANAGER(manager));
XTHREADTRACE("isc_taskmgr_destroy");
void
isc_taskmgr_setprivilegedmode(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
+ isc_taskmgr_t *manager = (isc_taskmgr_t *)manager0;
atomic_store(&manager->mode, isc_taskmgrmode_privileged);
}
isc_taskmgrmode_t
isc_taskmgr_mode(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
+ isc_taskmgr_t *manager = (isc_taskmgr_t *)manager0;
return (atomic_load(&manager->mode));
}
void
isc__taskmgr_pause(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
+ isc_taskmgr_t *manager = (isc_taskmgr_t *)manager0;
LOCK(&manager->halt_lock);
while (atomic_load_relaxed(&manager->exclusive_req) ||
void
isc__taskmgr_resume(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
+ isc_taskmgr_t *manager = (isc_taskmgr_t *)manager0;
LOCK(&manager->halt_lock);
if (atomic_load(&manager->pause_req)) {
atomic_store(&manager->pause_req, false);
}
void
-isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0) {
- isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_taskmgr_setexcltask(isc_taskmgr_t *mgr, isc_task_t *task) {
REQUIRE(VALID_MANAGER(mgr));
REQUIRE(VALID_TASK(task));
LOCK(&mgr->excl_lock);
if (mgr->excl != NULL) {
isc_task_detach((isc_task_t **)&mgr->excl);
}
- isc_task_attach(task0, (isc_task_t **)&mgr->excl);
+ isc_task_attach(task, (isc_task_t **)&mgr->excl);
UNLOCK(&mgr->excl_lock);
}
isc_result_t
-isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) {
- isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
+isc_taskmgr_excltask(isc_taskmgr_t *mgr, isc_task_t **taskp) {
isc_result_t result = ISC_R_SUCCESS;
REQUIRE(VALID_MANAGER(mgr));
}
isc_result_t
-isc_task_beginexclusive(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
- isc__taskmgr_t *manager;
+isc_task_beginexclusive(isc_task_t *task) {
+ isc_taskmgr_t *manager;
REQUIRE(VALID_TASK(task));
}
void
-isc_task_endexclusive(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
- isc__taskmgr_t *manager;
+isc_task_endexclusive(isc_task_t *task) {
+ isc_taskmgr_t *manager;
REQUIRE(VALID_TASK(task));
REQUIRE(task->state == task_state_running);
}
void
-isc_task_pause(isc_task_t *task0) {
- REQUIRE(ISCAPI_TASK_VALID(task0));
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_pause(isc_task_t *task) {
+ REQUIRE(VALID_TASK(task));
LOCK(&task->lock);
task->pause_cnt++;
}
void
-isc_task_unpause(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_unpause(isc_task_t *task) {
bool was_idle = false;
- REQUIRE(ISCAPI_TASK_VALID(task0));
+ REQUIRE(VALID_TASK(task));
LOCK(&task->lock);
task->pause_cnt--;
}
void
-isc_task_setprivilege(isc_task_t *task0, bool priv) {
- REQUIRE(ISCAPI_TASK_VALID(task0));
- isc__task_t *task = (isc__task_t *)task0;
- isc__taskmgr_t *manager = task->manager;
+isc_task_setprivilege(isc_task_t *task, bool priv) {
+ REQUIRE(VALID_TASK(task));
+ isc_taskmgr_t *manager = task->manager;
uint_fast32_t oldflags, newflags;
oldflags = atomic_load_acquire(&task->flags);
}
bool
-isc_task_privilege(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_privilege(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
return (TASK_PRIVILEGED(task));
bool
isc_task_exiting(isc_task_t *t) {
- isc__task_t *task = (isc__task_t *)t;
+ isc_task_t *task = (isc_task_t *)t;
REQUIRE(VALID_TASK(task));
return (TASK_SHUTTINGDOWN(task));
goto error; \
} while (0)
int
-isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, void *writer0) {
- isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
- isc__task_t *task = NULL;
+isc_taskmgr_renderxml(isc_taskmgr_t *mgr, void *writer0) {
+ isc_task_t *task = NULL;
int xmlrc;
xmlTextWriterPtr writer = (xmlTextWriterPtr)writer0;
} while (0)
isc_result_t
-isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, void *tasks0) {
+isc_taskmgr_renderjson(isc_taskmgr_t *mgr, void *tasks0) {
isc_result_t result = ISC_R_SUCCESS;
- isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
- isc__task_t *task = NULL;
+ isc_task_t *task = NULL;
json_object *obj = NULL, *array = NULL, *taskobj = NULL;
json_object *tasks = (json_object *)tasks0;
/* two tasks in pool; make sure we can access them more than twice */
isc_taskpool_gettask(pool, &task1);
- assert_true(ISCAPI_TASK_VALID(task1));
+ assert_non_null(task1);
isc_taskpool_gettask(pool, &task2);
- assert_true(ISCAPI_TASK_VALID(task2));
+ assert_non_null(task2);
isc_taskpool_gettask(pool, &task3);
- assert_true(ISCAPI_TASK_VALID(task3));
+ assert_non_null(task3);
isc_task_destroy(&task1);
isc_task_destroy(&task2);
isc_taskpool_gettask(pool, &task2);
isc_taskpool_gettask(pool, &task3);
- assert_true(ISCAPI_TASK_VALID(task1));
- assert_true(ISCAPI_TASK_VALID(task2));
- assert_true(ISCAPI_TASK_VALID(task3));
+ assert_non_null(task1);
+ assert_non_null(task2);
+ assert_non_null(task3);
assert_true(isc_task_privilege(task1));
assert_true(isc_task_privilege(task2));
#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;
-
-struct isc__timer {
+struct isc_timer {
/*! Not locked. */
- isc_timer_t common;
- isc__timermgr_t *manager;
+ unsigned int magic;
+ isc_timermgr_t *manager;
isc_mutex_t lock;
isc_refcount_t references;
/*! Locked by timer lock. */
void *arg;
unsigned int index;
isc_time_t 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;
+ unsigned int magic;
isc_mem_t *mctx;
isc_mutex_t lock;
/* Locked by manager lock. */
bool done;
- LIST(isc__timer_t) timers;
+ LIST(isc_timer_t) timers;
unsigned int nscheduled;
isc_time_t due;
isc_condition_t wakeup;
isc_timermgr_poke(isc_timermgr_t *manager0);
static inline isc_result_t
-schedule(isc__timer_t *timer, isc_time_t *now, bool signal_ok) {
+schedule(isc_timer_t *timer, isc_time_t *now, bool signal_ok) {
isc_result_t result;
- isc__timermgr_t *manager;
+ isc_timermgr_t *manager;
isc_time_t due;
int cmp;
}
static inline void
-deschedule(isc__timer_t *timer) {
+deschedule(isc_timer_t *timer) {
bool need_wakeup = false;
- isc__timermgr_t *manager;
+ isc_timermgr_t *manager;
/*
* The caller must ensure locking.
}
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.
isc_task_detach(&timer->task);
isc_mutex_destroy(&timer->lock);
- timer->common.impmagic = 0;
- timer->common.magic = 0;
+ timer->magic = 0;
isc_mem_put(manager->mctx, timer, sizeof(*timer));
}
isc_result_t
-isc_timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
+isc_timer_create(isc_timermgr_t *manager, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_timer_t **timerp) {
- REQUIRE(VALID_MANAGER(manager0));
+ REQUIRE(VALID_MANAGER(manager));
REQUIRE(task != NULL);
REQUIRE(action != NULL);
- isc__timermgr_t *manager;
- isc__timer_t *timer;
+ isc_timer_t *timer;
isc_result_t result;
isc_time_t now;
* called with 'arg' as the arg value. The new timer is returned
* in 'timerp'.
*/
- manager = (isc__timermgr_t *)manager0;
if (expires == NULL) {
expires = isc_time_epoch;
}
timer->index = 0;
isc_mutex_init(&timer->lock);
ISC_LINK_INIT(timer, link);
- timer->common.impmagic = TIMER_MAGIC;
- timer->common.magic = ISCAPI_TIMER_MAGIC;
+ timer->magic = TIMER_MAGIC;
LOCK(&manager->lock);
result = ISC_R_SUCCESS;
}
if (result == ISC_R_SUCCESS) {
- *timerp = (isc_timer_t *)timer;
+ *timerp = timer;
APPEND(manager->timers, timer, link);
}
UNLOCK(&manager->lock);
if (result != ISC_R_SUCCESS) {
- timer->common.impmagic = 0;
- timer->common.magic = 0;
+ timer->magic = 0;
isc_mutex_destroy(&timer->lock);
isc_task_detach(&timer->task);
isc_mem_put(manager->mctx, timer, sizeof(*timer));
}
isc_result_t
-isc_timer_reset(isc_timer_t *timer0, isc_timertype_t type,
+isc_timer_reset(isc_timer_t *timer, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
bool purge) {
- isc__timer_t *timer;
isc_time_t now;
- isc__timermgr_t *manager;
+ isc_timermgr_t *manager;
isc_result_t result;
/*
* are purged from its task's event queue.
*/
- REQUIRE(VALID_TIMER(timer0));
- timer = (isc__timer_t *)timer0;
+ REQUIRE(VALID_TIMER(timer));
manager = timer->manager;
REQUIRE(VALID_MANAGER(manager));
}
isc_timertype_t
-isc_timer_gettype(isc_timer_t *timer0) {
- isc__timer_t *timer;
+isc_timer_gettype(isc_timer_t *timer) {
isc_timertype_t t;
- REQUIRE(VALID_TIMER(timer0));
- timer = (isc__timer_t *)timer0;
+ REQUIRE(VALID_TIMER(timer));
LOCK(&timer->lock);
t = timer->type;
}
isc_result_t
-isc_timer_touch(isc_timer_t *timer0) {
- isc__timer_t *timer;
+isc_timer_touch(isc_timer_t *timer) {
isc_result_t result;
isc_time_t now;
* Set the last-touched time of 'timer' to the current time.
*/
- REQUIRE(VALID_TIMER(timer0));
- timer = (isc__timer_t *)timer0;
+ REQUIRE(VALID_TIMER(timer));
LOCK(&timer->lock);
}
void
-isc_timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) {
- isc__timer_t *timer;
-
+isc_timer_attach(isc_timer_t *timer, isc_timer_t **timerp) {
/*
* Attach *timerp to timer.
*/
- REQUIRE(VALID_TIMER(timer0));
- timer = (isc__timer_t *)timer0;
+ REQUIRE(VALID_TIMER(timer));
REQUIRE(timerp != NULL && *timerp == NULL);
isc_refcount_increment(&timer->references);
- *timerp = (isc_timer_t *)timer;
+ *timerp = timer;
}
void
isc_timer_detach(isc_timer_t **timerp) {
- isc__timer_t *timer;
+ isc_timer_t *timer;
/*
* Detach *timerp from its timer.
*/
REQUIRE(timerp != NULL);
- timer = (isc__timer_t *)*timerp;
+ timer = *timerp;
REQUIRE(VALID_TIMER(timer));
if (isc_refcount_decrement(&timer->references) == 1) {
}
static void
-dispatch(isc__timermgr_t *manager, isc_time_t *now) {
+dispatch(isc_timermgr_t *manager, isc_time_t *now) {
bool done = 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;
bool idle;
WINAPI
#endif /* ifdef _WIN32 */
run(void *uap) {
- isc__timermgr_t *manager = uap;
+ isc_timermgr_t *manager = uap;
isc_time_t now;
isc_result_t result;
static bool
sooner(void *v1, void *v2) {
- isc__timer_t *t1, *t2;
+ isc_timer_t *t1, *t2;
t1 = v1;
t2 = v2;
static void
set_index(void *what, unsigned int index) {
- isc__timer_t *timer;
+ isc_timer_t *timer;
REQUIRE(VALID_TIMER(what));
timer = what;
isc_result_t
isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
- isc__timermgr_t *manager;
+ isc_timermgr_t *manager;
isc_result_t result;
/*
manager = isc_mem_get(mctx, sizeof(*manager));
- manager->common.impmagic = TIMER_MANAGER_MAGIC;
- manager->common.magic = ISCAPI_TIMERMGR_MAGIC;
+ manager->magic = TIMER_MANAGER_MAGIC;
manager->mctx = NULL;
manager->done = false;
INIT_LIST(manager->timers);
isc_thread_create(run, manager, &manager->thread);
isc_thread_setname(manager->thread, "isc-timer");
- *managerp = (isc_timermgr_t *)manager;
+ *managerp = manager;
return (ISC_R_SUCCESS);
}
void
-isc_timermgr_poke(isc_timermgr_t *manager0) {
- isc__timermgr_t *manager;
-
- REQUIRE(VALID_MANAGER(manager0));
- manager = (isc__timermgr_t *)manager0;
+isc_timermgr_poke(isc_timermgr_t *manager) {
+ REQUIRE(VALID_MANAGER(manager));
SIGNAL(&manager->wakeup);
}
void
isc_timermgr_destroy(isc_timermgr_t **managerp) {
- isc__timermgr_t *manager;
+ isc_timermgr_t *manager;
/*
* Destroy a timer manager.
*/
REQUIRE(managerp != NULL);
- manager = (isc__timermgr_t *)*managerp;
+ manager = *managerp;
REQUIRE(VALID_MANAGER(manager));
LOCK(&manager->lock);
(void)isc_condition_destroy(&manager->wakeup);
isc_mutex_destroy(&manager->lock);
isc_heap_destroy(&manager->heap);
- manager->common.impmagic = 0;
- manager->common.magic = 0;
+ manager->magic = 0;
isc_mem_putanddetach(&manager->mctx, manager, sizeof(*manager));
*managerp = NULL;
*/
#define NRETRIES 10
-typedef struct isc__socket isc__socket_t;
-typedef struct isc__socketmgr isc__socketmgr_t;
typedef struct isc__socketthread isc__socketthread_t;
-#define NEWCONNSOCK(ev) ((isc__socket_t *)(ev)->newsocket)
+#define NEWCONNSOCK(ev) ((ev)->newsocket)
-struct isc__socket {
+struct isc_socket {
/* Not locked. */
- isc_socket_t common;
- isc__socketmgr_t *manager;
+ unsigned int magic;
+ isc_socketmgr_t *manager;
isc_mutex_t lock;
isc_sockettype_t type;
const isc_statscounter_t *statsindex;
isc_refcount_t references;
/* Locked by socket lock. */
- ISC_LINK(isc__socket_t) link;
+ ISC_LINK(isc_socket_t) link;
int fd;
int pf;
int threadid;
#define SOCKET_MANAGER_MAGIC ISC_MAGIC('I', 'O', 'm', 'g')
#define VALID_MANAGER(m) ISC_MAGIC_VALID(m, SOCKET_MANAGER_MAGIC)
-struct isc__socketmgr {
+struct isc_socketmgr {
/* Not locked. */
- isc_socketmgr_t common;
+ unsigned int magic;
isc_mem_t *mctx;
isc_mutex_t lock;
isc_stats_t *stats;
isc__socketthread_t *threads;
unsigned int maxsocks;
/* Locked by manager lock. */
- ISC_LIST(isc__socket_t) socklist;
+ ISC_LIST(isc_socket_t) socklist;
int reserved; /* unlocked */
isc_condition_t shutdown_ok;
size_t maxudp;
};
struct isc__socketthread {
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
int threadid;
isc_thread_t thread;
int pipe_fds[2];
isc_mutex_t *fdlock;
/* Locked by fdlock. */
- isc__socket_t **fds;
+ isc_socket_t **fds;
int *fdstate;
#ifdef USE_KQUEUE
int kqueue_fd;
socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
isc_socket_t **socketp, isc_socket_t *dup_socket);
static void
-send_recvdone_event(isc__socket_t *, isc_socketevent_t **);
+send_recvdone_event(isc_socket_t *, isc_socketevent_t **);
static void
-send_senddone_event(isc__socket_t *, isc_socketevent_t **);
+send_senddone_event(isc_socket_t *, isc_socketevent_t **);
static void
-send_connectdone_event(isc__socket_t *, isc_socket_connev_t **);
+send_connectdone_event(isc_socket_t *, isc_socket_connev_t **);
static void
-free_socket(isc__socket_t **);
+free_socket(isc_socket_t **);
static isc_result_t
-allocate_socket(isc__socketmgr_t *, isc_sockettype_t, isc__socket_t **);
+allocate_socket(isc_socketmgr_t *, isc_sockettype_t, isc_socket_t **);
static void
-destroy(isc__socket_t **);
+destroy(isc_socket_t **);
static void
-internal_accept(isc__socket_t *);
+internal_accept(isc_socket_t *);
static void
-internal_connect(isc__socket_t *);
+internal_connect(isc_socket_t *);
static void
-internal_recv(isc__socket_t *);
+internal_recv(isc_socket_t *);
static void
-internal_send(isc__socket_t *);
+internal_send(isc_socket_t *);
static void
-process_cmsg(isc__socket_t *, struct msghdr *, isc_socketevent_t *);
+process_cmsg(isc_socket_t *, struct msghdr *, isc_socketevent_t *);
static void
-build_msghdr_send(isc__socket_t *, char *, isc_socketevent_t *, struct msghdr *,
+build_msghdr_send(isc_socket_t *, char *, isc_socketevent_t *, struct msghdr *,
struct iovec *, size_t *);
static void
-build_msghdr_recv(isc__socket_t *, char *, isc_socketevent_t *, struct msghdr *,
+build_msghdr_recv(isc_socket_t *, char *, isc_socketevent_t *, struct msghdr *,
struct iovec *, size_t *);
static bool
process_ctlfd(isc__socketthread_t *thread);
static void
-setdscp(isc__socket_t *sock, isc_dscp_t dscp);
+setdscp(isc_socket_t *sock, isc_dscp_t dscp);
#define SELECT_POKE_SHUTDOWN (-1)
#define SELECT_POKE_NOTHING (-2)
};
static int
-gen_threadid(isc__socket_t *sock);
+gen_threadid(isc_socket_t *sock);
static int
-gen_threadid(isc__socket_t *sock) {
+gen_threadid(isc_socket_t *sock) {
return (sock->fd % sock->manager->nthreads);
}
static void
-manager_log(isc__socketmgr_t *sockmgr, isc_logcategory_t *category,
+manager_log(isc_socketmgr_t *sockmgr, isc_logcategory_t *category,
isc_logmodule_t *module, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(5, 6);
static void
-manager_log(isc__socketmgr_t *sockmgr, isc_logcategory_t *category,
+manager_log(isc_socketmgr_t *sockmgr, isc_logcategory_t *category,
isc_logmodule_t *module, int level, const char *fmt, ...) {
char msgbuf[2048];
va_list ap;
}
static void
-socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
+socket_log(isc_socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
const char *fmt, ...) ISC_FORMAT_PRINTF(6, 7);
static void
-socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
+socket_log(isc_socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
const char *fmt, ...) {
char msgbuf[2048];
* will not get partial writes.
*/
static void
-select_poke(isc__socketmgr_t *mgr, int threadid, int fd, int msg) {
+select_poke(isc_socketmgr_t *mgr, int threadid, int fd, int msg) {
int cc;
int buf[2];
char strbuf[ISC_STRERRORSIZE];
* Process control messages received on a socket.
*/
static void
-process_cmsg(isc__socket_t *sock, struct msghdr *msg, isc_socketevent_t *dev) {
+process_cmsg(isc_socket_t *sock, struct msghdr *msg, isc_socketevent_t *dev) {
#ifdef USE_CMSG
struct cmsghdr *cmsgp;
struct in6_pktinfo *pktinfop;
* this transaction can send.
*/
static void
-build_msghdr_send(isc__socket_t *sock, char *cmsgbuf, isc_socketevent_t *dev,
+build_msghdr_send(isc_socket_t *sock, char *cmsgbuf, isc_socketevent_t *dev,
struct msghdr *msg, struct iovec *iov, size_t *write_countp) {
unsigned int iovcount;
size_t write_count;
* this transaction can receive.
*/
static void
-build_msghdr_recv(isc__socket_t *sock, char *cmsgbuf, isc_socketevent_t *dev,
+build_msghdr_recv(isc_socket_t *sock, char *cmsgbuf, isc_socketevent_t *dev,
struct msghdr *msg, struct iovec *iov, size_t *read_countp) {
unsigned int iovcount;
size_t read_count;
}
static void
-set_dev_address(const isc_sockaddr_t *address, isc__socket_t *sock,
+set_dev_address(const isc_sockaddr_t *address, isc_socket_t *sock,
isc_socketevent_t *dev) {
if (sock->type == isc_sockettype_udp) {
if (address != NULL) {
#define DOIO_EOF 3 /* EOF, no event sent */
static int
-doio_recv(isc__socket_t *sock, isc_socketevent_t *dev) {
+doio_recv(isc_socket_t *sock, isc_socketevent_t *dev) {
int cc;
struct iovec iov[MAXSCATTERGATHER_RECV];
size_t read_count;
* No other return values are possible.
*/
static int
-doio_send(isc__socket_t *sock, isc_socketevent_t *dev) {
+doio_send(isc_socket_t *sock, isc_socketevent_t *dev) {
int cc;
struct iovec iov[MAXSCATTERGATHER_SEND];
size_t write_count;
* references exist.
*/
static void
-socketclose(isc__socketthread_t *thread, isc__socket_t *sock, int fd) {
+socketclose(isc__socketthread_t *thread, isc_socket_t *sock, int fd) {
int lockid = FDLOCK_ID(fd);
/*
* No one has this socket open, so the watcher doesn't have to be
}
static void
-destroy(isc__socket_t **sockp) {
+destroy(isc_socket_t **sockp) {
int fd = 0;
- isc__socket_t *sock = *sockp;
- isc__socketmgr_t *manager = sock->manager;
+ isc_socket_t *sock = *sockp;
+ isc_socketmgr_t *manager = sock->manager;
isc__socketthread_t *thread = NULL;
socket_log(sock, NULL, CREATION, "destroying");
}
static isc_result_t
-allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type,
- isc__socket_t **socketp) {
- isc__socket_t *sock;
+allocate_socket(isc_socketmgr_t *manager, isc_sockettype_t type,
+ isc_socket_t **socketp) {
+ isc_socket_t *sock;
sock = isc_mem_get(manager->mctx, sizeof(*sock));
- sock->common.magic = 0;
- sock->common.impmagic = 0;
+ sock->magic = 0;
isc_refcount_init(&sock->references, 0);
sock->manager = manager;
*/
isc_mutex_init(&sock->lock);
- sock->common.magic = ISCAPI_SOCKET_MAGIC;
- sock->common.impmagic = SOCKET_MAGIC;
+ sock->magic = SOCKET_MAGIC;
*socketp = sock;
return (ISC_R_SUCCESS);
* also close the socket.
*/
static void
-free_socket(isc__socket_t **socketp) {
- isc__socket_t *sock = *socketp;
+free_socket(isc_socket_t **socketp) {
+ isc_socket_t *sock = *socketp;
*socketp = NULL;
INSIST(VALID_SOCKET(sock));
INSIST(!ISC_LINK_LINKED(sock, link));
UNLOCK(&sock->lock);
- sock->common.magic = 0;
- sock->common.impmagic = 0;
+ sock->magic = 0;
isc_mutex_destroy(&sock->lock);
#endif /* ifdef SO_SNDBUF */
static void
-use_min_mtu(isc__socket_t *sock) {
+use_min_mtu(isc_socket_t *sock) {
#if !defined(IPV6_USE_MIN_MTU) && !defined(IPV6_MTU)
UNUSED(sock);
#endif /* if !defined(IPV6_USE_MIN_MTU) && !defined(IPV6_MTU) */
}
static void
-set_tcp_maxseg(isc__socket_t *sock, int size) {
+set_tcp_maxseg(isc_socket_t *sock, int size) {
#ifdef TCP_MAXSEG
if (sock->type == isc_sockettype_tcp) {
(void)setsockopt(sock->fd, IPPROTO_TCP, TCP_MAXSEG,
}
static isc_result_t
-opensocket(isc__socketmgr_t *manager, isc__socket_t *sock,
- isc__socket_t *dup_socket) {
+opensocket(isc_socketmgr_t *manager, isc_socket_t *sock,
+ isc_socket_t *dup_socket) {
isc_result_t result;
char strbuf[ISC_STRERRORSIZE];
const char *err = "socket";
* socket is returned in 'socketp'.
*/
static isc_result_t
-socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
+socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
isc_socket_t **socketp, isc_socket_t *dup_socket) {
- isc__socket_t *sock = NULL;
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
+ isc_socket_t *sock = NULL;
isc__socketthread_t *thread;
isc_result_t result;
int lockid;
sock->pf = pf;
- result = opensocket(manager, sock, (isc__socket_t *)dup_socket);
+ result = opensocket(manager, sock, dup_socket);
if (result != ISC_R_SUCCESS) {
free_socket(&sock);
return (result);
sock->threadid = gen_threadid(sock);
isc_refcount_increment0(&sock->references);
thread = &manager->threads[sock->threadid];
- *socketp = (isc_socket_t *)sock;
+ *socketp = sock;
/*
* Note we don't have to lock the socket like we normally would because
* in 'socketp'.
*/
isc_result_t
-isc_socket_dup(isc_socket_t *sock0, isc_socket_t **socketp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_dup(isc_socket_t *sock, isc_socket_t **socketp) {
REQUIRE(VALID_SOCKET(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
- return (socket_create((isc_socketmgr_t *)sock->manager, sock->pf,
- sock->type, socketp, sock0));
+ return (socket_create(sock->manager, sock->pf, sock->type, socketp,
+ sock));
}
isc_result_t
-isc_socket_open(isc_socket_t *sock0) {
+isc_socket_open(isc_socket_t *sock) {
isc_result_t result;
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc__socketthread_t *thread;
REQUIRE(VALID_SOCKET(sock));
* Attach to a socket. Caller must explicitly detach when it is done.
*/
void
-isc_socket_attach(isc_socket_t *sock0, isc_socket_t **socketp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
REQUIRE(VALID_SOCKET(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
int old_refs = isc_refcount_increment(&sock->references);
REQUIRE(old_refs > 0);
- *socketp = (isc_socket_t *)sock;
+ *socketp = sock;
}
/*
*/
void
isc_socket_detach(isc_socket_t **socketp) {
- isc__socket_t *sock;
+ isc_socket_t *sock;
REQUIRE(socketp != NULL);
- sock = (isc__socket_t *)*socketp;
+ sock = *socketp;
REQUIRE(VALID_SOCKET(sock));
if (isc_refcount_decrement(&sock->references) == 1) {
destroy(&sock);
}
isc_result_t
-isc_socket_close(isc_socket_t *sock0) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_close(isc_socket_t *sock) {
int fd;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
isc__socketthread_t *thread;
fflush(stdout);
REQUIRE(VALID_SOCKET(sock));
* Caller must have the socket locked if the event is attached to the socket.
*/
static void
-send_recvdone_event(isc__socket_t *sock, isc_socketevent_t **dev) {
+send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
isc_task_t *task;
task = (*dev)->ev_sender;
* Caller must have the socket locked if the event is attached to the socket.
*/
static void
-send_senddone_event(isc__socket_t *sock, isc_socketevent_t **dev) {
+send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
isc_task_t *task;
INSIST(dev != NULL && *dev != NULL);
* Caller must have the socket locked if the event is attached to the socket.
*/
static void
-send_connectdone_event(isc__socket_t *sock, isc_socket_connev_t **dev) {
+send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **dev) {
isc_task_t *task;
INSIST(dev != NULL && *dev != NULL);
* so just unlock and return.
*/
static void
-internal_accept(isc__socket_t *sock) {
- isc__socketmgr_t *manager;
+internal_accept(isc_socket_t *sock) {
+ isc_socketmgr_t *manager;
isc__socketthread_t *thread, *nthread;
isc_socket_newconnev_t *dev;
isc_task_t *task;
} else {
inc_stats(manager->stats, sock->statsindex[STATID_ACCEPTFAIL]);
isc_refcount_decrementz(&NEWCONNSOCK(dev)->references);
- free_socket((isc__socket_t **)&dev->newsocket);
+ free_socket((isc_socket_t **)&dev->newsocket);
}
/*
}
static void
-internal_recv(isc__socket_t *sock) {
+internal_recv(isc_socket_t *sock) {
isc_socketevent_t *dev;
INSIST(VALID_SOCKET(sock));
}
static void
-internal_send(isc__socket_t *sock) {
+internal_send(isc_socket_t *sock) {
isc_socketevent_t *dev;
INSIST(VALID_SOCKET(sock));
*/
static void
process_fd(isc__socketthread_t *thread, int fd, bool readable, bool writeable) {
- isc__socket_t *sock;
+ isc_socket_t *sock;
int lockid = FDLOCK_ID(fd);
/*
static isc_threadresult_t
netthread(void *uap) {
isc__socketthread_t *thread = uap;
- isc__socketmgr_t *manager = thread->manager;
+ isc_socketmgr_t *manager = thread->manager;
(void)manager;
bool done;
int cc;
}
void
-isc_socketmgr_setreserved(isc_socketmgr_t *manager0, uint32_t reserved) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
-
+isc_socketmgr_setreserved(isc_socketmgr_t *manager, uint32_t reserved) {
REQUIRE(VALID_MANAGER(manager));
manager->reserved = reserved;
}
void
-isc_socketmgr_maxudp(isc_socketmgr_t *manager0, unsigned int maxudp) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
-
+isc_socketmgr_maxudp(isc_socketmgr_t *manager, unsigned int maxudp) {
REQUIRE(VALID_MANAGER(manager));
manager->maxudp = maxudp;
REQUIRE(thread->threadid >= 0 &&
thread->threadid < thread->manager->nthreads);
- thread->fds = isc_mem_get(thread->manager->mctx,
- thread->manager->maxsocks *
- sizeof(isc__socket_t *));
+ thread->fds =
+ isc_mem_get(thread->manager->mctx,
+ thread->manager->maxsocks * sizeof(isc_socket_t *));
memset(thread->fds, 0,
thread->manager->maxsocks * sizeof(isc_socket_t *));
thread->manager->maxsocks * sizeof(uint32_t));
#endif /* if defined(USE_EPOLL) */
isc_mem_put(thread->manager->mctx, thread->fds,
- thread->manager->maxsocks * sizeof(isc__socket_t *));
+ thread->manager->maxsocks * sizeof(isc_socket_t *));
isc_mem_put(thread->manager->mctx, thread->fdstate,
thread->manager->maxsocks * sizeof(int));
isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
unsigned int maxsocks, int nthreads) {
int i;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
REQUIRE(managerp != NULL && *managerp == NULL);
manager->nthreads = nthreads;
manager->stats = NULL;
- manager->common.magic = ISCAPI_SOCKETMGR_MAGIC;
- manager->common.impmagic = SOCKET_MANAGER_MAGIC;
+ manager->magic = SOCKET_MANAGER_MAGIC;
manager->mctx = NULL;
ISC_LIST_INIT(manager->socklist);
isc_mutex_init(&manager->lock);
isc_thread_setname(manager->threads[i].thread, tname);
}
- *managerp = (isc_socketmgr_t *)manager;
+ *managerp = manager;
return (ISC_R_SUCCESS);
}
isc_result_t
-isc_socketmgr_getmaxsockets(isc_socketmgr_t *manager0, unsigned int *nsockp) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
+isc_socketmgr_getmaxsockets(isc_socketmgr_t *manager, unsigned int *nsockp) {
REQUIRE(VALID_MANAGER(manager));
REQUIRE(nsockp != NULL);
}
void
-isc_socketmgr_setstats(isc_socketmgr_t *manager0, isc_stats_t *stats) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
-
+isc_socketmgr_setstats(isc_socketmgr_t *manager, isc_stats_t *stats) {
REQUIRE(VALID_MANAGER(manager));
REQUIRE(ISC_LIST_EMPTY(manager->socklist));
REQUIRE(manager->stats == NULL);
void
isc_socketmgr_destroy(isc_socketmgr_t **managerp) {
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
/*
* Destroy a socket manager.
*/
REQUIRE(managerp != NULL);
- manager = (isc__socketmgr_t *)*managerp;
+ manager = *managerp;
REQUIRE(VALID_MANAGER(manager));
LOCK(&manager->lock);
isc_stats_detach(&manager->stats);
}
isc_mutex_destroy(&manager->lock);
- manager->common.magic = 0;
- manager->common.impmagic = 0;
+ manager->magic = 0;
isc_mem_putanddetach(&manager->mctx, manager, sizeof(*manager));
*managerp = NULL;
}
static isc_result_t
-socket_recv(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
+socket_recv(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
unsigned int flags) {
int io_state;
bool have_lock = false;
}
isc_result_t
-isc_socket_recv(isc_socket_t *sock0, isc_region_t *region, unsigned int minimum,
+isc_socket_recv(isc_socket_t *sock, isc_region_t *region, unsigned int minimum,
isc_task_t *task, isc_taskaction_t action, void *arg) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socketevent_t *dev;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
REQUIRE(VALID_SOCKET(sock));
REQUIRE(action != NULL);
return (ISC_R_NOMEMORY);
}
- return (isc_socket_recv2(sock0, region, minimum, task, dev, 0));
+ return (isc_socket_recv2(sock, region, minimum, task, dev, 0));
}
isc_result_t
-isc_socket_recv2(isc_socket_t *sock0, isc_region_t *region,
- unsigned int minimum, isc_task_t *task,
- isc_socketevent_t *event, unsigned int flags) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_recv2(isc_socket_t *sock, isc_region_t *region, unsigned int minimum,
+ isc_task_t *task, isc_socketevent_t *event,
+ unsigned int flags) {
event->ev_sender = sock;
event->result = ISC_R_UNSET;
event->region = *region;
}
static isc_result_t
-socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
+socket_send(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags) {
int io_state;
}
isc_result_t
-isc_socket_sendto(isc_socket_t *sock0, isc_region_t *region, isc_task_t *task,
+isc_socket_sendto(isc_socket_t *sock, isc_region_t *region, isc_task_t *task,
isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socketevent_t *dev;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
REQUIRE(VALID_SOCKET(sock));
REQUIRE(region != NULL);
}
isc_result_t
-isc_socket_sendto2(isc_socket_t *sock0, isc_region_t *region, isc_task_t *task,
+isc_socket_sendto2(isc_socket_t *sock, isc_region_t *region, isc_task_t *task,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
isc_socketevent_t *event, unsigned int flags) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
REQUIRE(VALID_SOCKET(sock));
REQUIRE((flags & ~(ISC_SOCKFLAG_IMMEDIATE | ISC_SOCKFLAG_NORETRY)) ==
0);
}
isc_result_t
-isc_socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
+isc_socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
isc_socket_options_t options) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
char strbuf[ISC_STRERRORSIZE];
int on = 1;
#undef ENABLE_ACCEPTFILTER
isc_result_t
-isc_socket_filter(isc_socket_t *sock0, const char *filter) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_filter(isc_socket_t *sock, const char *filter) {
#if defined(SO_ACCEPTFILTER) && defined(ENABLE_ACCEPTFILTER)
char strbuf[ISC_STRERRORSIZE];
struct accept_filter_arg afa;
* Try enabling TCP Fast Open for a given socket if the OS supports it.
*/
static void
-set_tcp_fastopen(isc__socket_t *sock, unsigned int backlog) {
+set_tcp_fastopen(isc_socket_t *sock, unsigned int backlog) {
#if defined(ENABLE_TCP_FASTOPEN) && defined(TCP_FASTOPEN)
char strbuf[ISC_STRERRORSIZE];
* as well keep things simple rather than having to track them.
*/
isc_result_t
-isc_socket_listen(isc_socket_t *sock0, unsigned int backlog) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_listen(isc_socket_t *sock, unsigned int backlog) {
char strbuf[ISC_STRERRORSIZE];
REQUIRE(VALID_SOCKET(sock));
* This should try to do aggressive accept() XXXMLG
*/
isc_result_t
-isc_socket_accept(isc_socket_t *sock0, isc_task_t *task,
- isc_taskaction_t action, void *arg) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_accept(isc_socket_t *sock, isc_task_t *task, isc_taskaction_t action,
+ void *arg) {
isc_socket_newconnev_t *dev;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
isc_task_t *ntask = NULL;
- isc__socket_t *nsock;
+ isc_socket_t *nsock;
isc_result_t result;
bool do_poke = false;
nsock->statsindex = sock->statsindex;
dev->ev_sender = ntask;
- dev->newsocket = (isc_socket_t *)nsock;
+ dev->newsocket = nsock;
/*
* Poke watcher here. We still have the socket locked, so there
}
isc_result_t
-isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
+isc_socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action, void *arg) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socket_connev_t *dev;
isc_task_t *ntask = NULL;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
int cc;
char strbuf[ISC_STRERRORSIZE];
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
* Called when a socket with a pending connect() finishes.
*/
static void
-internal_connect(isc__socket_t *sock) {
+internal_connect(isc_socket_t *sock) {
isc_socket_connev_t *dev;
int cc;
isc_result_t result;
}
isc_result_t
-isc_socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
isc_result_t result;
REQUIRE(VALID_SOCKET(sock));
}
isc_result_t
-isc_socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
socklen_t len;
isc_result_t result;
char strbuf[ISC_STRERRORSIZE];
* queued for task "task" of type "how". "how" is a bitmask.
*/
void
-isc_socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
REQUIRE(VALID_SOCKET(sock));
/*
isc_refcount_decrementz(
&NEWCONNSOCK(dev)->references);
- free_socket((isc__socket_t **)&dev->newsocket);
+ free_socket((isc_socket_t **)&dev->newsocket);
dev->result = ISC_R_CANCELED;
dev->ev_sender = sock;
}
isc_sockettype_t
-isc_socket_gettype(isc_socket_t *sock0) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_gettype(isc_socket_t *sock) {
REQUIRE(VALID_SOCKET(sock));
return (sock->type);
}
void
-isc_socket_ipv6only(isc_socket_t *sock0, bool yes) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_ipv6only(isc_socket_t *sock, bool yes) {
#if defined(IPV6_V6ONLY)
int onoff = yes ? 1 : 0;
#else /* if defined(IPV6_V6ONLY) */
}
static void
-setdscp(isc__socket_t *sock, isc_dscp_t dscp) {
+setdscp(isc_socket_t *sock, isc_dscp_t dscp) {
#if defined(IP_TOS) || defined(IPV6_TCLASS)
int value = dscp << 2;
#endif /* if defined(IP_TOS) || defined(IPV6_TCLASS) */
}
void
-isc_socket_dscp(isc_socket_t *sock0, isc_dscp_t dscp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
REQUIRE(VALID_SOCKET(sock));
REQUIRE(dscp < 0x40);
}
void
-isc_socket_setname(isc_socket_t *socket0, const char *name, void *tag) {
- isc__socket_t *sock = (isc__socket_t *)socket0;
-
+isc_socket_setname(isc_socket_t *sock, const char *name, void *tag) {
/*
* Name 'sock'.
*/
}
const char *
-isc_socket_getname(isc_socket_t *socket0) {
- isc__socket_t *sock = (isc__socket_t *)socket0;
-
+isc_socket_getname(isc_socket_t *sock) {
return (sock->name);
}
void *
-isc_socket_gettag(isc_socket_t *socket0) {
- isc__socket_t *sock = (isc__socket_t *)socket0;
-
+isc_socket_gettag(isc_socket_t *sock) {
return (sock->tag);
}
int
-isc_socket_getfd(isc_socket_t *socket0) {
- isc__socket_t *sock = (isc__socket_t *)socket0;
-
+isc_socket_getfd(isc_socket_t *sock) {
return ((short)sock->fd);
}
goto error; \
} while (0)
int
-isc_socketmgr_renderxml(isc_socketmgr_t *mgr0, void *writer0) {
- isc__socketmgr_t *mgr = (isc__socketmgr_t *)mgr0;
- isc__socket_t *sock = NULL;
+isc_socketmgr_renderxml(isc_socketmgr_t *mgr, void *writer0) {
+ isc_socket_t *sock = NULL;
char peerbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t addr;
socklen_t len;
} while (0)
isc_result_t
-isc_socketmgr_renderjson(isc_socketmgr_t *mgr0, void *stats0) {
+isc_socketmgr_renderjson(isc_socketmgr_t *mgr, void *stats0) {
isc_result_t result = ISC_R_SUCCESS;
- isc__socketmgr_t *mgr = (isc__socketmgr_t *)mgr0;
- isc__socket_t *sock = NULL;
+ isc_socket_t *sock = NULL;
char peerbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t addr;
socklen_t len;
projects / thirdparty / bind9.git / commitdiff
