---
name: "sd_event_get_fd"
section: "3"
platform: "linux"
package: "systemd-libs"
version: "262.1-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/sd_event_get_fd"
---

# sd\_event\_get\_fd(3)

Obtain a file descriptor to poll for event loop events

## NAME

sd\_event\_get\_fd - Obtain a file descriptor to poll for event loop events

## SYNOPSIS

```
#include <systemd/sd-event.h>
```

**int sd\_event\_get\_fd(sd\_event \****event***);**

## DESCRIPTION

**sd\_event\_get\_fd()** returns the file descriptor that an event loop object returned by the [**sd\_event\_new**(3)](/sd_event_new/3.md) function uses to wait for events. This file descriptor may itself be polled for **POLLIN**/**EPOLLIN** events. This makes it possible to embed an [**sd-event**(3)](/sd-event/3.md) event loop into another, possibly foreign, event loop.

The returned file descriptor refers to an [**epoll**(7)](/epoll/7.md) object. It is recommended not to alter it by invoking [**epoll\_ctl**(2)](/epoll_ctl/2.md) on it, in order to avoid interference with the event loop's inner logic and assumptions.

## RETURN VALUE

On success, **sd\_event\_get\_fd()** returns a non-negative file descriptor. On failure, it returns a negative errno-style error code.

### Errors

Returned errors may indicate the following problems:

**-EINVAL**

*event* is not a valid pointer to an sd\_event structure.

**-ECHILD**

The event loop has been created in a different process, library or module instance.

## EXAMPLES

**Example 1. Integration in the GLib event loop**

```
/* SPDX-License-Identifier: MIT-0 */
#include <stdlib.h>
#include <glib.h>
#include <systemd/sd-event.h>
typedef struct SDEventSource {
  GSource source;
  GPollFD pollfd;
  sd_event *event;
} SDEventSource;
static gboolean event_prepare(GSource *source, gint *timeout_) {
  sd_event *event = ((SDEventSource *) source)->event;
  /* GLib does not guarantee that check() is always called between two
   * consecutive prepare() invocations. For example, if another thread
   * attaches/removes a source with poll fds to this GMainContext while
   * the main thread is inside poll(), g_main_context_check_unlocked()
   * returns immediately without calling any source's check().
   *
   * If check() was skipped, the sd_event is still in SD_EVENT_ARMED
   * state.  Return FALSE to let the normal poll() -> check() -> dispatch()
   * path complete the cycle. */
  if (sd_event_get_state(event) == SD_EVENT_ARMED)
    return FALSE;
  return sd_event_prepare(event) > 0;
}
static gboolean event_check(GSource *source) {
  return sd_event_wait(((SDEventSource *)source)->event, 0) > 0;
}
static gboolean event_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) {
  return sd_event_dispatch(((SDEventSource *)source)->event) > 0;
}
static void event_finalize(GSource *source) {
  sd_event_unref(((SDEventSource *)source)->event);
}
static GSourceFuncs event_funcs = {
  .prepare = event_prepare,
  .check = event_check,
  .dispatch = event_dispatch,
  .finalize = event_finalize,
};
GSource *g_sd_event_create_source(sd_event *event) {
  SDEventSource *source;
  source = (SDEventSource *)g_source_new(&event_funcs, sizeof(SDEventSource));
  source->event = sd_event_ref(event);
  source->pollfd.fd = sd_event_get_fd(event);
  source->pollfd.events = G_IO_IN | G_IO_HUP | G_IO_ERR;
  g_source_add_poll((GSource *)source, &source->pollfd);
  return (GSource *)source;
}
```

## NOTES

Functions described here are available as a shared library, which can be compiled against and linked to with the **libsystemd** [**pkg-config**(1)](/pkg-config/1.md) file.

All functions listed here are thread-agnostic and only a single thread may operate on a given object at any given time. Different threads may access the same object at different times. Multiple independent objects may be used from different threads in parallel.

The code described here uses [**getenv**(3)](/getenv/3.md), which is declared to be not multi-thread-safe. This means that the code calling the functions described here must not call [**setenv**(3)](/setenv/3.md) from a parallel thread. It is recommended to only do calls to **setenv()** from an early phase of the program when no other threads have been started.

## HISTORY

**sd\_event\_get\_fd()** was added in version 217.

## SEE ALSO

[**sd-event**(3)](/sd-event/3.md), [**sd\_event\_new**(3)](/sd_event_new/3.md), [**sd\_event\_wait**(3)](/sd_event_wait/3.md), [**epoll\_ctl**(2)](/epoll_ctl/2.md), [**epoll**(7)](/epoll/7.md)