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 20typedef enum blocking_work_req_tag { 21 BLOCKING_GETNAMEINFO, 22 BLOCKING_GETADDRINFO, 23} blocking_work_req; 24 25typedef void (*blocking_work_callback)(blocking_work_req, void *, size_t, void *); 26 27typedef 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 */ 36typedef 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 47typedef struct { HANDLE thnd; } thread_type; 48typedef struct { HANDLE shnd; } sema_type; 49# else 50typedef pthread_t thread_type; 51typedef sem_t sema_type; 52# endif 53typedef thread_type *thr_ref; 54typedef sema_type *sem_ref; 55# endif 56 57/* 58 * 59 */ 60#if defined(WORK_FORK) 61 62typedef 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 volatile u_int resp_ready_seen; /* signal/scan */ 72 volatile u_int resp_ready_done; /* consumer/mainloop */ 73} blocking_child; 74 75#elif defined(WORK_THREAD) 76 77typedef struct blocking_child_tag { 78 /* 79 * blocking workitems and blocking_responses are 80 * dynamically-sized one-dimensional arrays of pointers to 81 * blocking worker requests and responses. 82 * 83 * IMPORTANT: This structure is shared between threads, and all 84 * access that is not atomic (especially queue operations) must 85 * hold the 'accesslock' semaphore to avoid data races. 86 * 87 * The resource management (thread/semaphore 88 * creation/destruction) functions and functions just testing a 89 * handle are safe because these are only changed by the main 90 * thread when no worker is running on the same data structure. 91 */ 92 int reusable; 93 sem_ref accesslock; /* shared access lock */ 94 thr_ref thread_ref; /* thread 'handle' */ 95 96 /* the reuest queue */ 97 blocking_pipe_header ** volatile 98 workitems; 99 volatile size_t workitems_alloc; 100 size_t head_workitem; /* parent */ 101 size_t tail_workitem; /* child */ 102 sem_ref workitems_pending; /* signalling */ 103 104 /* the response queue */ 105 blocking_pipe_header ** volatile 106 responses; 107 volatile size_t responses_alloc; 108 size_t head_response; /* child */ 109 size_t tail_response; /* parent */ 110 111 /* event handles / sem_t pointers */ 112 sem_ref wake_scheduled_sleep; 113 114 /* some systems use a pipe for notification, others a semaphore. 115 * Both employ the queue above for the actual data transfer. 116 */ 117#ifdef WORK_PIPE 118 int resp_read_pipe; /* parent */ 119 int resp_write_pipe; /* child */ 120 int ispipe; 121 void * resp_read_ctx; /* child */ 122#else 123 sem_ref responses_pending; /* signalling */ 124#endif 125 volatile u_int resp_ready_seen; /* signal/scan */ 126 volatile u_int resp_ready_done; /* consumer/mainloop */ 127 sema_type sem_table[4]; 128 thread_type thr_table[1]; 129} blocking_child; 130 131#endif /* WORK_THREAD */ 132 133/* we need some global tag to indicate any blocking child may be ready: */ 134extern volatile u_int blocking_child_ready_seen;/* signal/scan */ 135extern volatile u_int blocking_child_ready_done;/* consumer/mainloop */ 136 137extern blocking_child ** blocking_children; 138extern size_t blocking_children_alloc; 139extern int worker_per_query; /* boolean */ 140extern int intres_req_pending; 141 142extern u_int available_blocking_child_slot(void); 143extern int queue_blocking_request(blocking_work_req, void *, 144 size_t, blocking_work_callback, 145 void *); 146extern int queue_blocking_response(blocking_child *, 147 blocking_pipe_header *, size_t, 148 const blocking_pipe_header *); 149extern void process_blocking_resp(blocking_child *); 150extern void harvest_blocking_responses(void); 151extern int send_blocking_req_internal(blocking_child *, 152 blocking_pipe_header *, 153 void *); 154extern int send_blocking_resp_internal(blocking_child *, 155 blocking_pipe_header *); 156extern blocking_pipe_header * 157 receive_blocking_req_internal(blocking_child *); 158extern blocking_pipe_header * 159 receive_blocking_resp_internal(blocking_child *); 160extern int blocking_child_common(blocking_child *); 161extern void exit_worker(int) 162 __attribute__ ((__noreturn__)); 163extern int worker_sleep(blocking_child *, time_t); 164extern void worker_idle_timer_fired(void); 165extern void interrupt_worker_sleep(void); 166extern int req_child_exit(blocking_child *); 167#ifndef HAVE_IO_COMPLETION_PORT 168extern int pipe_socketpair(int fds[2], int *is_pipe); 169extern void close_all_beyond(int); 170extern void close_all_except(int); 171extern void kill_asyncio (int); 172#endif 173 174extern void worker_global_lock(int inOrOut); 175 176# ifdef WORK_PIPE 177typedef void (*addremove_io_fd_func)(int, int, int); 178extern addremove_io_fd_func addremove_io_fd; 179# else 180extern void handle_blocking_resp_sem(void *); 181typedef void (*addremove_io_semaphore_func)(sem_ref, int); 182extern addremove_io_semaphore_func addremove_io_semaphore; 183# endif 184 185# ifdef WORK_FORK 186extern int worker_process; 187# endif 188 189#endif /* WORKER */ 190 191#if defined(HAVE_DROPROOT) && defined(WORK_FORK) 192extern void fork_deferred_worker(void); 193#else 194# define fork_deferred_worker() do {} while (0) 195#endif 196 197#endif /* !NTP_WORKER_H */ 198