contrib/ntp/include/ntp_worker.h

   1 /*
   2  * ntp_worker.h
   3  */
   4
   5 #ifndef NTP_WORKER_H
   6 #define NTP_WORKER_H
   7
   8 #include "ntp_workimpl.h"
   9
  10 #ifdef WORKER
  11 # if defined(WORK_THREAD) && defined(WORK_PIPE)
  12 #  ifdef HAVE_SEMAPHORE_H
  13 #   include <semaphore.h>
  14 #  endif
  15 # endif
  16 #include "ntp_stdlib.h"
  17
  18 /* #define TEST_BLOCKING_WORKER */      /* ntp_config.c ntp_intres.c */
  19
  20 typedef enum blocking_work_req_tag {
  21         BLOCKING_GETNAMEINFO,
  22         BLOCKING_GETADDRINFO,
  23 } blocking_work_req;
  24
  25 typedef void (*blocking_work_callback)(blocking_work_req, void *, size_t, void *);
  26
  27 typedef enum blocking_magic_sig_e {
  28         BLOCKING_REQ_MAGIC  = 0x510c7ecf,
  29         BLOCKING_RESP_MAGIC = 0x510c7e54,
  30 } blocking_magic_sig;
  31
  32 /*
  33  * The same header is used for both requests to and responses from
  34  * the child.  In the child, done_func and context are opaque.
  35  */
  36 typedef struct blocking_pipe_header_tag {
  37         size_t                  octets;
  38         blocking_magic_sig      magic_sig;
  39         blocking_work_req       rtype;
  40         u_int                   child_idx;
  41         blocking_work_callback  done_func;
  42         void *                  context;
  43 } blocking_pipe_header;
  44
  45 # ifdef WORK_THREAD
  46 #  ifdef SYS_WINNT
  47 typedef struct { HANDLE thnd; } thread_type;
  48 typedef struct { HANDLE shnd; } sema_type;
  49 #  else
  50 typedef pthread_t       thread_type;
  51 typedef sem_t           sema_type;
  52 #  endif
  53 typedef thread_type     *thr_ref;
  54 typedef sema_type       *sem_ref;
  55 # endif
  56
  57 /*
  58  *
  59  */
  60 #if defined(WORK_FORK)
  61
  62 typedef struct blocking_child_tag {
  63         int     reusable;
  64         int     pid;
  65         int     req_write_pipe;         /* parent */
  66         int     resp_read_pipe;
  67         void *  resp_read_ctx;
  68         int     req_read_pipe;          /* child */
  69         int     resp_write_pipe;
  70         int     ispipe;
  71 } blocking_child;
  72
  73 #elif defined(WORK_THREAD)
  74
  75 typedef struct blocking_child_tag {
  76 /*
  77  * blocking workitems and blocking_responses are dynamically-sized
  78  * one-dimensional arrays of pointers to blocking worker requests and
  79  * responses.
  80  *
  81  * IMPORTANT: This structure is shared between threads, and all access
  82  * that is not atomic (especially queue operations) must hold the
  83  * 'accesslock' semaphore to avoid data races.
  84  *
  85  * The resource management (thread/semaphore creation/destruction)
  86  * functions and functions just testing a handle are safe because these
  87  * are only changed by the main thread when no worker is running on the
  88  * same data structure.
  89  */
  90         int                     reusable;
  91         sem_ref                 accesslock;     /* shared access lock */
  92         thr_ref                 thread_ref;     /* thread 'handle' */
  93
  94         /* the reuest queue */
  95         blocking_pipe_header ** volatile
  96                                 workitems;
  97         volatile size_t         workitems_alloc;
  98         size_t                  head_workitem;          /* parent */
  99         size_t                  tail_workitem;          /* child */
 100         sem_ref                 workitems_pending;      /* signalling */
 101
 102         /* the response queue */
 103         blocking_pipe_header ** volatile
 104                                 responses;
 105         volatile size_t         responses_alloc;
 106         size_t                  head_response;          /* child */
 107         size_t                  tail_response;          /* parent */
 108
 109         /* event handles / sem_t pointers */
 110         sem_ref                 wake_scheduled_sleep;
 111
 112         /* some systems use a pipe for notification, others a semaphore.
 113          * Both employ the queue above for the actual data transfer.
 114          */
 115 #ifdef WORK_PIPE
 116         int                     resp_read_pipe;         /* parent */
 117         int                     resp_write_pipe;        /* child */
 118         int                     ispipe;
 119         void *                  resp_read_ctx;          /* child */
 120 #else
 121         sem_ref                 responses_pending;      /* signalling */
 122 #endif
 123         sema_type               sem_table[4];
 124         thread_type             thr_table[1];
 125 } blocking_child;
 126
 127 #endif  /* WORK_THREAD */
 128
 129 extern  blocking_child **       blocking_children;
 130 extern  size_t                  blocking_children_alloc;
 131 extern  int                     worker_per_query;       /* boolean */
 132 extern  int                     intres_req_pending;
 133
 134 extern  u_int   available_blocking_child_slot(void);
 135 extern  int     queue_blocking_request(blocking_work_req, void *,
 136                                        size_t, blocking_work_callback,
 137                                        void *);
 138 extern  int     queue_blocking_response(blocking_child *,
 139                                         blocking_pipe_header *, size_t,
 140                                         const blocking_pipe_header *);
 141 extern  void    process_blocking_resp(blocking_child *);
 142 extern  int     send_blocking_req_internal(blocking_child *,
 143                                            blocking_pipe_header *,
 144                                            void *);
 145 extern  int     send_blocking_resp_internal(blocking_child *,
 146                                             blocking_pipe_header *);
 147 extern  blocking_pipe_header *
 148                 receive_blocking_req_internal(blocking_child *);
 149 extern  blocking_pipe_header *
 150                 receive_blocking_resp_internal(blocking_child *);
 151 extern  int     blocking_child_common(blocking_child *);
 152 extern  void    exit_worker(int)
 153                         __attribute__ ((__noreturn__));
 154 extern  int     worker_sleep(blocking_child *, time_t);
 155 extern  void    worker_idle_timer_fired(void);
 156 extern  void    interrupt_worker_sleep(void);
 157 extern  int     req_child_exit(blocking_child *);
 158 #ifndef HAVE_IO_COMPLETION_PORT
 159 extern  int     pipe_socketpair(int fds[2], int *is_pipe);
 160 extern  void    close_all_beyond(int);
 161 extern  void    close_all_except(int);
 162 extern  void    kill_asyncio    (int);
 163 #endif
 164
 165 # ifdef WORK_PIPE
 166 typedef void    (*addremove_io_fd_func)(int, int, int);
 167 extern  addremove_io_fd_func            addremove_io_fd;
 168 # else
 169 extern  void    handle_blocking_resp_sem(void *);
 170 typedef void    (*addremove_io_semaphore_func)(sem_ref, int);
 171 extern  addremove_io_semaphore_func     addremove_io_semaphore;
 172 # endif
 173
 174 # ifdef WORK_FORK
 175 extern  int                             worker_process;
 176 # endif
 177
 178 #endif  /* WORKER */
 179
 180 #if defined(HAVE_DROPROOT) && defined(WORK_FORK)
 181 extern void     fork_deferred_worker(void);
 182 #else
 183 # define        fork_deferred_worker()  do {} while (0)
 184 #endif
 185
 186 #endif  /* !NTP_WORKER_H */