-/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- 02111-1307 USA. */
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fcntl.h>
-#include <mntent.h>
-#include <paths.h>
#include <pthread.h>
+#include <search.h>
#include <semaphore.h>
#include <stdarg.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
-#include <sys/statfs.h>
-#include <linux_fsinfo.h>
#include "semaphoreP.h"
+#include <shm-directory.h>
+#include <futex-internal.h>
+#include <libc-lock.h>
+/* Comparison function for search of existing mapping. */
+int
+attribute_hidden
+__sem_search (const void *a, const void *b)
+{
+ const struct inuse_sem *as = (const struct inuse_sem *) a;
+ const struct inuse_sem *bs = (const struct inuse_sem *) b;
+
+ if (as->ino != bs->ino)
+ /* Cannot return the difference the type is larger than int. */
+ return as->ino < bs->ino ? -1 : (as->ino == bs->ino ? 0 : 1);
+ if (as->dev != bs->dev)
+ /* Cannot return the difference the type is larger than int. */
+ return as->dev < bs->dev ? -1 : (as->dev == bs->dev ? 0 : 1);
-/* Information about the mount point. */
-struct mountpoint_info mountpoint attribute_hidden;
+ return strcmp (as->name, bs->name);
+}
-/* This is the default mount point. */
-static const char defaultmount[] = "/dev/shm";
-/* This is the default directory. */
-static const char defaultdir[] = "/dev/shm/sem.";
-/* Protect the `mountpoint' variable above. */
-pthread_once_t __namedsem_once attribute_hidden = PTHREAD_ONCE_INIT;
+/* The search tree for existing mappings. */
+void *__sem_mappings attribute_hidden;
+/* Lock to protect the search tree. */
+int __sem_mappings_lock attribute_hidden = LLL_LOCK_INITIALIZER;
-/* Determine where the shmfs is mounted (if at all). */
-void
-attribute_hidden
-__where_is_shmfs (void)
+
+/* Search for existing mapping and if possible add the one provided. */
+static sem_t *
+check_add_mapping (const char *name, size_t namelen, int fd, sem_t *existing)
{
- char buf[512];
- struct statfs f;
- struct mntent resmem;
- struct mntent *mp;
- FILE *fp;
-
- /* The canonical place is /dev/shm. This is at least what the
- documentation tells everybody to do. */
- if (__statfs (defaultmount, &f) == 0 && f.f_type == SHMFS_SUPER_MAGIC)
+ sem_t *result = SEM_FAILED;
+
+ /* Get the information about the file. */
+ struct stat64 st;
+ if (__fxstat64 (_STAT_VER, fd, &st) == 0)
{
- /* It is in the normal place. */
- mountpoint.dir = (char *) defaultdir;
- mountpoint.dirlen = sizeof (defaultdir) - 1;
+ /* Get the lock. */
+ lll_lock (__sem_mappings_lock, LLL_PRIVATE);
+
+ /* Search for an existing mapping given the information we have. */
+ struct inuse_sem *fake;
+ fake = (struct inuse_sem *) alloca (sizeof (*fake) + namelen);
+ memcpy (fake->name, name, namelen);
+ fake->dev = st.st_dev;
+ fake->ino = st.st_ino;
+
+ struct inuse_sem **foundp = __tfind (fake, &__sem_mappings,
+ __sem_search);
+ if (foundp != NULL)
+ {
+ /* There is already a mapping. Use it. */
+ result = (*foundp)->sem;
+ ++(*foundp)->refcnt;
+ }
+ else
+ {
+ /* We haven't found a mapping. Install ione. */
+ struct inuse_sem *newp;
- return;
+ newp = (struct inuse_sem *) malloc (sizeof (*newp) + namelen);
+ if (newp != NULL)
+ {
+ /* If the caller hasn't provided any map it now. */
+ if (existing == SEM_FAILED)
+ existing = (sem_t *) mmap (NULL, sizeof (sem_t),
+ PROT_READ | PROT_WRITE, MAP_SHARED,
+ fd, 0);
+
+ newp->dev = st.st_dev;
+ newp->ino = st.st_ino;
+ newp->refcnt = 1;
+ newp->sem = existing;
+ memcpy (newp->name, name, namelen);
+
+ /* Insert the new value. */
+ if (existing != MAP_FAILED
+ && __tsearch (newp, &__sem_mappings, __sem_search) != NULL)
+ /* Successful. */
+ result = existing;
+ else
+ /* Something went wrong while inserting the new
+ value. We fail completely. */
+ free (newp);
+ }
+ }
+
+ /* Release the lock. */
+ lll_unlock (__sem_mappings_lock, LLL_PRIVATE);
}
- /* OK, do it the hard way. Look through the /proc/mounts file and if
- this does not exist through /etc/fstab to find the mount point. */
- fp = __setmntent ("/proc/mounts", "r");
- if (__builtin_expect (fp == NULL, 0))
+ if (result != existing && existing != SEM_FAILED && existing != MAP_FAILED)
{
- fp = __setmntent (_PATH_MNTTAB, "r");
- if (__builtin_expect (fp == NULL, 0))
- /* There is nothing we can do. Blind guesses are not helpful. */
- return;
+ /* Do not disturb errno. */
+ int save = errno;
+ munmap (existing, sizeof (sem_t));
+ errno = save;
}
- /* Now read the entries. */
- while ((mp = __getmntent_r (fp, &resmem, buf, sizeof buf)) != NULL)
- /* The original name is "shm" but this got changed in early Linux
- 2.4.x to "tmpfs". */
- if (strcmp (mp->mnt_type, "tmpfs") == 0
- || strcmp (mp->mnt_type, "shm") == 0)
- {
- /* Found it. There might be more than one place where the
- filesystem is mounted but one is enough for us. */
- size_t namelen;
-
- /* First make sure this really is the correct entry. At least
- some versions of the kernel give wrong information because
- of the implicit mount of the shmfs for SysV IPC. */
- if (__statfs (mp->mnt_dir, &f) != 0 || f.f_type != SHMFS_SUPER_MAGIC)
- continue;
-
- namelen = strlen (mp->mnt_dir);
-
- if (namelen == 0)
- /* Hum, maybe some crippled entry. Keep on searching. */
- continue;
-
- mountpoint.dir = (char *) malloc (namelen + 4 + 2);
- if (mountpoint.dir != NULL)
- {
- char *cp = __mempcpy (mountpoint.dir, mp->mnt_dir, namelen);
- if (cp[-1] != '/')
- *cp++ = '/';
- cp = stpcpy (cp, "sem.");
- mountpoint.dirlen = cp - mountpoint.dir;
- }
-
- break;
- }
-
- /* Close the stream. */
- __endmntent (fp);
+ return result;
}
sem_t *
sem_open (const char *name, int oflag, ...)
{
- char *finalname;
- size_t namelen = SEM_FAILED;
- sem_t *result;
int fd;
+ sem_t *result;
- /* Determine where the shmfs is mounted. */
- INTUSE(__pthread_once) (&__namedsem_once, __where_is_shmfs);
-
- /* If we don't know the mount points there is nothing we can do. Ever. */
- if (mountpoint.dir == NULL)
+ /* Check that shared futexes are supported. */
+ int err = futex_supports_pshared (PTHREAD_PROCESS_SHARED);
+ if (err != 0)
{
- __set_errno (ENOSYS);
+ __set_errno (err);
return SEM_FAILED;
}
- /* Construct the filename. */
- while (name[0] == '/')
- ++name;
-
- if (name[0] == '\0')
- {
- /* The name "/" is not supported. */
- __set_errno (EINVAL);
- return SEM_FAILED;
- }
- namelen = strlen (name);
+ /* Create the name of the final file in local variable SHM_NAME. */
+ SHM_GET_NAME (EINVAL, SEM_FAILED, SEM_SHM_PREFIX);
- /* Create the name of the final file. */
- finalname = (char *) alloca (mountpoint.dirlen + namelen + 1);
- __mempcpy (__mempcpy (finalname, mountpoint.dir, mountpoint.dirlen),
- name, namelen + 1);
+ /* Disable asynchronous cancellation. */
+#ifdef __libc_ptf_call
+ int state;
+ __libc_ptf_call (__pthread_setcancelstate,
+ (PTHREAD_CANCEL_DISABLE, &state), 0);
+#endif
/* If the semaphore object has to exist simply open it. */
if ((oflag & O_CREAT) == 0 || (oflag & O_EXCL) == 0)
{
try_again:
- fd = __libc_open (finalname,
+ fd = __libc_open (shm_name,
(oflag & ~(O_CREAT|O_ACCMODE)) | O_NOFOLLOW | O_RDWR);
if (fd == -1)
{
/* If we are supposed to create the file try this next. */
- if ((oflag & O_CREAT) != 0)
+ if ((oflag & O_CREAT) != 0 && errno == ENOENT)
goto try_create;
/* Return. errno is already set. */
}
else
- /* Map the sem_t structure from the file. */
- result = (sem_t *) mmap (NULL, sizeof (sem_t), PROT_READ | PROT_WRITE,
- MAP_SHARED, fd, 0);
+ /* Check whether we already have this semaphore mapped and
+ create one if necessary. */
+ result = check_add_mapping (name, namelen, fd, SEM_FAILED);
}
else
{
if (value > SEM_VALUE_MAX)
{
__set_errno (EINVAL);
- return SEM_FAILED;
+ result = SEM_FAILED;
+ goto out;
}
- tmpfname = (char *) alloca (mountpoint.dirlen + 6 + 1);
- strcpy (__mempcpy (tmpfname, mountpoint.dir, mountpoint.dirlen),
- "XXXXXX");
+ /* Create the initial file content. */
+ union
+ {
+ sem_t initsem;
+ struct new_sem newsem;
+ } sem;
+
+#if __HAVE_64B_ATOMICS
+ sem.newsem.data = value;
+#else
+ sem.newsem.value = value << SEM_VALUE_SHIFT;
+ sem.newsem.nwaiters = 0;
+#endif
+ /* pad is used as a mutex on pre-v9 sparc and ignored otherwise. */
+ sem.newsem.pad = 0;
+
+ /* This always is a shared semaphore. */
+ sem.newsem.private = FUTEX_SHARED;
- fd = mkstemp (tmpfname);
- if (fd == -1)
- return SEM_FAILED;
+ /* Initialize the remaining bytes as well. */
+ memset ((char *) &sem.initsem + sizeof (struct new_sem), '\0',
+ sizeof (sem_t) - sizeof (struct new_sem));
- /* Create the initial file content. */
- sem_t initsem;
+ tmpfname = __alloca (shm_dirlen + sizeof SEM_SHM_PREFIX + 6);
+ char *xxxxxx = __mempcpy (tmpfname, shm_dir, shm_dirlen);
- struct sem *iinitsem = (struct sem *) &initsem;
- iinitsem->count = value;
+ int retries = 0;
+#define NRETRIES 50
+ while (1)
+ {
+ /* Add the suffix for mktemp. */
+ strcpy (xxxxxx, "XXXXXX");
+
+ /* We really want to use mktemp here. We cannot use mkstemp
+ since the file must be opened with a specific mode. The
+ mode cannot later be set since then we cannot apply the
+ file create mask. */
+ if (__mktemp (tmpfname) == NULL)
+ {
+ result = SEM_FAILED;
+ goto out;
+ }
- /* Initialize the remaining bytes as well. */
- memset ((char *) &initsem + sizeof (struct sem), '\0',
- sizeof (sem_t) - sizeof (struct sem));
+ /* Open the file. Make sure we do not overwrite anything. */
+ fd = __libc_open (tmpfname, O_RDWR | O_CREAT | O_EXCL, mode);
+ if (fd == -1)
+ {
+ if (errno == EEXIST)
+ {
+ if (++retries < NRETRIES)
+ continue;
+
+ __set_errno (EAGAIN);
+ }
+
+ result = SEM_FAILED;
+ goto out;
+ }
- if (TEMP_FAILURE_RETRY (__libc_write (fd, &initsem, sizeof (sem_t)))
+ /* We got a file. */
+ break;
+ }
+
+ if (TEMP_FAILURE_RETRY (__libc_write (fd, &sem.initsem, sizeof (sem_t)))
== sizeof (sem_t)
- /* Adjust the permission. */
- && fchmod (fd, mode) == 0
/* Map the sem_t structure from the file. */
&& (result = (sem_t *) mmap (NULL, sizeof (sem_t),
PROT_READ | PROT_WRITE, MAP_SHARED,
fd, 0)) != MAP_FAILED)
{
/* Create the file. Don't overwrite an existing file. */
- if (link (tmpfname, finalname) != 0)
+ if (link (tmpfname, shm_name) != 0)
{
/* Undo the mapping. */
(void) munmap (result, sizeof (sem_t));
goto try_again;
}
}
+ else
+ /* Insert the mapping into the search tree. This also
+ determines whether another thread sneaked by and already
+ added such a mapping despite the fact that we created it. */
+ result = check_add_mapping (name, namelen, fd, result);
}
/* Now remove the temporary name. This should never fail. If
/* We don't need the file descriptor anymore. */
if (fd != -1)
- (void) __libc_close (fd);
+ {
+ /* Do not disturb errno. */
+ int save = errno;
+ __libc_close (fd);
+ errno = save;
+ }
+
+out:
+#ifdef __libc_ptf_call
+ __libc_ptf_call (__pthread_setcancelstate, (state, NULL), 0);
+#endif
return result;
}
projects / thirdparty / glibc.git / blobdiff