external/bsd/bind/dist/lib/isc/task_api.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2009  Internet Systems Consortium, Inc. ("ISC")
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  11  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  12  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  13  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  14  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  15  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16  * PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 /* Id: task_api.c,v 1.5 2009/09/02 23:48:02 tbox Exp */
  20
  21 #include <config.h>
  22
  23 #include <unistd.h>
  24
  25 #include <isc/app.h>
  26 #include <isc/magic.h>
  27 #include <isc/mutex.h>
  28 #include <isc/once.h>
  29 #include <isc/task.h>
  30 #include <isc/util.h>
  31
  32 static isc_mutex_t createlock;
  33 static isc_once_t once = ISC_ONCE_INIT;
  34 static isc_taskmgrcreatefunc_t taskmgr_createfunc = NULL;
  35
  36 static void
  37 initialize(void) {
  38         RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
  39 }
  40
  41 isc_result_t
  42 isc_task_register(isc_taskmgrcreatefunc_t createfunc) {
  43         isc_result_t result = ISC_R_SUCCESS;
  44
  45         RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
  46
  47         LOCK(&createlock);
  48         if (taskmgr_createfunc == NULL)
  49                 taskmgr_createfunc = createfunc;
  50         else
  51                 result = ISC_R_EXISTS;
  52         UNLOCK(&createlock);
  53
  54         return (result);
  55 }
  56
  57 isc_result_t
  58 isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
  59                         unsigned int workers, unsigned int default_quantum,
  60                         isc_taskmgr_t **managerp)
  61 {
  62         isc_result_t result;
  63
  64         LOCK(&createlock);
  65
  66         REQUIRE(taskmgr_createfunc != NULL);
  67         result = (*taskmgr_createfunc)(mctx, workers, default_quantum,
  68                                        managerp);
  69
  70         UNLOCK(&createlock);
  71
  72         if (result == ISC_R_SUCCESS)
  73                 isc_appctx_settaskmgr(actx, *managerp);
  74
  75         return (result);
  76 }
  77
  78 isc_result_t
  79 isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
  80                    unsigned int default_quantum, isc_taskmgr_t **managerp)
  81 {
  82         isc_result_t result;
  83
  84         LOCK(&createlock);
  85
  86         REQUIRE(taskmgr_createfunc != NULL);
  87         result = (*taskmgr_createfunc)(mctx, workers, default_quantum,
  88                                        managerp);
  89
  90         UNLOCK(&createlock);
  91
  92         return (result);
  93 }
  94
  95 void
  96 isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
  97         REQUIRE(managerp != NULL && ISCAPI_TASKMGR_VALID(*managerp));
  98
  99         (*managerp)->methods->destroy(managerp);
 100
 101         ENSURE(*managerp == NULL);
 102 }
 103
 104 isc_result_t
 105 isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
 106                 isc_task_t **taskp)
 107 {
 108         REQUIRE(ISCAPI_TASKMGR_VALID(manager));
 109         REQUIRE(taskp != NULL && *taskp == NULL);
 110
 111         return (manager->methods->taskcreate(manager, quantum, taskp));
 112 }
 113
 114 void
 115 isc_task_attach(isc_task_t *source, isc_task_t **targetp) {
 116         REQUIRE(ISCAPI_TASK_VALID(source));
 117         REQUIRE(targetp != NULL && *targetp == NULL);
 118
 119         source->methods->attach(source, targetp);
 120
 121         ENSURE(*targetp == source);
 122 }
 123
 124 void
 125 isc_task_detach(isc_task_t **taskp) {
 126         REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
 127
 128         (*taskp)->methods->detach(taskp);
 129
 130         ENSURE(*taskp == NULL);
 131 }
 132
 133 void
 134 isc_task_send(isc_task_t *task, isc_event_t **eventp) {
 135         REQUIRE(ISCAPI_TASK_VALID(task));
 136         REQUIRE(eventp != NULL && *eventp != NULL);
 137
 138         task->methods->send(task, eventp);
 139
 140         ENSURE(*eventp == NULL);
 141 }
 142
 143 void
 144 isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
 145         REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
 146         REQUIRE(eventp != NULL && *eventp != NULL);
 147
 148         (*taskp)->methods->sendanddetach(taskp, eventp);
 149
 150         ENSURE(*taskp == NULL && *eventp == NULL);
 151 }
 152
 153 unsigned int
 154 isc_task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
 155                 void *tag, isc_eventlist_t *events)
 156 {
 157         REQUIRE(ISCAPI_TASK_VALID(task));
 158
 159         return (task->methods->unsend(task, sender, type, tag, events));
 160 }
 161
 162 isc_result_t
 163 isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, const void *arg)
 164 {
 165         REQUIRE(ISCAPI_TASK_VALID(task));
 166
 167         return (task->methods->onshutdown(task, action, arg));
 168 }
 169
 170 void
 171 isc_task_shutdown(isc_task_t *task) {
 172         REQUIRE(ISCAPI_TASK_VALID(task));
 173
 174         task->methods->shutdown(task);
 175 }
 176
 177 void
 178 isc_task_setname(isc_task_t *task, const char *name, void *tag) {
 179         REQUIRE(ISCAPI_TASK_VALID(task));
 180
 181         task->methods->setname(task, name, tag);
 182 }
 183
 184 unsigned int
 185 isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type, void *tag)
 186 {
 187         REQUIRE(ISCAPI_TASK_VALID(task));
 188
 189         return (task->methods->purgeevents(task, sender, type, tag));
 190 }
 191
 192 /*%
 193  * This is necessary for libisc's internal timer implementation.  Other
 194  * implementation might skip implementing this.
 195  */
 196 unsigned int
 197 isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first,
 198                     isc_eventtype_t last, void *tag)
 199 {
 200         REQUIRE(ISCAPI_TASK_VALID(task));
 201
 202         return (task->methods->purgerange(task, sender, first, last, tag));
 203 }