src/dbus-loop.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2011 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   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   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdbool.h>
  23 #include <assert.h>
  24 #include <sys/epoll.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <sys/timerfd.h>
  28 #include <unistd.h>
  29
  30 #include "dbus-loop.h"
  31 #include "dbus-common.h"
  32 #include "util.h"
  33
  34 /* Minimal implementation of the dbus loop which integrates all dbus
  35  * events into a single epoll fd which we can triviall integrate with
  36  * other loops. Note that this is not used in the main systemd daemon
  37  * since we run a more elaborate mainloop there. */
  38
  39 typedef struct EpollData {
  40         int fd;
  41         void *object;
  42         bool is_timeout:1;
  43         bool fd_is_dupped:1;
  44 } EpollData;
  45
  46 static dbus_bool_t add_watch(DBusWatch *watch, void *data) {
  47         EpollData *e;
  48         struct epoll_event ev;
  49
  50         assert(watch);
  51
  52         e = new0(EpollData, 1);
  53         if (!e)
  54                 return FALSE;
  55
  56         e->fd = dbus_watch_get_unix_fd(watch);
  57         e->object = watch;
  58         e->is_timeout = false;
  59
  60         zero(ev);
  61         ev.events = bus_flags_to_events(watch);
  62         ev.data.ptr = e;
  63
  64         if (epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_ADD, e->fd, &ev) < 0) {
  65
  66                 if (errno != EEXIST) {
  67                         free(e);
  68                         return FALSE;
  69                 }
  70
  71                 /* Hmm, bloody D-Bus creates multiple watches on the
  72                  * same fd. epoll() does not like that. As a dirty
  73                  * hack we simply dup() the fd and hence get a second
  74                  * one we can safely add to the epoll(). */
  75
  76                 e->fd = dup(e->fd);
  77                 if (e->fd < 0) {
  78                         free(e);
  79                         return FALSE;
  80                 }
  81
  82                 if (epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_ADD, e->fd, &ev) < 0) {
  83                         close_nointr_nofail(e->fd);
  84                         free(e);
  85                         return FALSE;
  86                 }
  87
  88                 e->fd_is_dupped = true;
  89         }
  90
  91         dbus_watch_set_data(watch, e, NULL);
  92
  93         return TRUE;
  94 }
  95
  96 static void remove_watch(DBusWatch *watch, void *data) {
  97         EpollData *e;
  98
  99         assert(watch);
 100
 101         e = dbus_watch_get_data(watch);
 102         if (!e)
 103                 return;
 104
 105         assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_DEL, e->fd, NULL) >= 0);
 106
 107         if (e->fd_is_dupped)
 108                 close_nointr_nofail(e->fd);
 109
 110         free(e);
 111 }
 112
 113 static void toggle_watch(DBusWatch *watch, void *data) {
 114         EpollData *e;
 115         struct epoll_event ev;
 116
 117         assert(watch);
 118
 119         e = dbus_watch_get_data(watch);
 120         if (!e)
 121                 return;
 122
 123         zero(ev);
 124         ev.events = bus_flags_to_events(watch);
 125         ev.data.ptr = e;
 126
 127         assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_MOD, e->fd, &ev) == 0);
 128 }
 129
 130 static int timeout_arm(EpollData *e) {
 131         struct itimerspec its;
 132
 133         assert(e);
 134         assert(e->is_timeout);
 135
 136         zero(its);
 137
 138         if (dbus_timeout_get_enabled(e->object)) {
 139                 timespec_store(&its.it_value, dbus_timeout_get_interval(e->object) * USEC_PER_MSEC);
 140                 its.it_interval = its.it_value;
 141         }
 142
 143         if (timerfd_settime(e->fd, 0, &its, NULL) < 0)
 144                 return -errno;
 145
 146         return 0;
 147 }
 148
 149 static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data) {
 150         EpollData *e;
 151         struct epoll_event ev;
 152
 153         assert(timeout);
 154
 155         e = new0(EpollData, 1);
 156         if (!e)
 157                 return FALSE;
 158
 159         e->fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
 160         if (e->fd < 0)
 161                 goto fail;
 162
 163         e->object = timeout;
 164         e->is_timeout = true;
 165
 166         if (timeout_arm(e) < 0)
 167                 goto fail;
 168
 169         zero(ev);
 170         ev.events = EPOLLIN;
 171         ev.data.ptr = e;
 172
 173         if (epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_ADD, e->fd, &ev) < 0)
 174                 goto fail;
 175
 176         dbus_timeout_set_data(timeout, e, NULL);
 177
 178         return TRUE;
 179
 180 fail:
 181         if (e->fd >= 0)
 182                 close_nointr_nofail(e->fd);
 183
 184         free(e);
 185         return FALSE;
 186 }
 187
 188 static void remove_timeout(DBusTimeout *timeout, void *data) {
 189         EpollData *e;
 190
 191         assert(timeout);
 192
 193         e = dbus_timeout_get_data(timeout);
 194         if (!e)
 195                 return;
 196
 197         assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_DEL, e->fd, NULL) >= 0);
 198         close_nointr_nofail(e->fd);
 199         free(e);
 200 }
 201
 202 static void toggle_timeout(DBusTimeout *timeout, void *data) {
 203         EpollData *e;
 204         int r;
 205
 206         assert(timeout);
 207
 208         e = dbus_timeout_get_data(timeout);
 209         if (!e)
 210                 return;
 211
 212         r = timeout_arm(e);
 213         if (r < 0)
 214                 log_error("Failed to rearm timer: %s", strerror(-r));
 215 }
 216
 217 int bus_loop_open(DBusConnection *c) {
 218         int fd;
 219
 220         assert(c);
 221
 222         fd = epoll_create1(EPOLL_CLOEXEC);
 223         if (fd < 0)
 224                 return -errno;
 225
 226         if (!dbus_connection_set_watch_functions(c, add_watch, remove_watch, toggle_watch, INT_TO_PTR(fd), NULL) ||
 227             !dbus_connection_set_timeout_functions(c, add_timeout, remove_timeout, toggle_timeout, INT_TO_PTR(fd), NULL)) {
 228                 close_nointr_nofail(fd);
 229                 return -ENOMEM;
 230         }
 231
 232         return fd;
 233 }
 234
 235 int bus_loop_dispatch(int fd) {
 236         int n;
 237         struct epoll_event event;
 238         EpollData *d;
 239
 240         assert(fd >= 0);
 241
 242         zero(event);
 243
 244         n = epoll_wait(fd, &event, 1, 0);
 245         if (n < 0)
 246                 return errno == EAGAIN || errno == EINTR ? 0 : -errno;
 247
 248         assert_se(d = event.data.ptr);
 249
 250         if (d->is_timeout) {
 251                 DBusTimeout *t = d->object;
 252
 253                 if (dbus_timeout_get_enabled(t))
 254                         dbus_timeout_handle(t);
 255         } else {
 256                 DBusWatch *w = d->object;
 257
 258                 if (dbus_watch_get_enabled(w))
 259                         dbus_watch_handle(w, bus_events_to_flags(event.events));
 260         }
 261
 262         return 0;
 263 }