contrib/bind9/lib/isc/task_api.c

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