1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ 2 /* dbus-socket-set-epoll.c - a socket set implemented via Linux epoll(4) 3 * 4 * Copyright 2011 Nokia Corporation 5 * 6 * Licensed under the Academic Free License version 2.1 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 21 * MA 02110-1301 USA 22 * 23 */ 24 25 #include <config.h> 26 #include "dbus-socket-set.h" 27 28 #include <dbus/dbus-internals.h> 29 #include <dbus/dbus-sysdeps.h> 30 31 #ifndef __linux__ 32 # error This file is for Linux epoll(4) 33 #endif 34 35 #include <errno.h> 36 #include <fcntl.h> 37 #include <sys/epoll.h> 38 #include <unistd.h> 39 40 #ifndef DOXYGEN_SHOULD_SKIP_THIS 41 42 typedef struct { 43 DBusSocketSet parent; 44 int epfd; 45 } DBusSocketSetEpoll; 46 47 static inline DBusSocketSetEpoll * 48 socket_set_epoll_cast (DBusSocketSet *set) 49 { 50 _dbus_assert (set->cls == &_dbus_socket_set_epoll_class); 51 return (DBusSocketSetEpoll *) set; 52 } 53 54 /* this is safe to call on a partially-allocated socket set */ 55 static void 56 socket_set_epoll_free (DBusSocketSet *set) 57 { 58 DBusSocketSetEpoll *self = socket_set_epoll_cast (set); 59 60 if (self == NULL) 61 return; 62 63 if (self->epfd != -1) 64 close (self->epfd); 65 66 dbus_free (self); 67 } 68 69 DBusSocketSet * 70 _dbus_socket_set_epoll_new (void) 71 { 72 DBusSocketSetEpoll *self; 73 74 self = dbus_new0 (DBusSocketSetEpoll, 1); 75 76 if (self == NULL) 77 return NULL; 78 79 self->parent.cls = &_dbus_socket_set_epoll_class; 80 81 self->epfd = epoll_create1 (EPOLL_CLOEXEC); 82 83 if (self->epfd == -1) 84 { 85 int flags; 86 87 /* the size hint is ignored unless you have a rather old kernel, 88 * but must be positive on some versions, so just pick something 89 * arbitrary; it's a hint, not a limit */ 90 self->epfd = epoll_create (42); 91 92 flags = fcntl (self->epfd, F_GETFD, 0); 93 94 if (flags != -1) 95 fcntl (self->epfd, F_SETFD, flags | FD_CLOEXEC); 96 } 97 98 if (self->epfd == -1) 99 { 100 socket_set_epoll_free ((DBusSocketSet *) self); 101 return NULL; 102 } 103 104 return (DBusSocketSet *) self; 105 } 106 107 static uint32_t 108 watch_flags_to_epoll_events (unsigned int flags) 109 { 110 uint32_t events = 0; 111 112 if (flags & DBUS_WATCH_READABLE) 113 events |= EPOLLIN; 114 if (flags & DBUS_WATCH_WRITABLE) 115 events |= EPOLLOUT; 116 117 return events; 118 } 119 120 static unsigned int 121 epoll_events_to_watch_flags (uint32_t events) 122 { 123 short flags = 0; 124 125 if (events & EPOLLIN) 126 flags |= DBUS_WATCH_READABLE; 127 if (events & EPOLLOUT) 128 flags |= DBUS_WATCH_WRITABLE; 129 if (events & EPOLLHUP) 130 flags |= DBUS_WATCH_HANGUP; 131 if (events & EPOLLERR) 132 flags |= DBUS_WATCH_ERROR; 133 134 return flags; 135 } 136 137 static dbus_bool_t 138 socket_set_epoll_add (DBusSocketSet *set, 139 int fd, 140 unsigned int flags, 141 dbus_bool_t enabled) 142 { 143 DBusSocketSetEpoll *self = socket_set_epoll_cast (set); 144 struct epoll_event event; 145 int err; 146 147 event.data.fd = fd; 148 149 if (enabled) 150 { 151 event.events = watch_flags_to_epoll_events (flags); 152 } 153 else 154 { 155 /* We need to add *something* to reserve space in the kernel's data 156 * structures: see socket_set_epoll_disable for more details */ 157 event.events = EPOLLET; 158 } 159 160 if (epoll_ctl (self->epfd, EPOLL_CTL_ADD, fd, &event) == 0) 161 return TRUE; 162 163 /* Anything except ENOMEM, ENOSPC means we have an internal error. */ 164 err = errno; 165 switch (err) 166 { 167 case ENOMEM: 168 case ENOSPC: 169 /* be silent: this is basically OOM, which our callers are expected 170 * to cope with */ 171 break; 172 173 case EBADF: 174 _dbus_warn ("Bad fd %d\n", fd); 175 break; 176 177 case EEXIST: 178 _dbus_warn ("fd %d added and then added again\n", fd); 179 break; 180 181 default: 182 _dbus_warn ("Misc error when trying to watch fd %d: %s\n", fd, 183 strerror (err)); 184 break; 185 } 186 187 return FALSE; 188 } 189 190 static void 191 socket_set_epoll_enable (DBusSocketSet *set, 192 int fd, 193 unsigned int flags) 194 { 195 DBusSocketSetEpoll *self = socket_set_epoll_cast (set); 196 struct epoll_event event; 197 int err; 198 199 event.data.fd = fd; 200 event.events = watch_flags_to_epoll_events (flags); 201 202 if (epoll_ctl (self->epfd, EPOLL_CTL_MOD, fd, &event) == 0) 203 return; 204 205 err = errno; 206 207 /* Enabling a file descriptor isn't allowed to fail, even for OOM, so we 208 * do our best to avoid all of these. */ 209 switch (err) 210 { 211 case EBADF: 212 _dbus_warn ("Bad fd %d\n", fd); 213 break; 214 215 case ENOENT: 216 _dbus_warn ("fd %d enabled before it was added\n", fd); 217 break; 218 219 case ENOMEM: 220 _dbus_warn ("Insufficient memory to change watch for fd %d\n", fd); 221 break; 222 223 default: 224 _dbus_warn ("Misc error when trying to watch fd %d: %s\n", fd, 225 strerror (err)); 226 break; 227 } 228 } 229 230 static void 231 socket_set_epoll_disable (DBusSocketSet *set, 232 int fd) 233 { 234 DBusSocketSetEpoll *self = socket_set_epoll_cast (set); 235 struct epoll_event event; 236 int err; 237 238 /* The naive thing to do would be EPOLL_CTL_DEL, but that'll probably 239 * free resources in the kernel. When we come to do socket_set_epoll_enable, 240 * there might not be enough resources to bring it back! 241 * 242 * The next idea you might have is to set the flags to 0. However, events 243 * always trigger on EPOLLERR and EPOLLHUP, even if libdbus isn't actually 244 * delivering them to a DBusWatch. Because epoll is level-triggered by 245 * default, we'll busy-loop on an unhandled error or hangup; not good. 246 * 247 * So, let's set it to be edge-triggered: then the worst case is that 248 * we return from poll immediately on one iteration, ignore it because no 249 * watch is enabled, then go back to normal. When we re-enable a watch 250 * we'll switch back to level-triggered and be notified again (verified to 251 * work on 2.6.32). Compile this file with -DTEST_BEHAVIOUR_OF_EPOLLET for 252 * test code. 253 */ 254 event.data.fd = fd; 255 event.events = EPOLLET; 256 257 if (epoll_ctl (self->epfd, EPOLL_CTL_MOD, fd, &event) == 0) 258 return; 259 260 err = errno; 261 _dbus_warn ("Error when trying to watch fd %d: %s\n", fd, 262 strerror (err)); 263 } 264 265 static void 266 socket_set_epoll_remove (DBusSocketSet *set, 267 int fd) 268 { 269 DBusSocketSetEpoll *self = socket_set_epoll_cast (set); 270 int err; 271 /* Kernels < 2.6.9 require a non-NULL struct pointer, even though its 272 * contents are ignored */ 273 struct epoll_event dummy = { 0 }; 274 275 if (epoll_ctl (self->epfd, EPOLL_CTL_DEL, fd, &dummy) == 0) 276 return; 277 278 err = errno; 279 _dbus_warn ("Error when trying to remove fd %d: %s\n", fd, strerror (err)); 280 } 281 282 /* Optimally, this should be the same as in DBusLoop: we use it to translate 283 * between struct epoll_event and DBusSocketEvent without allocating heap 284 * memory. */ 285 #define N_STACK_DESCRIPTORS 64 286 287 static int 288 socket_set_epoll_poll (DBusSocketSet *set, 289 DBusSocketEvent *revents, 290 int max_events, 291 int timeout_ms) 292 { 293 DBusSocketSetEpoll *self = socket_set_epoll_cast (set); 294 struct epoll_event events[N_STACK_DESCRIPTORS]; 295 int n_ready; 296 int i; 297 298 _dbus_assert (max_events > 0); 299 300 n_ready = epoll_wait (self->epfd, events, 301 MIN (_DBUS_N_ELEMENTS (events), max_events), 302 timeout_ms); 303 304 if (n_ready <= 0) 305 return n_ready; 306 307 for (i = 0; i < n_ready; i++) 308 { 309 revents[i].fd = events[i].data.fd; 310 revents[i].flags = epoll_events_to_watch_flags (events[i].events); 311 } 312 313 return n_ready; 314 } 315 316 DBusSocketSetClass _dbus_socket_set_epoll_class = { 317 socket_set_epoll_free, 318 socket_set_epoll_add, 319 socket_set_epoll_remove, 320 socket_set_epoll_enable, 321 socket_set_epoll_disable, 322 socket_set_epoll_poll 323 }; 324 325 #ifdef TEST_BEHAVIOUR_OF_EPOLLET 326 /* usage: cat /dev/null | ./epoll 327 * 328 * desired output: 329 * ctl ADD: 0 330 * wait for HUP, edge-triggered: 1 331 * wait for HUP again: 0 332 * ctl MOD: 0 333 * wait for HUP: 1 334 */ 335 336 #include <sys/epoll.h> 337 338 #include <stdio.h> 339 340 int 341 main (void) 342 { 343 struct epoll_event input; 344 struct epoll_event output; 345 int epfd = epoll_create1 (EPOLL_CLOEXEC); 346 int fd = 0; /* stdin */ 347 int ret; 348 349 input.events = EPOLLHUP | EPOLLET; 350 ret = epoll_ctl (epfd, EPOLL_CTL_ADD, fd, &input); 351 printf ("ctl ADD: %d\n", ret); 352 353 ret = epoll_wait (epfd, &output, 1, -1); 354 printf ("wait for HUP, edge-triggered: %d\n", ret); 355 356 ret = epoll_wait (epfd, &output, 1, 1); 357 printf ("wait for HUP again: %d\n", ret); 358 359 input.events = EPOLLHUP; 360 ret = epoll_ctl (epfd, EPOLL_CTL_MOD, fd, &input); 361 printf ("ctl MOD: %d\n", ret); 362 363 ret = epoll_wait (epfd, &output, 1, -1); 364 printf ("wait for HUP: %d\n", ret); 365 366 return 0; 367 } 368 369 #endif /* TEST_BEHAVIOUR_OF_EPOLLET */ 370 371 #endif /* !DOXYGEN_SHOULD_SKIP_THIS */ 372
