contrib/ntp/libntp/ntp_worker.c

   1 /*
   2  * ntp_worker.c
   3  */
   4 #include <config.h>
   5 #include "ntp_workimpl.h"
   6
   7 #ifdef WORKER
   8
   9 #include <stdio.h>
  10 #include <ctype.h>
  11 #include <signal.h>
  12
  13 #include "iosignal.h"
  14 #include "ntp_stdlib.h"
  15 #include "ntp_malloc.h"
  16 #include "ntp_syslog.h"
  17 #include "ntpd.h"
  18 #include "ntp_io.h"
  19 #include "ntp_assert.h"
  20 #include "ntp_unixtime.h"
  21 #include "intreswork.h"
  22
  23
  24 #define CHILD_MAX_IDLE  (3 * 60)        /* seconds, idle worker limit */
  25
  26 blocking_child **       blocking_children;
  27 size_t                  blocking_children_alloc;
  28 int                     worker_per_query;       /* boolean */
  29 int                     intres_req_pending;
  30
  31
  32 #ifndef HAVE_IO_COMPLETION_PORT
  33 /*
  34  * pipe_socketpair()
  35  *
  36  * Provides an AF_UNIX socketpair on systems which have them, otherwise
  37  * pair of unidirectional pipes.
  38  */
  39 int
  40 pipe_socketpair(
  41         int     caller_fds[2],
  42         int *   is_pipe
  43         )
  44 {
  45         int     rc;
  46         int     fds[2];
  47         int     called_pipe;
  48
  49 #ifdef HAVE_SOCKETPAIR
  50         rc = socketpair(AF_UNIX, SOCK_STREAM, 0, &fds[0]);
  51 #else
  52         rc = -1;
  53 #endif
  54
  55         if (-1 == rc) {
  56                 rc = pipe(&fds[0]);
  57                 called_pipe = TRUE;
  58         } else {
  59                 called_pipe = FALSE;
  60         }
  61
  62         if (-1 == rc)
  63                 return rc;
  64
  65         caller_fds[0] = fds[0];
  66         caller_fds[1] = fds[1];
  67         if (is_pipe != NULL)
  68                 *is_pipe = called_pipe;
  69
  70         return 0;
  71 }
  72
  73
  74 /*
  75  * close_all_except()
  76  *
  77  * Close all file descriptors except the given keep_fd.
  78  */
  79 void
  80 close_all_except(
  81         int keep_fd
  82         )
  83 {
  84         int fd;
  85
  86         for (fd = 0; fd < keep_fd; fd++)
  87                 close(fd);
  88
  89         close_all_beyond(keep_fd);
  90 }
  91
  92
  93 /*
  94  * close_all_beyond()
  95  *
  96  * Close all file descriptors after the given keep_fd, which is the
  97  * highest fd to keep open.
  98  */
  99 void
 100 close_all_beyond(
 101         int keep_fd
 102         )
 103 {
 104 # ifdef HAVE_CLOSEFROM
 105         closefrom(keep_fd + 1);
 106 # elif defined(F_CLOSEM)
 107         /*
 108          * From 'Writing Reliable AIX Daemons,' SG24-4946-00,
 109          * by Eric Agar (saves us from doing 32767 system
 110          * calls)
 111          */
 112         if (fcntl(keep_fd + 1, F_CLOSEM, 0) == -1)
 113                 msyslog(LOG_ERR, "F_CLOSEM(%d): %m", keep_fd + 1);
 114 # else  /* !HAVE_CLOSEFROM && !F_CLOSEM follows */
 115         int fd;
 116         int max_fd;
 117
 118         max_fd = GETDTABLESIZE();
 119         for (fd = keep_fd + 1; fd < max_fd; fd++)
 120                 close(fd);
 121 # endif /* !HAVE_CLOSEFROM && !F_CLOSEM */
 122 }
 123 #endif  /* HAVE_IO_COMPLETION_PORT */
 124
 125
 126 u_int
 127 available_blocking_child_slot(void)
 128 {
 129         const size_t    each = sizeof(blocking_children[0]);
 130         u_int           slot;
 131         size_t          prev_alloc;
 132         size_t          new_alloc;
 133         size_t          prev_octets;
 134         size_t          octets;
 135
 136         for (slot = 0; slot < blocking_children_alloc; slot++) {
 137                 if (NULL == blocking_children[slot])
 138                         return slot;
 139                 if (blocking_children[slot]->reusable) {
 140                         blocking_children[slot]->reusable = FALSE;
 141                         return slot;
 142                 }
 143         }
 144
 145         prev_alloc = blocking_children_alloc;
 146         prev_octets = prev_alloc * each;
 147         new_alloc = blocking_children_alloc + 4;
 148         octets = new_alloc * each;
 149         blocking_children = erealloc_zero(blocking_children, octets,
 150                                           prev_octets);
 151         blocking_children_alloc = new_alloc;
 152
 153         /* assume we'll never have enough workers to overflow u_int */
 154         return (u_int)prev_alloc;
 155 }
 156
 157
 158 int
 159 queue_blocking_request(
 160         blocking_work_req       rtype,
 161         void *                  req,
 162         size_t                  reqsize,
 163         blocking_work_callback  done_func,
 164         void *                  context
 165         )
 166 {
 167         static u_int            intres_slot = UINT_MAX;
 168         u_int                   child_slot;
 169         blocking_child *        c;
 170         blocking_pipe_header    req_hdr;
 171
 172         req_hdr.octets = sizeof(req_hdr) + reqsize;
 173         req_hdr.magic_sig = BLOCKING_REQ_MAGIC;
 174         req_hdr.rtype = rtype;
 175         req_hdr.done_func = done_func;
 176         req_hdr.context = context;
 177
 178         child_slot = UINT_MAX;
 179         if (worker_per_query || UINT_MAX == intres_slot ||
 180             blocking_children[intres_slot]->reusable)
 181                 child_slot = available_blocking_child_slot();
 182         if (!worker_per_query) {
 183                 if (UINT_MAX == intres_slot)
 184                         intres_slot = child_slot;
 185                 else
 186                         child_slot = intres_slot;
 187                 if (0 == intres_req_pending)
 188                         intres_timeout_req(0);
 189         }
 190         intres_req_pending++;
 191         INSIST(UINT_MAX != child_slot);
 192         c = blocking_children[child_slot];
 193         if (NULL == c) {
 194                 c = emalloc_zero(sizeof(*c));
 195 #ifdef WORK_FORK
 196                 c->req_read_pipe = -1;
 197                 c->req_write_pipe = -1;
 198 #endif
 199 #ifdef WORK_PIPE
 200                 c->resp_read_pipe = -1;
 201                 c->resp_write_pipe = -1;
 202 #endif
 203                 blocking_children[child_slot] = c;
 204         }
 205         req_hdr.child_idx = child_slot;
 206
 207         return send_blocking_req_internal(c, &req_hdr, req);
 208 }
 209
 210
 211 int queue_blocking_response(
 212         blocking_child *                c,
 213         blocking_pipe_header *          resp,
 214         size_t                          respsize,
 215         const blocking_pipe_header *    req
 216         )
 217 {
 218         resp->octets = respsize;
 219         resp->magic_sig = BLOCKING_RESP_MAGIC;
 220         resp->rtype = req->rtype;
 221         resp->context = req->context;
 222         resp->done_func = req->done_func;
 223
 224         return send_blocking_resp_internal(c, resp);
 225 }
 226
 227
 228 void
 229 process_blocking_resp(
 230         blocking_child *        c
 231         )
 232 {
 233         blocking_pipe_header *  resp;
 234         void *                  data;
 235
 236         /*
 237          * On Windows send_blocking_resp_internal() may signal the
 238          * blocking_response_ready event multiple times while we're
 239          * processing a response, so always consume all available
 240          * responses before returning to test the event again.
 241          */
 242 #ifdef WORK_THREAD
 243         do {
 244 #endif
 245                 resp = receive_blocking_resp_internal(c);
 246                 if (NULL != resp) {
 247                         DEBUG_REQUIRE(BLOCKING_RESP_MAGIC ==
 248                                       resp->magic_sig);
 249                         data = (char *)resp + sizeof(*resp);
 250                         intres_req_pending--;
 251                         (*resp->done_func)(resp->rtype, resp->context,
 252                                            resp->octets - sizeof(*resp),
 253                                            data);
 254                         free(resp);
 255                 }
 256 #ifdef WORK_THREAD
 257         } while (NULL != resp);
 258 #endif
 259         if (!worker_per_query && 0 == intres_req_pending)
 260                 intres_timeout_req(CHILD_MAX_IDLE);
 261         else if (worker_per_query)
 262                 req_child_exit(c);
 263 }
 264
 265
 266 /*
 267  * blocking_child_common runs as a forked child or a thread
 268  */
 269 int
 270 blocking_child_common(
 271         blocking_child  *c
 272         )
 273 {
 274         int say_bye;
 275         blocking_pipe_header *req;
 276
 277         say_bye = FALSE;
 278         while (!say_bye) {
 279                 req = receive_blocking_req_internal(c);
 280                 if (NULL == req) {
 281                         say_bye = TRUE;
 282                         continue;
 283                 }
 284
 285                 DEBUG_REQUIRE(BLOCKING_REQ_MAGIC == req->magic_sig);
 286
 287                 switch (req->rtype) {
 288                 case BLOCKING_GETADDRINFO:
 289                         if (blocking_getaddrinfo(c, req))
 290                                 say_bye = TRUE;
 291                         break;
 292
 293                 case BLOCKING_GETNAMEINFO:
 294                         if (blocking_getnameinfo(c, req))
 295                                 say_bye = TRUE;
 296                         break;
 297
 298                 default:
 299                         msyslog(LOG_ERR, "unknown req %d to blocking worker", req->rtype);
 300                         say_bye = TRUE;
 301                 }
 302
 303                 free(req);
 304         }
 305
 306         return 0;
 307 }
 308
 309
 310 /*
 311  * worker_idle_timer_fired()
 312  *
 313  * The parent starts this timer when the last pending response has been
 314  * received from the child, making it idle, and clears the timer when a
 315  * request is dispatched to the child.  Once the timer expires, the
 316  * child is sent packing.
 317  *
 318  * This is called when worker_idle_timer is nonzero and less than or
 319  * equal to current_time.
 320  */
 321 void
 322 worker_idle_timer_fired(void)
 323 {
 324         u_int                   idx;
 325         blocking_child *        c;
 326
 327         DEBUG_REQUIRE(0 == intres_req_pending);
 328
 329         intres_timeout_req(0);
 330         for (idx = 0; idx < blocking_children_alloc; idx++) {
 331                 c = blocking_children[idx];
 332                 if (NULL == c)
 333                         continue;
 334                 req_child_exit(c);
 335         }
 336 }
 337
 338
 339 #else   /* !WORKER follows */
 340 int ntp_worker_nonempty_compilation_unit;
 341 #endif