sysdeps/unix/sysv/linux/tst-epoll.c

   1 /* Basic tests for Linux epoll_* wrappers.
   2    Copyright (C) 2022-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <errno.h>
  20 #include <intprops.h>
  21 #include <support/check.h>
  22 #include <support/support.h>
  23 #include <support/xsignal.h>
  24 #include <support/xunistd.h>
  25 #include <support/xtime.h>
  26 #include <stdlib.h>
  27 #include <sys/epoll.h>
  28
  29 /* The test focus on checking if the timeout argument is correctly handled
  30    by glibc wrappers.  */
  31
  32 static void
  33 handler (int sig)
  34 {
  35 }
  36
  37 typedef int (*epoll_wait_check_t) (int, struct epoll_event *, int,
  38                                    int, const sigset_t *);
  39
  40 static void
  41 test_epoll_basic (epoll_wait_check_t epoll_wait_check)
  42 {
  43   {
  44     sigset_t ss_usr1;
  45     sigemptyset (&ss_usr1);
  46     sigaddset (&ss_usr1, SIGUSR1);
  47     TEST_COMPARE (sigprocmask (SIG_BLOCK, &ss_usr1, NULL), 0);
  48   }
  49
  50   int fds[2][2];
  51   xpipe (fds[0]);
  52   xpipe (fds[1]);
  53
  54   sigset_t ss;
  55   TEST_COMPARE (sigprocmask (SIG_SETMASK, NULL, &ss), 0);
  56   sigdelset (&ss, SIGUSR1);
  57
  58   int efd = epoll_create1 (0);
  59   TEST_VERIFY_EXIT (efd != -1);
  60
  61   struct epoll_event event;
  62
  63   event.data.fd = fds[1][0];
  64   event.events = EPOLLIN | EPOLLET;
  65   TEST_COMPARE (epoll_ctl (efd, EPOLL_CTL_ADD, fds[1][0], &event), 0);
  66
  67   pid_t parent = getpid ();
  68   pid_t p = xfork ();
  69   if (p == 0)
  70     {
  71       xclose (fds[0][1]);
  72       xclose (fds[1][0]);
  73
  74       event.data.fd = fds[0][0];
  75       event.events = EPOLLIN | EPOLLET;
  76       TEST_COMPARE (epoll_ctl (efd, EPOLL_CTL_ADD, fds[0][0], &event), 0);
  77
  78       int e;
  79       do
  80         {
  81           if (getppid () != parent)
  82             FAIL_EXIT1 ("getppid()=%d != parent=%d", getppid(), parent);
  83
  84           errno = 0;
  85           e = epoll_wait_check (efd, &event, 1, 500, &ss);
  86         }
  87       while (e == 0);
  88
  89       TEST_COMPARE (e, -1);
  90       TEST_COMPARE (errno, EINTR);
  91
  92       TEMP_FAILURE_RETRY (write (fds[1][1], "foo", 3));
  93
  94       exit (0);
  95     }
  96
  97   xclose (fds[0][0]);
  98   xclose (fds[1][1]);
  99
 100   /* Wait some time so child is blocked on the syscall.  */
 101   nanosleep (&(struct timespec) {0, 10000000}, NULL);
 102   TEST_COMPARE (kill (p, SIGUSR1), 0);
 103
 104   int e = epoll_wait_check (efd, &event, 1, 500000000, &ss);
 105   TEST_COMPARE (e, 1);
 106   TEST_VERIFY (event.events & EPOLLIN);
 107
 108   xclose (fds[0][1]);
 109   xclose (fds[1][0]);
 110   xclose (efd);
 111 }
 112
 113
 114 static void
 115 test_epoll_large_timeout (epoll_wait_check_t epoll_wait_check)
 116 {
 117   timer_t t = support_create_timer (0, 100000000, true, NULL);
 118
 119   int fds[2];
 120   xpipe (fds);
 121
 122   fd_set rfds;
 123   FD_ZERO (&rfds);
 124   FD_SET (fds[0], &rfds);
 125
 126   sigset_t ss;
 127   TEST_COMPARE (sigprocmask (SIG_SETMASK, NULL, &ss), 0);
 128   sigdelset (&ss, SIGALRM);
 129
 130   int efd = epoll_create1 (0);
 131   TEST_VERIFY_EXIT (efd != -1);
 132
 133   struct epoll_event event;
 134   event.data.fd = fds[0];
 135   event.events = EPOLLIN | EPOLLET;
 136   TEST_COMPARE (epoll_ctl (efd, EPOLL_CTL_ADD, fds[0], &event), 0);
 137
 138   int tmo = TYPE_MAXIMUM (int);
 139   TEST_COMPARE (epoll_wait_check (efd, &event, 1, tmo, &ss), -1);
 140   TEST_VERIFY (errno == EINTR || errno == EOVERFLOW);
 141
 142   TEST_COMPARE (epoll_wait_check (efd, &event, 1, -1, &ss), -1);
 143   TEST_VERIFY (errno == EINTR || errno == EOVERFLOW);
 144
 145   support_delete_timer (t);
 146
 147   xclose (fds[0]);
 148   xclose (fds[1]);
 149   xclose (efd);
 150 }
 151
 152
 153 static int
 154 epoll_wait_check (int epfd, struct epoll_event *ev, int maxev, int tmo,
 155                   const sigset_t *ss)
 156 {
 157   sigset_t orig;
 158   TEST_COMPARE (sigprocmask (SIG_SETMASK, ss, &orig), 0);
 159   int r = epoll_wait (epfd, ev, maxev, tmo);
 160   TEST_COMPARE (sigprocmask (SIG_SETMASK, &orig, NULL), 0);
 161   return r;
 162 }
 163
 164 static int
 165 epoll_pwait_check (int epfd, struct epoll_event *ev, int maxev, int tmo,
 166                    const sigset_t *ss)
 167 {
 168   return epoll_pwait (epfd, ev, maxev, tmo, ss);
 169 }
 170
 171 static int
 172 epoll_pwait2_check (int epfd, struct epoll_event *ev, int maxev, int tmo,
 173                     const sigset_t *ss)
 174 {
 175   time_t s = tmo == -1 ? TYPE_MAXIMUM (time_t) : tmo / 1000;
 176   long int ns = tmo == -1 ? 0 : (tmo % 1000) * 1000000;
 177   return epoll_pwait2 (epfd, ev, maxev, &(struct timespec) { s, ns }, ss);
 178 }
 179
 180 static int
 181 do_test (void)
 182 {
 183   struct epoll_event ev;
 184
 185   {
 186     struct sigaction sa;
 187     sa.sa_handler = handler;
 188     sa.sa_flags = 0;
 189     sigemptyset (&sa.sa_mask);
 190     xsigaction (SIGUSR1, &sa, NULL);
 191
 192     sa.sa_handler = SIG_IGN;
 193     xsigaction (SIGCHLD, &sa, NULL);
 194   }
 195
 196   int r = epoll_pwait2 (-1, &ev, 0, NULL, NULL);
 197   TEST_COMPARE (r, -1);
 198   bool pwait2_supported = errno != ENOSYS;
 199
 200   test_epoll_basic (epoll_wait_check);
 201   test_epoll_basic (epoll_pwait_check);
 202   if (pwait2_supported)
 203     test_epoll_basic (epoll_pwait2_check);
 204
 205   test_epoll_large_timeout (epoll_wait_check);
 206   test_epoll_large_timeout (epoll_pwait_check);
 207   if (pwait2_supported)
 208     test_epoll_large_timeout (epoll_pwait2_check);
 209
 210   return 0;
 211 }
 212
 213 #include <support/test-driver.c>