lib/tevent/tevent_poll.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    main select loop and event handling
   4    Copyright (C) Andrew Tridgell        2003-2005
   5    Copyright (C) Stefan Metzmacher      2005-2009
   6
   7      ** NOTE! The following LGPL license applies to the tevent
   8      ** library. This does NOT imply that all of Samba is released
   9      ** under the LGPL
  10
  11    This library is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU Lesser General Public
  13    License as published by the Free Software Foundation; either
  14    version 3 of the License, or (at your option) any later version.
  15
  16    This library is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19    Lesser General Public License for more details.
  20
  21    You should have received a copy of the GNU Lesser General Public
  22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "replace.h"
  26 #include "system/filesys.h"
  27 #include "system/select.h"
  28 #include "tevent.h"
  29 #include "tevent_util.h"
  30 #include "tevent_internal.h"
  31
  32 struct poll_event_context {
  33         /*
  34          * These two arrays are maintained together.
  35          */
  36         struct pollfd *fds;
  37         struct tevent_fd **fd_events;
  38         uint64_t num_fds;
  39
  40         /* information for exiting from the event loop */
  41         int exit_code;
  42 };
  43
  44 /*
  45   create a select_event_context structure.
  46 */
  47 static int poll_event_context_init(struct tevent_context *ev)
  48 {
  49         struct poll_event_context *poll_ev;
  50
  51         poll_ev = talloc_zero(ev, struct poll_event_context);
  52         if (poll_ev == NULL) {
  53                 return -1;
  54         }
  55         ev->additional_data = poll_ev;
  56         return 0;
  57 }
  58
  59 /*
  60   destroy an fd_event
  61 */
  62 static int poll_event_fd_destructor(struct tevent_fd *fde)
  63 {
  64         struct tevent_context *ev = fde->event_ctx;
  65         struct poll_event_context *poll_ev = NULL;
  66         struct tevent_fd *moved_fde;
  67         uint64_t del_idx = fde->additional_flags;
  68
  69         if (ev == NULL) {
  70                 goto done;
  71         }
  72
  73         poll_ev = talloc_get_type_abort(
  74                 ev->additional_data, struct poll_event_context);
  75
  76         moved_fde = poll_ev->fd_events[poll_ev->num_fds-1];
  77         poll_ev->fd_events[del_idx] = moved_fde;
  78         poll_ev->fds[del_idx] = poll_ev->fds[poll_ev->num_fds-1];
  79         moved_fde->additional_flags = del_idx;
  80
  81         poll_ev->num_fds -= 1;
  82 done:
  83         return tevent_common_fd_destructor(fde);
  84 }
  85
  86 /*
  87   add a fd based event
  88   return NULL on failure (memory allocation error)
  89 */
  90 static struct tevent_fd *poll_event_add_fd(struct tevent_context *ev,
  91                                            TALLOC_CTX *mem_ctx,
  92                                            int fd, uint16_t flags,
  93                                            tevent_fd_handler_t handler,
  94                                            void *private_data,
  95                                            const char *handler_name,
  96                                            const char *location)
  97 {
  98         struct poll_event_context *poll_ev = talloc_get_type_abort(
  99                 ev->additional_data, struct poll_event_context);
 100         struct pollfd *pfd;
 101         struct tevent_fd *fde;
 102
 103         fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
 104                                    handler, private_data,
 105                                    handler_name, location);
 106         if (fde == NULL) {
 107                 return NULL;
 108         }
 109
 110         /* we allocate 16 slots to avoid a lot of reallocations */
 111         if (talloc_array_length(poll_ev->fds) == poll_ev->num_fds) {
 112                 struct pollfd *tmp_fds;
 113                 struct tevent_fd **tmp_fd_events;
 114                 tmp_fds = talloc_realloc(
 115                         poll_ev, poll_ev->fds, struct pollfd,
 116                         poll_ev->num_fds + 16);
 117                 if (tmp_fds == NULL) {
 118                         TALLOC_FREE(fde);
 119                         return NULL;
 120                 }
 121                 poll_ev->fds = tmp_fds;
 122
 123                 tmp_fd_events = talloc_realloc(
 124                         poll_ev, poll_ev->fd_events, struct tevent_fd *,
 125                         poll_ev->num_fds + 16);
 126                 if (tmp_fd_events == NULL) {
 127                         TALLOC_FREE(fde);
 128                         return NULL;
 129                 }
 130                 poll_ev->fd_events = tmp_fd_events;
 131         }
 132
 133         pfd = &poll_ev->fds[poll_ev->num_fds];
 134
 135         pfd->fd = fd;
 136
 137         pfd->events = 0;
 138         pfd->revents = 0;
 139
 140         if (flags & TEVENT_FD_READ) {
 141                 pfd->events |= (POLLIN|POLLHUP);
 142         }
 143         if (flags & TEVENT_FD_WRITE) {
 144                 pfd->events |= (POLLOUT);
 145         }
 146
 147         fde->additional_flags = poll_ev->num_fds;
 148         poll_ev->fd_events[poll_ev->num_fds] = fde;
 149
 150         poll_ev->num_fds += 1;
 151
 152         talloc_set_destructor(fde, poll_event_fd_destructor);
 153
 154         return fde;
 155 }
 156
 157 /*
 158   set the fd event flags
 159 */
 160 static void poll_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
 161 {
 162         struct poll_event_context *poll_ev = talloc_get_type_abort(
 163                 fde->event_ctx->additional_data, struct poll_event_context);
 164         uint64_t idx = fde->additional_flags;
 165         uint16_t pollflags = 0;
 166
 167         if (flags & TEVENT_FD_READ) {
 168                 pollflags |= (POLLIN|POLLHUP);
 169         }
 170         if (flags & TEVENT_FD_WRITE) {
 171                 pollflags |= (POLLOUT);
 172         }
 173
 174         poll_ev->fds[idx].events = pollflags;
 175
 176         fde->flags = flags;
 177 }
 178
 179 /*
 180   event loop handling using select()
 181 */
 182 static int poll_event_loop_poll(struct tevent_context *ev,
 183                                 struct timeval *tvalp)
 184 {
 185         struct poll_event_context *poll_ev = talloc_get_type_abort(
 186                 ev->additional_data, struct poll_event_context);
 187         struct tevent_fd *fde;
 188         int pollrtn;
 189         int timeout = -1;
 190
 191         if (ev->signal_events && tevent_common_check_signal(ev)) {
 192                 return 0;
 193         }
 194
 195         if (tvalp != NULL) {
 196                 timeout = tvalp->tv_sec * 1000;
 197                 timeout += (tvalp->tv_usec + 999) / 1000;
 198         }
 199
 200         pollrtn = poll(poll_ev->fds, poll_ev->num_fds, timeout);
 201
 202         if (pollrtn == -1 && errno == EINTR && ev->signal_events) {
 203                 tevent_common_check_signal(ev);
 204                 return 0;
 205         }
 206
 207         if (pollrtn == -1 && errno == EBADF) {
 208                 /* the socket is dead! this should never
 209                    happen as the socket should have first been
 210                    made readable and that should have removed
 211                    the event, so this must be a bug. This is a
 212                    fatal error. */
 213                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
 214                              "ERROR: EBADF on poll_event_loop_once\n");
 215                 poll_ev->exit_code = EBADF;
 216                 return -1;
 217         }
 218
 219         if (pollrtn == 0 && tvalp) {
 220                 /* we don't care about a possible delay here */
 221                 tevent_common_loop_timer_delay(ev);
 222                 return 0;
 223         }
 224
 225         if (pollrtn > 0) {
 226                 /* at least one file descriptor is ready - check
 227                    which ones and call the handler, being careful to allow
 228                    the handler to remove itself when called */
 229                 for (fde = ev->fd_events; fde; fde = fde->next) {
 230                         struct pollfd *pfd;
 231                         uint64_t pfd_idx = fde->additional_flags;
 232                         uint16_t flags = 0;
 233
 234                         pfd = &poll_ev->fds[pfd_idx];
 235
 236                         if (pfd->revents & (POLLIN|POLLHUP|POLLERR)) {
 237                                 flags |= TEVENT_FD_READ;
 238                         }
 239                         if (pfd->revents & POLLOUT) {
 240                                 flags |= TEVENT_FD_WRITE;
 241                         }
 242                         if (flags != 0) {
 243                                 fde->handler(ev, fde, flags,
 244                                              fde->private_data);
 245                                 break;
 246                         }
 247                 }
 248         }
 249
 250         return 0;
 251 }
 252
 253 /*
 254   do a single event loop using the events defined in ev
 255 */
 256 static int poll_event_loop_once(struct tevent_context *ev,
 257                                 const char *location)
 258 {
 259         struct timeval tval;
 260
 261         if (ev->signal_events &&
 262             tevent_common_check_signal(ev)) {
 263                 return 0;
 264         }
 265
 266         if (ev->immediate_events &&
 267             tevent_common_loop_immediate(ev)) {
 268                 return 0;
 269         }
 270
 271         tval = tevent_common_loop_timer_delay(ev);
 272         if (tevent_timeval_is_zero(&tval)) {
 273                 return 0;
 274         }
 275
 276         return poll_event_loop_poll(ev, &tval);
 277 }
 278
 279 static const struct tevent_ops poll_event_ops = {
 280         .context_init           = poll_event_context_init,
 281         .add_fd                 = poll_event_add_fd,
 282         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
 283         .get_fd_flags           = tevent_common_fd_get_flags,
 284         .set_fd_flags           = poll_event_set_fd_flags,
 285         .add_timer              = tevent_common_add_timer,
 286         .schedule_immediate     = tevent_common_schedule_immediate,
 287         .add_signal             = tevent_common_add_signal,
 288         .loop_once              = poll_event_loop_once,
 289         .loop_wait              = tevent_common_loop_wait,
 290 };
 291
 292 _PRIVATE_ bool tevent_poll_init(void)
 293 {
 294         return tevent_register_backend("poll", &poll_event_ops);
 295 }