From 749cd2ca7893702f762de9d9852a39973eb044a0 Mon Sep 17 00:00:00 2001 From: Samuel Thibault Date: Sun, 13 Dec 2020 15:20:32 +0000 Subject: htl: Get sem_open/sem_close/sem_unlink support [BZ #25524] This just moves the existing nptl implementation to reuse as it is in htl. --- sysdeps/htl/sem-close.c | 31 ---- sysdeps/htl/sem-open.c | 31 ---- sysdeps/htl/sem-unlink.c | 31 ---- sysdeps/mach/hurd/i386/Makefile | 7 - sysdeps/pthread/sem_close.c | 81 ++++++++++ sysdeps/pthread/sem_open.c | 320 ++++++++++++++++++++++++++++++++++++++++ sysdeps/pthread/sem_unlink.c | 38 +++++ 7 files changed, 439 insertions(+), 100 deletions(-) delete mode 100644 sysdeps/htl/sem-close.c delete mode 100644 sysdeps/htl/sem-open.c delete mode 100644 sysdeps/htl/sem-unlink.c create mode 100644 sysdeps/pthread/sem_close.c create mode 100644 sysdeps/pthread/sem_open.c create mode 100644 sysdeps/pthread/sem_unlink.c (limited to 'sysdeps') diff --git a/sysdeps/htl/sem-close.c b/sysdeps/htl/sem-close.c deleted file mode 100644 index e568758532..0000000000 --- a/sysdeps/htl/sem-close.c +++ /dev/null @@ -1,31 +0,0 @@ -/* Close a named semaphore. Generic version. - Copyright (C) 2005-2020 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - 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, see - . */ - -#include -#include - -#include - -int -__sem_close (sem_t *sem) -{ - errno = EOPNOTSUPP; - return -1; -} - -strong_alias (__sem_close, sem_close); diff --git a/sysdeps/htl/sem-open.c b/sysdeps/htl/sem-open.c deleted file mode 100644 index 682f0e1a88..0000000000 --- a/sysdeps/htl/sem-open.c +++ /dev/null @@ -1,31 +0,0 @@ -/* Open a named semaphore. Generic version. - Copyright (C) 2005-2020 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - 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, see - . */ - -#include -#include - -#include - -sem_t * -__sem_open (const char *name, int open_flags, ...) -{ - errno = ENOSYS; - return SEM_FAILED; -} - -strong_alias (__sem_open, sem_open); diff --git a/sysdeps/htl/sem-unlink.c b/sysdeps/htl/sem-unlink.c deleted file mode 100644 index c92c8317b1..0000000000 --- a/sysdeps/htl/sem-unlink.c +++ /dev/null @@ -1,31 +0,0 @@ -/* Unlink a named semaphore. Generic version. - Copyright (C) 2005-2020 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - 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, see - . */ - -#include -#include - -#include - -int -__sem_unlink (const char *name) -{ - errno = EOPNOTSUPP; - return -1; -} - -strong_alias (__sem_unlink, sem_unlink); diff --git a/sysdeps/mach/hurd/i386/Makefile b/sysdeps/mach/hurd/i386/Makefile index d056e06278..7400ea98cc 100644 --- a/sysdeps/mach/hurd/i386/Makefile +++ b/sysdeps/mach/hurd/i386/Makefile @@ -129,13 +129,6 @@ test-xfail-tst-signal2 = yes test-xfail-tst-cond24 = yes test-xfail-tst-cond25 = yes -# For bug 25524 -# (sem_open support) -test-xfail-tst-sem4 = yes -test-xfail-tst-sem7 = yes -test-xfail-tst-sem8 = yes -test-xfail-tst-sem9 = yes - # For bug 25563 # (robust support against dead threads) test-xfail-tst-robust1 = yes diff --git a/sysdeps/pthread/sem_close.c b/sysdeps/pthread/sem_close.c new file mode 100644 index 0000000000..5eea0e1518 --- /dev/null +++ b/sysdeps/pthread/sem_close.c @@ -0,0 +1,81 @@ +/* Copyright (C) 2002-2020 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2002. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + 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, see + . */ + +#include +#include +#include +#include "semaphoreP.h" + +struct walk_closure +{ + sem_t *the_sem; + struct inuse_sem *rec; +}; + +static void +walker (const void *inodep, VISIT which, void *closure0) +{ + struct walk_closure *closure = closure0; + struct inuse_sem *nodep = *(struct inuse_sem **) inodep; + + if (nodep->sem == closure->the_sem) + closure->rec = nodep; +} + + +int +sem_close (sem_t *sem) +{ + int result = 0; + + /* Get the lock. */ + lll_lock (__sem_mappings_lock, LLL_PRIVATE); + + /* Locate the entry for the mapping the caller provided. */ + struct inuse_sem *rec; + { + struct walk_closure closure = { .the_sem = sem, .rec = NULL }; + __twalk_r (__sem_mappings, walker, &closure); + rec = closure.rec; + } + if (rec != NULL) + { + /* Check the reference counter. If it is going to be zero, free + all the resources. */ + if (--rec->refcnt == 0) + { + /* Remove the record from the tree. */ + (void) __tdelete (rec, &__sem_mappings, __sem_search); + + result = munmap (rec->sem, sizeof (sem_t)); + + free (rec); + } + } + else + { + /* This is no valid semaphore. */ + result = -1; + __set_errno (EINVAL); + } + + /* Release the lock. */ + lll_unlock (__sem_mappings_lock, LLL_PRIVATE); + + return result; +} diff --git a/sysdeps/pthread/sem_open.c b/sysdeps/pthread/sem_open.c new file mode 100644 index 0000000000..634bdf7425 --- /dev/null +++ b/sysdeps/pthread/sem_open.c @@ -0,0 +1,320 @@ +/* Copyright (C) 2002-2020 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2002. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + 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, see + . */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "semaphoreP.h" +#include +#include +#include + +/* 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); + + return strcmp (as->name, bs->name); +} + + +/* 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; + + +/* 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) +{ + sem_t *result = SEM_FAILED; + + /* Get the information about the file. */ + struct stat64 st; + if (__fstat64 (fd, &st) == 0) + { + /* 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; + + 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); + } + + if (result != existing && existing != SEM_FAILED && existing != MAP_FAILED) + { + /* Do not disturb errno. */ + int save = errno; + munmap (existing, sizeof (sem_t)); + errno = save; + } + + return result; +} + + +sem_t * +sem_open (const char *name, int oflag, ...) +{ + int fd; + sem_t *result; + + /* Check that shared futexes are supported. */ + int err = futex_supports_pshared (PTHREAD_PROCESS_SHARED); + if (err != 0) + { + __set_errno (err); + return SEM_FAILED; + } + + /* Create the name of the final file in local variable SHM_NAME. */ + SHM_GET_NAME (EINVAL, SEM_FAILED, SEM_SHM_PREFIX); + + /* 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 (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 && errno == ENOENT) + goto try_create; + + /* Return. errno is already set. */ + } + else + /* Check whether we already have this semaphore mapped and + create one if necessary. */ + result = check_add_mapping (name, namelen, fd, SEM_FAILED); + } + else + { + /* We have to open a temporary file first since it must have the + correct form before we can start using it. */ + char *tmpfname; + mode_t mode; + unsigned int value; + va_list ap; + + try_create: + va_start (ap, oflag); + + mode = va_arg (ap, mode_t); + value = va_arg (ap, unsigned int); + + va_end (ap); + + if (value > SEM_VALUE_MAX) + { + __set_errno (EINVAL); + result = SEM_FAILED; + goto out; + } + + /* Create the initial file content. */ + union + { + sem_t initsem; + struct new_sem newsem; + } sem; + + __new_sem_open_init (&sem.newsem, value); + + /* Initialize the remaining bytes as well. */ + memset ((char *) &sem.initsem + sizeof (struct new_sem), '\0', + sizeof (sem_t) - sizeof (struct new_sem)); + + tmpfname = __alloca (shm_dirlen + sizeof SEM_SHM_PREFIX + 6); + char *xxxxxx = __mempcpy (tmpfname, shm_dir, shm_dirlen); + + 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; + } + + /* 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; + } + + /* We got a file. */ + break; + } + + if (TEMP_FAILURE_RETRY (__libc_write (fd, &sem.initsem, sizeof (sem_t))) + == sizeof (sem_t) + /* 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, shm_name) != 0) + { + /* Undo the mapping. */ + (void) munmap (result, sizeof (sem_t)); + + /* Reinitialize 'result'. */ + result = SEM_FAILED; + + /* This failed. If O_EXCL is not set and the problem was + that the file exists, try again. */ + if ((oflag & O_EXCL) == 0 && errno == EEXIST) + { + /* Remove the file. */ + (void) unlink (tmpfname); + + /* Close the file. */ + (void) __libc_close (fd); + + 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 + it fails we leak a file name. Better fix the kernel. */ + (void) unlink (tmpfname); + } + + /* Map the mmap error to the error we need. */ + if (MAP_FAILED != (void *) SEM_FAILED && result == MAP_FAILED) + result = SEM_FAILED; + + /* We don't need the file descriptor anymore. */ + if (fd != -1) + { + /* 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; +} diff --git a/sysdeps/pthread/sem_unlink.c b/sysdeps/pthread/sem_unlink.c new file mode 100644 index 0000000000..41fbb2c7fd --- /dev/null +++ b/sysdeps/pthread/sem_unlink.c @@ -0,0 +1,38 @@ +/* Copyright (C) 2002-2020 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2002. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + 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, see + . */ + +#include +#include +#include +#include +#include +#include "semaphoreP.h" +#include + +int +sem_unlink (const char *name) +{ + /* Construct the filename. */ + SHM_GET_NAME (ENOENT, -1, SEM_SHM_PREFIX); + + /* Now try removing it. */ + int ret = unlink (shm_name); + if (ret < 0 && errno == EPERM) + __set_errno (EACCES); + return ret; +} -- cgit v1.2.3