Home | History | Annotate | Line # | Download | only in gdbsupport 
      1 /* Utility for handling interrupted syscalls by signals.
      2 
      3    Copyright (C) 2020-2024 Free Software Foundation, Inc.
      4 
      5    This file is part of GDB.
      6 
      7    This program is free software; you can redistribute it and/or modify
      8    it under the terms of the GNU General Public License as published by
      9    the Free Software Foundation; either version 3 of the License, or
     10    (at your option) any later version.
     11 
     12    This program is distributed in the hope that it will be useful,
     13    but WITHOUT ANY WARRANTY; without even the implied warranty of
     14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     15    GNU General Public License for more details.
     16 
     17    You should have received a copy of the GNU General Public License
     18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
     19 
     20 #ifndef GDBSUPPORT_EINTR_H
     21 #define GDBSUPPORT_EINTR_H
     22 
     23 #include <cerrno>
     24 #include <sys/types.h>
     25 #include <sys/wait.h>
     26 #include <sys/stat.h>
     27 #include <fcntl.h>
     28 #include <unistd.h>
     29 
     30 namespace gdb
     31 {
     32 /* Repeat a system call interrupted with a signal.
     33 
     34    A utility for handling interrupted syscalls, which return with error
     35    and set the errno to EINTR.  The interrupted syscalls can be repeated,
     36    until successful completion.  This utility avoids wrapping code with
     37    manual checks for such errors which are highly repetitive.
     38 
     39    For example, with:
     40 
     41    ssize_t ret;
     42    do
     43      {
     44        errno = 0;
     45        ret = ::write (pipe[1], "+", 1);
     46      }
     47    while (ret == -1 && errno == EINTR);
     48 
     49    You could wrap it by writing the wrapped form:
     50 
     51    ssize_t ret = gdb::handle_eintr (-1, ::write, pipe[1], "+", 1);
     52 
     53    ERRVAL specifies the failure value indicating that the call to the
     54    F function with ARGS... arguments was possibly interrupted with a
     55    signal.  */
     56 
     57 template<typename ErrorValType, typename Fun, typename... Args>
     58 inline auto
     59 handle_eintr (ErrorValType errval, const Fun &f, const Args &... args)
     60   -> decltype (f (args...))
     61 {
     62   decltype (f (args...)) ret;
     63 
     64   do
     65     {
     66       errno = 0;
     67       ret = f (args...);
     68     }
     69   while (ret == errval && errno == EINTR);
     70 
     71   return ret;
     72 }
     73 
     74 #ifdef HAVE_WAITPID
     75 inline pid_t
     76 waitpid (pid_t pid, int *wstatus, int options)
     77 {
     78   return gdb::handle_eintr (-1, ::waitpid, pid, wstatus, options);
     79 }
     80 #endif /* HAVE_WAITPID */
     81 
     82 inline int
     83 open (const char *pathname, int flags)
     84 {
     85   return gdb::handle_eintr (-1, ::open, pathname, flags);
     86 }
     87 
     88 #ifdef HAVE_WAIT
     89 inline pid_t
     90 wait (int *wstatus)
     91 {
     92   return gdb::handle_eintr (-1, ::wait, wstatus);
     93 }
     94 #endif /* HAVE_WAIT */
     95 
     96 inline int
     97 close (int fd)
     98 {
     99   return gdb::handle_eintr (-1, ::close, fd);
    100 }
    101 
    102 inline ssize_t
    103 read (int fd, void *buf, size_t count)
    104 {
    105   return gdb::handle_eintr (-1, ::read, fd, buf, count);
    106 }
    107 
    108 template<typename... Args> int fcntl (int fd, int op, Args... args)
    109 {
    110   return gdb::handle_eintr (-1, ::fcntl, fd, op, args...);
    111 }
    112 
    113 inline ssize_t
    114 write (int fd, const void *buf, size_t count)
    115 {
    116   return gdb::handle_eintr (-1, ::write, fd, buf, count);
    117 }
    118 
    119 } /* namespace gdb */
    120 
    121 #endif /* GDBSUPPORT_EINTR_H */
    122