src/shared/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 Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 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   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser 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 }