dbus-pollable-set-epoll.c
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* dbus-pollable-set-epoll.c - a pollable set implemented via Linux epoll(4)
*
* Copyright © 2011 Nokia Corporation
*
* SPDX-License-Identifier: AFL-2.1 OR GPL-2.0-or-later
*
* Licensed under the Academic Free License version 2.1
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
*/
#include <config.h>
#include "dbus-pollable-set.h"
#include <dbus/dbus-internals.h>
#include <dbus/dbus-sysdeps.h>
#ifndef __linux__
# error This file is for Linux epoll(4)
#endif
#include <errno.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <unistd.h>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct {
DBusPollableSet parent;
int epfd;
} DBusPollableSetEpoll;
static inline DBusPollableSetEpoll *
socket_set_epoll_cast (DBusPollableSet *set)
{
_dbus_assert (set->cls == &_dbus_pollable_set_epoll_class);
return (DBusPollableSetEpoll *) set;
}
/* this is safe to call on a partially-allocated socket set */
static void
socket_set_epoll_free (DBusPollableSet *set)
{
DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
if (self == NULL)
return;
if (self->epfd != -1)
close (self->epfd);
dbus_free (self);
}
DBusPollableSet *
_dbus_pollable_set_epoll_new (void)
{
DBusPollableSetEpoll *self;
self = dbus_new0 (DBusPollableSetEpoll, 1);
if (self == NULL)
return NULL;
self->parent.cls = &_dbus_pollable_set_epoll_class;
self->epfd = epoll_create1 (EPOLL_CLOEXEC);
if (self->epfd == -1)
{
int flags;
/* the size hint is ignored unless you have a rather old kernel,
* but must be positive on some versions, so just pick something
* arbitrary; it's a hint, not a limit */
self->epfd = epoll_create (42);
flags = fcntl (self->epfd, F_GETFD, 0);
if (flags != -1)
fcntl (self->epfd, F_SETFD, flags | FD_CLOEXEC);
}
if (self->epfd == -1)
{
socket_set_epoll_free ((DBusPollableSet *) self);
return NULL;
}
return (DBusPollableSet *) self;
}
static uint32_t
watch_flags_to_epoll_events (unsigned int flags)
{
uint32_t events = 0;
if (flags & DBUS_WATCH_READABLE)
events |= EPOLLIN;
if (flags & DBUS_WATCH_WRITABLE)
events |= EPOLLOUT;
return events;
}
static unsigned int
epoll_events_to_watch_flags (uint32_t events)
{
short flags = 0;
if (events & EPOLLIN)
flags |= DBUS_WATCH_READABLE;
if (events & EPOLLOUT)
flags |= DBUS_WATCH_WRITABLE;
if (events & EPOLLHUP)
flags |= DBUS_WATCH_HANGUP;
if (events & EPOLLERR)
flags |= DBUS_WATCH_ERROR;
return flags;
}
static dbus_bool_t
socket_set_epoll_add (DBusPollableSet *set,
DBusPollable fd,
unsigned int flags,
dbus_bool_t enabled)
{
DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
struct epoll_event event;
int err;
_DBUS_ZERO (event);
event.data.fd = fd;
if (enabled)
{
event.events = watch_flags_to_epoll_events (flags);
}
else
{
/* We need to add *something* to reserve space in the kernel's data
* structures: see socket_set_epoll_disable for more details */
event.events = EPOLLET;
}
if (epoll_ctl (self->epfd, EPOLL_CTL_ADD, fd, &event) == 0)
return TRUE;
/* Anything except ENOMEM, ENOSPC means we have an internal error. */
err = errno;
switch (err)
{
case ENOMEM:
case ENOSPC:
/* be silent: this is basically OOM, which our callers are expected
* to cope with */
break;
case EBADF:
_dbus_warn ("Bad fd %d", fd);
break;
case EEXIST:
_dbus_warn ("fd %d added and then added again", fd);
break;
default:
_dbus_warn ("Misc error when trying to watch fd %d: %s", fd,
strerror (err));
break;
}
return FALSE;
}
static void
socket_set_epoll_enable (DBusPollableSet *set,
DBusPollable fd,
unsigned int flags)
{
DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
struct epoll_event event;
int err;
_DBUS_ZERO (event);
event.data.fd = fd;
event.events = watch_flags_to_epoll_events (flags);
if (epoll_ctl (self->epfd, EPOLL_CTL_MOD, fd, &event) == 0)
return;
err = errno;
/* Enabling a file descriptor isn't allowed to fail, even for OOM, so we
* do our best to avoid all of these. */
switch (err)
{
case EBADF:
_dbus_warn ("Bad fd %d", fd);
break;
case ENOENT:
_dbus_warn ("fd %d enabled before it was added", fd);
break;
case ENOMEM:
_dbus_warn ("Insufficient memory to change watch for fd %d", fd);
break;
default:
_dbus_warn ("Misc error when trying to watch fd %d: %s", fd,
strerror (err));
break;
}
}
static void
socket_set_epoll_disable (DBusPollableSet *set,
DBusPollable fd)
{
DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
struct epoll_event event;
int err;
/* The naive thing to do would be EPOLL_CTL_DEL, but that'll probably
* free resources in the kernel. When we come to do socket_set_epoll_enable,
* there might not be enough resources to bring it back!
*
* The next idea you might have is to set the flags to 0. However, events
* always trigger on EPOLLERR and EPOLLHUP, even if libdbus isn't actually
* delivering them to a DBusWatch. Because epoll is level-triggered by
* default, we'll busy-loop on an unhandled error or hangup; not good.
*
* So, let's set it to be edge-triggered: then the worst case is that
* we return from poll immediately on one iteration, ignore it because no
* watch is enabled, then go back to normal. When we re-enable a watch
* we'll switch back to level-triggered and be notified again (verified to
* work on 2.6.32). Compile this file with -DTEST_BEHAVIOUR_OF_EPOLLET for
* test code.
*/
_DBUS_ZERO (event);
event.data.fd = fd;
event.events = EPOLLET;
if (epoll_ctl (self->epfd, EPOLL_CTL_MOD, fd, &event) == 0)
return;
err = errno;
_dbus_warn ("Error when trying to watch fd %d: %s", fd,
strerror (err));
}
static void
socket_set_epoll_remove (DBusPollableSet *set,
DBusPollable fd)
{
DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
int err;
/* Kernels < 2.6.9 require a non-NULL struct pointer, even though its
* contents are ignored */
struct epoll_event dummy;
_DBUS_ZERO (dummy);
if (epoll_ctl (self->epfd, EPOLL_CTL_DEL, fd, &dummy) == 0)
return;
err = errno;
_dbus_warn ("Error when trying to remove fd %d: %s", fd, strerror (err));
}
/* Optimally, this should be the same as in DBusLoop: we use it to translate
* between struct epoll_event and DBusSocketEvent without allocating heap
* memory. */
#define N_STACK_DESCRIPTORS 64
static int
socket_set_epoll_poll (DBusPollableSet *set,
DBusPollableEvent *revents,
int max_events,
int timeout_ms)
{
DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
struct epoll_event events[N_STACK_DESCRIPTORS];
int n_ready;
int i;
_dbus_assert (max_events > 0);
n_ready = epoll_wait (self->epfd, events,
MIN (_DBUS_N_ELEMENTS (events), max_events),
timeout_ms);
if (n_ready <= 0)
return n_ready;
for (i = 0; i < n_ready; i++)
{
revents[i].fd = events[i].data.fd;
revents[i].flags = epoll_events_to_watch_flags (events[i].events);
}
return n_ready;
}
DBusPollableSetClass _dbus_pollable_set_epoll_class = {
socket_set_epoll_free,
socket_set_epoll_add,
socket_set_epoll_remove,
socket_set_epoll_enable,
socket_set_epoll_disable,
socket_set_epoll_poll
};
#ifdef TEST_BEHAVIOUR_OF_EPOLLET
/* usage: cat /dev/null | ./epoll
*
* desired output:
* ctl ADD: 0
* wait for HUP, edge-triggered: 1
* wait for HUP again: 0
* ctl MOD: 0
* wait for HUP: 1
*/
#include <sys/epoll.h>
#include <stdio.h>
int
main (void)
{
struct epoll_event input;
struct epoll_event output;
int epfd = epoll_create1 (EPOLL_CLOEXEC);
int fd = 0; /* stdin */
int ret;
_DBUS_ZERO (input);
input.events = EPOLLHUP | EPOLLET;
ret = epoll_ctl (epfd, EPOLL_CTL_ADD, fd, &input);
printf ("ctl ADD: %d\n", ret);
ret = epoll_wait (epfd, &output, 1, -1);
printf ("wait for HUP, edge-triggered: %d\n", ret);
ret = epoll_wait (epfd, &output, 1, 1);
printf ("wait for HUP again: %d\n", ret);
input.events = EPOLLHUP;
ret = epoll_ctl (epfd, EPOLL_CTL_MOD, fd, &input);
printf ("ctl MOD: %d\n", ret);
ret = epoll_wait (epfd, &output, 1, -1);
printf ("wait for HUP: %d\n", ret);
return 0;
}
#endif /* TEST_BEHAVIOUR_OF_EPOLLET */
#endif /* !DOXYGEN_SHOULD_SKIP_THIS */
DBUS_WATCH_READABLE
@ DBUS_WATCH_READABLE
As in POLLIN.
Definition dbus-connection.h:63
DBUS_WATCH_WRITABLE
@ DBUS_WATCH_WRITABLE
As in POLLOUT.
Definition dbus-connection.h:64
DBUS_WATCH_HANGUP
@ DBUS_WATCH_HANGUP
As in POLLHUP (can't watch for it, but can be present in current state passed to dbus_watch_handle())...
Definition dbus-connection.h:70
DBUS_WATCH_ERROR
@ DBUS_WATCH_ERROR
As in POLLERR (can't watch for this, but can be present in current state passed to dbus_watch_handle(...
Definition dbus-connection.h:65
_dbus_assert
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
Definition dbus-internals.h:153
_dbus_warn
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
Definition dbus-internals.c:278
_DBUS_N_ELEMENTS
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
Definition dbus-internals.h:189
_DBUS_ZERO
#define _DBUS_ZERO(object)
Sets all bits in an object to zero.
Definition dbus-internals.h:194
NULL
#define NULL
A null pointer, defined appropriately for C or C++.
Definition dbus-macros.h:51
TRUE
#define TRUE
Expands to "1".
Definition dbus-macros.h:41
FALSE
#define FALSE
Expands to "0".
Definition dbus-macros.h:44
dbus_free
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition dbus-memory.c:710
dbus_new0
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition dbus-memory.h:60
dbus_bool_t
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition dbus-types.h:37