sysdeps/pthread/sem_open.c

   1 /* Copyright (C) 2002-2023 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <fcntl.h>
  19 #include <semaphore.h>
  20 #include <stdarg.h>
  21 #include <unistd.h>
  22 #include <sys/mman.h>
  23 #include "semaphoreP.h"
  24 #include <shm-directory.h>
  25 #include <sem_routines.h>
  26 #include <futex-internal.h>
  27 #include <libc-lock.h>
  28
  29 #if !PTHREAD_IN_LIBC
  30 /* The private names are not exported from libc.  */
  31 # define __link link
  32 # define __unlink unlink
  33 #endif
  34
  35 sem_t *
  36 __sem_open (const char *name, int oflag, ...)
  37 {
  38   int fd;
  39   int open_flags;
  40   sem_t *result;
  41
  42   /* Check that shared futexes are supported.  */
  43   int err = futex_supports_pshared (PTHREAD_PROCESS_SHARED);
  44   if (err != 0)
  45     {
  46       __set_errno (err);
  47       return SEM_FAILED;
  48     }
  49
  50   struct shmdir_name dirname;
  51   int ret = __shm_get_name (&dirname, name, true);
  52   if (ret != 0)
  53     {
  54       __set_errno (ret);
  55       return SEM_FAILED;
  56     }
  57
  58   /* Disable asynchronous cancellation.  */
  59 #ifdef __libc_ptf_call
  60   int state;
  61   __libc_ptf_call (__pthread_setcancelstate,
  62                    (PTHREAD_CANCEL_DISABLE, &state), 0);
  63 #endif
  64
  65   /* If the semaphore object has to exist simply open it.  */
  66   if ((oflag & O_CREAT) == 0 || (oflag & O_EXCL) == 0)
  67     {
  68       open_flags = O_RDWR | O_NOFOLLOW | O_CLOEXEC;
  69       open_flags |= (oflag & ~(O_CREAT|O_ACCMODE));
  70     try_again:
  71       fd = __open (dirname.name, open_flags);
  72
  73       if (fd == -1)
  74         {
  75           /* If we are supposed to create the file try this next.  */
  76           if ((oflag & O_CREAT) != 0 && errno == ENOENT)
  77             goto try_create;
  78
  79           /* Return.  errno is already set.  */
  80         }
  81       else
  82         /* Check whether we already have this semaphore mapped and
  83            create one if necessary.  */
  84         result = __sem_check_add_mapping (name, fd, SEM_FAILED);
  85     }
  86   else
  87     {
  88       /* We have to open a temporary file first since it must have the
  89          correct form before we can start using it.  */
  90       mode_t mode;
  91       unsigned int value;
  92       va_list ap;
  93
  94     try_create:
  95       va_start (ap, oflag);
  96
  97       mode = va_arg (ap, mode_t);
  98       value = va_arg (ap, unsigned int);
  99
 100       va_end (ap);
 101
 102       if (value > SEM_VALUE_MAX)
 103         {
 104           __set_errno (EINVAL);
 105           result = SEM_FAILED;
 106           goto out;
 107         }
 108
 109       /* Create the initial file content.  */
 110       union
 111       {
 112         sem_t initsem;
 113         struct new_sem newsem;
 114       } sem;
 115
 116       __new_sem_open_init (&sem.newsem, value);
 117
 118       /* Initialize the remaining bytes as well.  */
 119       memset ((char *) &sem.initsem + sizeof (struct new_sem), '\0',
 120               sizeof (sem_t) - sizeof (struct new_sem));
 121
 122       char tmpfname[] = SHMDIR "sem.XXXXXX";
 123       int retries = 0;
 124 #define NRETRIES 50
 125       while (1)
 126         {
 127           /* We really want to use mktemp here.  We cannot use mkstemp
 128              since the file must be opened with a specific mode.  The
 129              mode cannot later be set since then we cannot apply the
 130              file create mask.  */
 131           if (__mktemp (tmpfname) == NULL)
 132             {
 133               result = SEM_FAILED;
 134               goto out;
 135             }
 136
 137           /* Open the file.  Make sure we do not overwrite anything.  */
 138           open_flags = O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC;
 139           fd = __open (tmpfname, open_flags, mode);
 140           if (fd == -1)
 141             {
 142               if (errno == EEXIST)
 143                 {
 144                   if (++retries < NRETRIES)
 145                     {
 146                       /* Restore the six placeholder bytes before the
 147                          null terminator before the next attempt.  */
 148                       memcpy (tmpfname + sizeof (tmpfname) - 7, "XXXXXX", 6);
 149                       continue;
 150                     }
 151
 152                   __set_errno (EAGAIN);
 153                 }
 154
 155               result = SEM_FAILED;
 156               goto out;
 157             }
 158
 159           /* We got a file.  */
 160           break;
 161         }
 162
 163       if (TEMP_FAILURE_RETRY (write (fd, &sem.initsem, sizeof (sem_t)))
 164           == sizeof (sem_t)
 165           /* Map the sem_t structure from the file.  */
 166           && (result = (sem_t *) __mmap (NULL, sizeof (sem_t),
 167                                          PROT_READ | PROT_WRITE, MAP_SHARED,
 168                                          fd, 0)) != MAP_FAILED)
 169         {
 170           /* Create the file.  Don't overwrite an existing file.  */
 171           if (__link (tmpfname, dirname.name) != 0)
 172             {
 173               /* Undo the mapping.  */
 174               __munmap (result, sizeof (sem_t));
 175
 176               /* Reinitialize 'result'.  */
 177               result = SEM_FAILED;
 178
 179               /* This failed.  If O_EXCL is not set and the problem was
 180                  that the file exists, try again.  */
 181               if ((oflag & O_EXCL) == 0 && errno == EEXIST)
 182                 {
 183                   /* Remove the file.  */
 184                   __unlink (tmpfname);
 185
 186                   /* Close the file.  */
 187                   __close (fd);
 188
 189                   goto try_again;
 190                 }
 191             }
 192           else
 193             /* Insert the mapping into the search tree.  This also
 194                determines whether another thread sneaked by and already
 195                added such a mapping despite the fact that we created it.  */
 196             result = __sem_check_add_mapping (name, fd, result);
 197         }
 198
 199       /* Now remove the temporary name.  This should never fail.  If
 200          it fails we leak a file name.  Better fix the kernel.  */
 201       __unlink (tmpfname);
 202     }
 203
 204   /* Map the mmap error to the error we need.  */
 205   if (MAP_FAILED != (void *) SEM_FAILED && result == MAP_FAILED)
 206     result = SEM_FAILED;
 207
 208   /* We don't need the file descriptor anymore.  */
 209   if (fd != -1)
 210     {
 211       /* Do not disturb errno.  */
 212       int save = errno;
 213       __close (fd);
 214       errno = save;
 215     }
 216
 217 out:
 218 #ifdef __libc_ptf_call
 219   __libc_ptf_call (__pthread_setcancelstate, (state, NULL), 0);
 220 #endif
 221
 222   return result;
 223 }
 224 #if PTHREAD_IN_LIBC
 225 versioned_symbol (libc, __sem_open, sem_open, GLIBC_2_34);
 226 # if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_1_1, GLIBC_2_34)
 227 compat_symbol (libpthread, __sem_open, sem_open, GLIBC_2_1_1);
 228 # endif
 229 #else /* !PTHREAD_IN_LIBC */
 230 strong_alias (__sem_open, sem_open)
 231 #endif