hurd/hurd/fd.h

   1 /* File descriptors.
   2    Copyright (C) 1993-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 #ifndef _HURD_FD_H
  20
  21 #define _HURD_FD_H      1
  22 #include <features.h>
  23
  24 #include <hurd/hurd_types.h>
  25 #include <hurd/port.h>
  26 #include <sys/socket.h>
  27 #include <sys/select.h>
  28 #include <fcntl.h>
  29 #include <bits/types/sigset_t.h>
  30
  31
  32 /* Structure representing a file descriptor.  */
  33
  34 struct hurd_fd
  35   {
  36     struct hurd_port port;      /* io server port.  */
  37     int flags;                  /* fcntl flags; locked by port.lock.  */
  38
  39     /* Normal port to the ctty.  When `port' is our ctty, this is a port to
  40        the same io object but which never returns EBACKGROUND; when not,
  41        this is nil.  */
  42     struct hurd_port ctty;
  43   };
  44
  45
  46 /* Current file descriptor table.  */
  47
  48 #if defined __USE_EXTERN_INLINES && defined _LIBC
  49 #include <lock-intern.h>
  50 extern int _hurd_dtablesize;
  51 extern struct hurd_fd **_hurd_dtable;
  52 extern struct mutex _hurd_dtable_lock; /* Locks those two variables.  */
  53 #endif
  54 \f
  55 #include <hurd/signal.h>
  56
  57 #ifndef _HURD_FD_H_EXTERN_INLINE
  58 #define _HURD_FD_H_EXTERN_INLINE __extern_inline
  59 #endif
  60
  61 /* Returns the descriptor cell for FD.  If FD is invalid or unused, return
  62    NULL.  The cell is unlocked; when ready to use it, lock it and check for
  63    it being unused.  */
  64
  65 extern struct hurd_fd *_hurd_fd_get (int fd);
  66
  67 #if defined __USE_EXTERN_INLINES && defined _LIBC
  68 # if IS_IN (libc)
  69 _HURD_FD_H_EXTERN_INLINE struct hurd_fd *
  70 _hurd_fd_get (int fd)
  71 {
  72   struct hurd_fd *descriptor;
  73
  74   HURD_CRITICAL_BEGIN;
  75   __mutex_lock (&_hurd_dtable_lock);
  76   if (__glibc_unlikely (fd < 0 || fd >= _hurd_dtablesize))
  77     descriptor = NULL;
  78   else
  79     {
  80       struct hurd_fd *cell = _hurd_dtable[fd];
  81       if (__glibc_unlikely (cell == NULL))
  82         /* No descriptor allocated at this index.  */
  83         descriptor = NULL;
  84       else
  85         {
  86           __spin_lock (&cell->port.lock);
  87           if (__glibc_unlikely (cell->port.port == MACH_PORT_NULL))
  88             /* The descriptor at this index has no port in it.
  89                This happens if it existed before but was closed.  */
  90             descriptor = NULL;
  91           else
  92             descriptor = cell;
  93           __spin_unlock (&cell->port.lock);
  94         }
  95     }
  96   __mutex_unlock (&_hurd_dtable_lock);
  97   HURD_CRITICAL_END;
  98
  99   return descriptor;
 100 }
 101 # endif
 102 #endif
 103
 104
 105 /* Evaluate EXPR with the variable `descriptor' bound to a pointer to the
 106    file descriptor structure for FD.   */
 107
 108 #define HURD_FD_USE(fd, expr)                                                 \
 109   ({ struct hurd_fd *descriptor = _hurd_fd_get (fd);                          \
 110      __glibc_unlikely (descriptor == NULL) ? EBADF : (expr); })
 111
 112 /* Evaluate EXPR with the variable `port' bound to the port to FD, and
 113    `ctty' bound to the ctty port.  */
 114
 115 #define HURD_DPORT_USE(fd, expr) \
 116   HURD_FD_USE ((fd), HURD_FD_PORT_USE (descriptor, (expr)))
 117
 118 /* Likewise, but FD is a pointer to the file descriptor structure.  */
 119 /* Also see HURD_FD_PORT_USE_CANCEL.  */
 120
 121 #define HURD_FD_PORT_USE(fd, expr)                                            \
 122   ({ error_t __result;                                                        \
 123      struct hurd_fd *const __d = (fd);                                        \
 124      struct hurd_userlink __ulink, __ctty_ulink;                              \
 125      io_t port, ctty;                                                         \
 126      void *crit = _hurd_critical_section_lock ();                             \
 127      __spin_lock (&__d->port.lock);                                           \
 128      if (__glibc_unlikely (__d->port.port == MACH_PORT_NULL))                 \
 129        {                                                                      \
 130          __spin_unlock (&__d->port.lock);                                     \
 131          _hurd_critical_section_unlock (crit);                                \
 132          __result = EBADF;                                                    \
 133        }                                                                      \
 134      else                                                                     \
 135        {                                                                      \
 136          ctty = _hurd_port_get (&__d->ctty, &__ctty_ulink);                   \
 137          port = _hurd_port_locked_get (&__d->port, &__ulink);                 \
 138          _hurd_critical_section_unlock (crit);                                \
 139          __result = (expr);                                                   \
 140          _hurd_port_free (&__d->port, &__ulink, port);                        \
 141          if (ctty != MACH_PORT_NULL)                                          \
 142            _hurd_port_free (&__d->ctty, &__ctty_ulink, ctty);                 \
 143        }                                                                      \
 144      __result; })
 145 \f
 146 #include <errno.h>
 147 #include <bits/types/error_t.h>
 148
 149 /* Check if ERR should generate a signal.
 150    Returns the signal to take, or zero if none.  */
 151
 152 extern int _hurd_fd_error_signal (error_t err) __COLD;
 153
 154 #ifdef __USE_EXTERN_INLINES
 155 _HURD_FD_H_EXTERN_INLINE int
 156 _hurd_fd_error_signal (error_t err)
 157 {
 158   switch (err)
 159     {
 160     case EMACH_SEND_INVALID_DEST:
 161     case EMIG_SERVER_DIED:
 162       /* The server has disappeared!  */
 163       return SIGLOST;
 164     case EPIPE:
 165       return SIGPIPE;
 166     default:
 167       /* Having a default case avoids -Wenum-switch warnings.  */
 168       return 0;
 169     }
 170 }
 171 #endif
 172
 173 /* Handle an error from an RPC on a file descriptor's port.  You should
 174    always use this function to handle errors from RPCs made on file
 175    descriptor ports.  Some errors are translated into signals.  */
 176
 177 extern error_t _hurd_fd_error (int fd, error_t err) __COLD;
 178
 179 #ifdef __USE_EXTERN_INLINES
 180 _HURD_FD_H_EXTERN_INLINE error_t
 181 _hurd_fd_error (int fd, error_t err)
 182 {
 183   int signo = _hurd_fd_error_signal (err);
 184   if (signo)
 185     {
 186       const struct hurd_signal_detail detail
 187         = { exc: 0, exc_code: 0, exc_subcode: 0, code: fd, error: err };
 188       _hurd_raise_signal (NULL, signo, &detail);
 189     }
 190   return err;
 191 }
 192 #endif
 193
 194 /* Handle error code ERR from an RPC on file descriptor FD's port.
 195    Set `errno' to the appropriate error code, and always return -1.  */
 196
 197 extern int __hurd_dfail (int fd, error_t err) __COLD;
 198
 199 #ifdef __USE_EXTERN_INLINES
 200 _HURD_FD_H_EXTERN_INLINE int
 201 __hurd_dfail (int fd, error_t err)
 202 {
 203   errno = _hurd_fd_error (fd, err);
 204   return -1;
 205 }
 206 #endif
 207
 208 /* Likewise, but do not raise SIGPIPE on EPIPE if flags contain
 209    MSG_NOSIGNAL.  */
 210
 211 extern int __hurd_sockfail (int fd, int flags, error_t err) __COLD;
 212
 213 #ifdef __USE_EXTERN_INLINES
 214 _HURD_FD_H_EXTERN_INLINE int
 215 __hurd_sockfail (int fd, int flags, error_t err)
 216 {
 217   if (!(flags & MSG_NOSIGNAL) || err != EPIPE)
 218     err = _hurd_fd_error (fd, err);
 219   errno = err;
 220   return -1;
 221 }
 222 #endif
 223 \f
 224 /* Set up *FD to have PORT its server port, doing appropriate ctty magic.
 225    Does no locking or unlocking.  */
 226
 227 extern void _hurd_port2fd (struct hurd_fd *fd, io_t port, int flags);
 228
 229 /* Allocate a new file descriptor and install PORT in it (doing any
 230    appropriate ctty magic); consumes a user reference on PORT.  FLAGS are
 231    as for `open'; only O_IGNORE_CTTY and O_CLOEXEC are meaningful, but all are
 232    saved.
 233
 234    If the descriptor table is full, set errno, and return -1.
 235    If DEALLOC is nonzero, deallocate PORT first.  */
 236
 237 extern int _hurd_intern_fd (io_t port, int flags, int dealloc);
 238
 239 /* Allocate a new file descriptor in the table and return it, locked.  The
 240    new descriptor number will be no less than FIRST_FD.  If the table is
 241    full, set errno to EMFILE and return NULL.  If FIRST_FD is negative or
 242    bigger than the size of the table, set errno to EINVAL and return NULL.  */
 243
 244 extern struct hurd_fd *_hurd_alloc_fd (int *fd_ptr, int first_fd);
 245
 246 /* Allocate a new file descriptor structure and initialize its port cells
 247    with PORT and CTTY.  (This does not affect the descriptor table.)  */
 248
 249 extern struct hurd_fd *_hurd_new_fd (io_t port, io_t ctty);
 250
 251 /* Close a file descriptor, making it available for future reallocation.  */
 252
 253 extern error_t _hurd_fd_close (struct hurd_fd *fd);
 254
 255 /* Read and write data from a file descriptor; just like `read' and `write'
 256    if OFFSET is -1, or like `pread' and `pwrite' if OFFSET is not -1.
 257    If successful, stores the amount actually read or written in *NBYTES.  */
 258
 259 extern error_t _hurd_fd_read (struct hurd_fd *fd,
 260                               void *buf, size_t *nbytes, __loff_t offset);
 261 extern error_t _hurd_fd_write (struct hurd_fd *fd,
 262                                const void *buf, size_t *nbytes, __loff_t offset);
 263
 264
 265 /* Call *RPC on PORT and/or CTTY; if a call on CTTY returns EBACKGROUND,
 266    generate SIGTTIN/SIGTTOU or EIO as appropriate.  */
 267
 268 extern error_t _hurd_ctty_input (io_t port, io_t ctty, error_t (*rpc) (io_t));
 269 extern error_t _hurd_ctty_output (io_t port, io_t ctty, error_t (*rpc) (io_t));
 270
 271
 272 /* The guts of `select' and `poll'.  Check the first NFDS descriptors
 273    either in POLLFDS (if nonnull) or in each of READFDS, WRITEFDS,
 274    EXCEPTFDS that is nonnull.  If TIMEOUT is not NULL, time out after
 275    waiting the interval specified therein.  If SIGMASK is nonnull,
 276    the set of blocked signals is temporarily set to that during this call.
 277    Returns the number of ready descriptors, or -1 for errors.  */
 278 struct pollfd;
 279 struct timespec;
 280 extern int _hurd_select (int nfds, struct pollfd *pollfds,
 281                          fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 282                          const struct timespec *timeout,
 283                          const sigset_t *sigmask);
 284
 285 /* Apply AT_FLAGS on FLAGS, in preparation for calling
 286    __hurd_file_name_lookup.  */
 287
 288 #if defined __USE_EXTERN_INLINES && defined _LIBC
 289 # if IS_IN (libc)
 290 _HURD_FD_H_EXTERN_INLINE error_t
 291 __hurd_at_flags (int *at_flags, int *flags)
 292 {
 293   if ((*at_flags & AT_SYMLINK_FOLLOW) && (*at_flags & AT_SYMLINK_NOFOLLOW))
 294     return EINVAL;
 295
 296   *flags |= (*at_flags & AT_SYMLINK_NOFOLLOW) ? O_NOLINK : 0;
 297   *at_flags &= ~AT_SYMLINK_NOFOLLOW;
 298
 299   if (*at_flags & AT_SYMLINK_FOLLOW)
 300     *flags &= ~O_NOLINK;
 301   *at_flags &= ~AT_SYMLINK_FOLLOW;
 302
 303   if (*at_flags & AT_NO_AUTOMOUNT)
 304     *flags |= O_NOTRANS;
 305   *at_flags &= ~AT_NO_AUTOMOUNT;
 306
 307   if (*at_flags != 0)
 308     return EINVAL;
 309
 310   return 0;
 311 }
 312 # endif
 313 #endif
 314
 315 /* Variant of file_name_lookup used in *at function implementations.
 316    AT_FLAGS may only contain AT_SYMLINK_FOLLOW or AT_SYMLINK_NOFOLLOW,
 317    which will remove and add O_NOLINK from FLAGS respectively.
 318    Other bits cause EINVAL.  */
 319 extern file_t __file_name_lookup_at (int fd, int at_flags,
 320                                      const char *file_name,
 321                                      int flags, mode_t mode);
 322
 323 /* Variant of file_name_split used in *at function implementations.  */
 324 extern file_t __file_name_split_at (int fd, const char *file_name,
 325                                     char **name);
 326
 327 /* Variant of directory_name_split used in *at function implementations.  */
 328 extern file_t __directory_name_split_at (int fd, const char *directory_name,
 329                                          char **name);
 330
 331
 332
 333 #endif  /* hurd/fd.h */