sysdeps/pthread/sem_open.c

   1 /* Copyright (C) 2002-2024 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 #define SEM_OPEN_FLAGS (O_RDWR | O_NOFOLLOW | O_CLOEXEC)
  36
  37 sem_t *
  38 __sem_open (const char *name, int oflag, ...)
  39 {
  40   int fd;
  41   sem_t *result;
  42
  43   /* Check that shared futexes are supported.  */
  44   int err = futex_supports_pshared (PTHREAD_PROCESS_SHARED);
  45   if (err != 0)
  46     {
  47       __set_errno (err);
  48       return SEM_FAILED;
  49     }
  50
  51   struct shmdir_name dirname;
  52   int ret = __shm_get_name (&dirname, name, true);
  53   if (ret != 0)
  54     {
  55       __set_errno (ret);
  56       return SEM_FAILED;
  57     }
  58
  59   /* Disable asynchronous cancellation.  */
  60 #ifdef __libc_ptf_call
  61   int state;
  62   __libc_ptf_call (__pthread_setcancelstate,
  63                    (PTHREAD_CANCEL_DISABLE, &state), 0);
  64 #endif
  65
  66   /* If the semaphore object has to exist simply open it.  */
  67   if ((oflag & O_CREAT) == 0 || (oflag & O_EXCL) == 0)
  68     {
  69     try_again:
  70       fd = __open (dirname.name, (oflag & O_EXCL) | SEM_OPEN_FLAGS);
  71
  72       if (fd == -1)
  73         {
  74           /* If we are supposed to create the file try this next.  */
  75           if ((oflag & O_CREAT) != 0 && errno == ENOENT)
  76             goto try_create;
  77
  78           /* Return.  errno is already set.  */
  79         }
  80       else
  81         /* Check whether we already have this semaphore mapped and
  82            create one if necessary.  */
  83         result = __sem_check_add_mapping (name, fd, SEM_FAILED);
  84     }
  85   else
  86     {
  87       /* We have to open a temporary file first since it must have the
  88          correct form before we can start using it.  */
  89       mode_t mode;
  90       unsigned int value;
  91       va_list ap;
  92
  93     try_create:
  94       va_start (ap, oflag);
  95
  96       mode = va_arg (ap, mode_t);
  97       value = va_arg (ap, unsigned int);
  98
  99       va_end (ap);
 100
 101       if (value > SEM_VALUE_MAX)
 102         {
 103           __set_errno (EINVAL);
 104           result = SEM_FAILED;
 105           goto out;
 106         }
 107
 108       /* Create the initial file content.  */
 109       union
 110       {
 111         sem_t initsem;
 112         struct new_sem newsem;
 113       } sem;
 114
 115       __new_sem_open_init (&sem.newsem, value);
 116
 117       /* Initialize the remaining bytes as well.  */
 118       memset ((char *) &sem.initsem + sizeof (struct new_sem), '\0',
 119               sizeof (sem_t) - sizeof (struct new_sem));
 120
 121       char tmpfname[] = SHMDIR "sem.XXXXXX";
 122       int retries = 0;
 123 #define NRETRIES 50
 124       while (1)
 125         {
 126           /* We really want to use mktemp here.  We cannot use mkstemp
 127              since the file must be opened with a specific mode.  The
 128              mode cannot later be set since then we cannot apply the
 129              file create mask.  */
 130           if (__mktemp (tmpfname) == NULL)
 131             {
 132               result = SEM_FAILED;
 133               goto out;
 134             }
 135
 136           /* Open the file.  Make sure we do not overwrite anything.  */
 137           fd = __open (tmpfname, O_CREAT | O_EXCL | SEM_OPEN_FLAGS, mode);
 138           if (fd == -1)
 139             {
 140               if (errno == EEXIST)
 141                 {
 142                   if (++retries < NRETRIES)
 143                     {
 144                       /* Restore the six placeholder bytes before the
 145                          null terminator before the next attempt.  */
 146                       memcpy (tmpfname + sizeof (tmpfname) - 7, "XXXXXX", 6);
 147                       continue;
 148                     }
 149
 150                   __set_errno (EAGAIN);
 151                 }
 152
 153               result = SEM_FAILED;
 154               goto out;
 155             }
 156
 157           /* We got a file.  */
 158           break;
 159         }
 160
 161       if (TEMP_FAILURE_RETRY (write (fd, &sem.initsem, sizeof (sem_t)))
 162           == sizeof (sem_t)
 163           /* Map the sem_t structure from the file.  */
 164           && (result = (sem_t *) __mmap (NULL, sizeof (sem_t),
 165                                          PROT_READ | PROT_WRITE, MAP_SHARED,
 166                                          fd, 0)) != MAP_FAILED)
 167         {
 168           /* Create the file.  Don't overwrite an existing file.  */
 169           if (__link (tmpfname, dirname.name) != 0)
 170             {
 171               /* Undo the mapping.  */
 172               __munmap (result, sizeof (sem_t));
 173
 174               /* Reinitialize 'result'.  */
 175               result = SEM_FAILED;
 176
 177               /* This failed.  If O_EXCL is not set and the problem was
 178                  that the file exists, try again.  */
 179               if ((oflag & O_EXCL) == 0 && errno == EEXIST)
 180                 {
 181                   /* Remove the file.  */
 182                   __unlink (tmpfname);
 183
 184                   /* Close the file.  */
 185                   __close (fd);
 186
 187                   goto try_again;
 188                 }
 189             }
 190           else
 191             /* Insert the mapping into the search tree.  This also
 192                determines whether another thread sneaked by and already
 193                added such a mapping despite the fact that we created it.  */
 194             result = __sem_check_add_mapping (name, fd, result);
 195         }
 196
 197       /* Now remove the temporary name.  This should never fail.  If
 198          it fails we leak a file name.  Better fix the kernel.  */
 199       __unlink (tmpfname);
 200     }
 201
 202   /* Map the mmap error to the error we need.  */
 203   if (MAP_FAILED != (void *) SEM_FAILED && result == MAP_FAILED)
 204     result = SEM_FAILED;
 205
 206   /* We don't need the file descriptor anymore.  */
 207   if (fd != -1)
 208     {
 209       /* Do not disturb errno.  */
 210       int save = errno;
 211       __close (fd);
 212       errno = save;
 213     }
 214
 215 out:
 216 #ifdef __libc_ptf_call
 217   __libc_ptf_call (__pthread_setcancelstate, (state, NULL), 0);
 218 #endif
 219
 220   return result;
 221 }
 222 #if PTHREAD_IN_LIBC
 223 versioned_symbol (libc, __sem_open, sem_open, GLIBC_2_34);
 224 # if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_1_1, GLIBC_2_34)
 225 compat_symbol (libpthread, __sem_open, sem_open, GLIBC_2_1_1);
 226 # endif
 227 #else /* !PTHREAD_IN_LIBC */
 228 strong_alias (__sem_open, sem_open)
 229 #endif