mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-10-31 03:26:19 +01:00
426fab1eca
First, there's no reason not to use the new `epoll_create1` system call, which quickly obsoleted `epoll_create` which has an obsolete and unused size argument. But more specifically, it offers `EPOLL_CLOEXEC` which we want to use for general hygeine - there's no reason to potentially leak this file descriptor to forked processes. (GLib itself carefully closes file descriptors when forking child processes, but it may be linked with other software that doesn't; notably in my case for example the Rust standard library does not do this and hence relies more on the application code using `O_CLOEXEC` and variants) This is just a drive-by fix; I saw the system call when I was using `strace` to debug something else in rpm-ostree.
148 lines
4.3 KiB
C
148 lines
4.3 KiB
C
/*
|
|
* Copyright © 2021 Ole André Vadla Ravnås
|
|
*
|
|
* SPDX-License-Identifier: LGPL-2.1-or-later
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#if defined (HAVE_EPOLL_CREATE)
|
|
#include <sys/epoll.h>
|
|
#elif defined (HAVE_KQUEUE)
|
|
#include <sys/event.h>
|
|
#include <sys/time.h>
|
|
#endif
|
|
|
|
#include "giounix-private.h"
|
|
|
|
#define G_TEMP_FAILURE_RETRY(expression) \
|
|
({ \
|
|
gssize __result; \
|
|
\
|
|
do \
|
|
__result = (gssize) (expression); \
|
|
while (__result == -1 && errno == EINTR); \
|
|
\
|
|
__result; \
|
|
})
|
|
|
|
static gboolean g_fd_is_regular_file (int fd) G_GNUC_UNUSED;
|
|
|
|
gboolean
|
|
_g_fd_is_pollable (int fd)
|
|
{
|
|
/*
|
|
* Determining whether a file-descriptor (FD) is pollable turns out to be
|
|
* quite hard.
|
|
*
|
|
* We used to detect this by attempting to lseek() and check if it failed with
|
|
* ESPIPE, and if so we'd consider the FD pollable. But this turned out to not
|
|
* work on e.g. PTYs and other devices that are pollable.
|
|
*
|
|
* Another approach that was considered was to call fstat() and if it failed
|
|
* we'd assume that the FD is pollable, and if it succeeded we'd consider it
|
|
* pollable as long as it's not a regular file. This seemed to work alright
|
|
* except for FDs backed by simple devices, such as /dev/null.
|
|
*
|
|
* There are however OS-specific methods that allow us to figure this out with
|
|
* absolute certainty:
|
|
*/
|
|
|
|
#if defined (HAVE_EPOLL_CREATE)
|
|
/*
|
|
* Linux
|
|
*
|
|
* The answer we seek is provided by the kernel's file_can_poll():
|
|
* https://github.com/torvalds/linux/blob/2ab38c17aac10bf55ab3efde4c4db3893d8691d2/include/linux/poll.h#L81-L84
|
|
* But we cannot probe that by using poll() as the returned events for
|
|
* non-pollable FDs are always IN | OUT.
|
|
*
|
|
* The best option then seems to be using epoll, as it will refuse to add FDs
|
|
* where file_can_poll() returns FALSE.
|
|
*/
|
|
|
|
int efd;
|
|
struct epoll_event ev = { 0, };
|
|
gboolean add_succeeded;
|
|
|
|
efd = epoll_create1 (EPOLL_CLOEXEC);
|
|
if (efd == -1)
|
|
g_error ("epoll_create1 () failed: %s", g_strerror (errno));
|
|
|
|
ev.events = EPOLLIN;
|
|
|
|
add_succeeded = epoll_ctl (efd, EPOLL_CTL_ADD, fd, &ev) == 0;
|
|
|
|
close (efd);
|
|
|
|
return add_succeeded;
|
|
#elif defined (HAVE_KQUEUE)
|
|
/*
|
|
* Apple OSes and BSDs
|
|
*
|
|
* Like on Linux, we cannot use poll() to do the probing, but kqueue does
|
|
* the trick as it will refuse to add non-pollable FDs. (Except for regular
|
|
* files, which we need to special-case. Even though kqueue does support them,
|
|
* poll() does not.)
|
|
*/
|
|
|
|
int kfd;
|
|
struct kevent ev;
|
|
gboolean add_succeeded;
|
|
|
|
if (g_fd_is_regular_file (fd))
|
|
return FALSE;
|
|
|
|
kfd = kqueue ();
|
|
if (kfd == -1)
|
|
g_error ("kqueue () failed: %s", g_strerror (errno));
|
|
|
|
EV_SET (&ev, fd, EVFILT_READ, EV_ADD, 0, 0, NULL);
|
|
|
|
add_succeeded =
|
|
G_TEMP_FAILURE_RETRY (kevent (kfd, &ev, 1, NULL, 0, NULL)) == 0;
|
|
|
|
close (kfd);
|
|
|
|
return add_succeeded;
|
|
#else
|
|
/*
|
|
* Other UNIXes (AIX, QNX, Solaris, etc.)
|
|
*
|
|
* We can rule out regular files, but devices such as /dev/null will be
|
|
* reported as pollable even though they're not. This is hopefully good
|
|
* enough for most use-cases, but easy to expand on later if needed.
|
|
*/
|
|
|
|
return !g_fd_is_regular_file (fd);
|
|
#endif
|
|
}
|
|
|
|
static gboolean
|
|
g_fd_is_regular_file (int fd)
|
|
{
|
|
struct stat st;
|
|
|
|
if (G_TEMP_FAILURE_RETRY (fstat (fd, &st)) == -1)
|
|
return FALSE;
|
|
|
|
return S_ISREG (st.st_mode);
|
|
}
|