Add a "fork" of musl as //fusl.

fusl/src/thread/sem_open.c

+#include <semaphore.h>
+#include <sys/mman.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <time.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include "libc.h"
+
+char *__shm_mapname(const char *, char *);
+
+static struct {
+        ino_t ino;
+        sem_t *sem;
+        int refcnt;
+} *semtab;
+static volatile int lock[2];
+
+#define FLAGS (O_RDWR|O_NOFOLLOW|O_CLOEXEC|O_NONBLOCK)
+
+sem_t *sem_open(const char *name, int flags, ...)
+{
+        va_list ap;
+        mode_t mode;
+        unsigned value;
+        int fd, i, e, slot, first=1, cnt, cs;
+        sem_t newsem;
+        void *map;
+        char tmp[64];
+        struct timespec ts;
+        struct stat st;
+        char buf[NAME_MAX+10];
+
+        if (!(name = __shm_mapname(name, buf)))
+                return SEM_FAILED;
+
+        LOCK(lock);
+        /* Allocate table if we don't have one yet */
+        if (!semtab && !(semtab = calloc(sizeof *semtab, SEM_NSEMS_MAX))) {
+                UNLOCK(lock);
+                return SEM_FAILED;
+        }
+
+        /* Reserve a slot in case this semaphore is not mapped yet;
+         * this is necessary because there is no way to handle
+         * failures after creation of the file. */
+        slot = -1;
+        for (cnt=i=0; i<SEM_NSEMS_MAX; i++) {
+                cnt += semtab[i].refcnt;
+                if (!semtab[i].sem && slot < 0) slot = i;
+        }
+        /* Avoid possibility of overflow later */
+        if (cnt == INT_MAX || slot < 0) {
+                errno = EMFILE;
+                UNLOCK(lock);
+                return SEM_FAILED;
+        }
+        /* Dummy pointer to make a reservation */
+        semtab[slot].sem = (sem_t *)-1;
+        UNLOCK(lock);
+
+        flags &= (O_CREAT|O_EXCL);
+
+        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+
+        /* Early failure check for exclusive open; otherwise the case
+         * where the semaphore already exists is expensive. */
+        if (flags == (O_CREAT|O_EXCL) && access(name, F_OK) == 0) {
+                errno = EEXIST;
+                goto fail;
+        }
+
+        for (;;) {
+                /* If exclusive mode is not requested, try opening an
+                 * existing file first and fall back to creation. */
+                if (flags != (O_CREAT|O_EXCL)) {
+                        fd = open(name, FLAGS);
+                        if (fd >= 0) {
+                                if (fstat(fd, &st) < 0 ||
+                                    (map = mmap(0, sizeof(sem_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+                                        close(fd);
+                                        goto fail;
+                                }
+                                close(fd);
+                                break;
+                        }
+                        if (errno != ENOENT)
+                                goto fail;
+                }
+                if (!(flags & O_CREAT))
+                        goto fail;
+                if (first) {
+                        first = 0;
+                        va_start(ap, flags);
+                        mode = va_arg(ap, mode_t) & 0666;
+                        value = va_arg(ap, unsigned);
+                        va_end(ap);
+                        if (value > SEM_VALUE_MAX) {
+                                errno = EINVAL;
+                                goto fail;
+                        }
+                        sem_init(&newsem, 1, value);
+                }
+                /* Create a temp file with the new semaphore contents
+                 * and attempt to atomically link it as the new name */
+                clock_gettime(CLOCK_REALTIME, &ts);
+                snprintf(tmp, sizeof(tmp), "/dev/shm/tmp-%d", (int)ts.tv_nsec);
+                fd = open(tmp, O_CREAT|O_EXCL|FLAGS, mode);
+                if (fd < 0) {
+                        if (errno == EEXIST) continue;
+                        goto fail;
+                }
+                if (write(fd, &newsem, sizeof newsem) != sizeof newsem || fstat(fd, &st) < 0 ||
+                    (map = mmap(0, sizeof(sem_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+                        close(fd);
+                        unlink(tmp);
+                        goto fail;
+                }
+                close(fd);
+                e = link(tmp, name) ? errno : 0;
+                unlink(tmp);
+                if (!e) break;
+                munmap(map, sizeof(sem_t));
+                /* Failure is only fatal when doing an exclusive open;
+                 * otherwise, next iteration will try to open the
+                 * existing file. */
+                if (e != EEXIST || flags == (O_CREAT|O_EXCL))
+                        goto fail;
+        }
+
+        /* See if the newly mapped semaphore is already mapped. If
+         * so, unmap the new mapping and use the existing one. Otherwise,
+         * add it to the table of mapped semaphores. */
+        LOCK(lock);
+        for (i=0; i<SEM_NSEMS_MAX && semtab[i].ino != st.st_ino; i++);
+        if (i<SEM_NSEMS_MAX) {
+                munmap(map, sizeof(sem_t));
+                semtab[slot].sem = 0;
+                slot = i;
+                map = semtab[i].sem;
+        }
+        semtab[slot].refcnt++;
+        semtab[slot].sem = map;
+        semtab[slot].ino = st.st_ino;
+        UNLOCK(lock);
+        pthread_setcancelstate(cs, 0);
+        return map;
+
+fail:
+        pthread_setcancelstate(cs, 0);
+        LOCK(lock);
+        semtab[slot].sem = 0;
+        UNLOCK(lock);
+        return SEM_FAILED;
+}
+
+int sem_close(sem_t *sem)
+{
+        int i;
+        LOCK(lock);
+        for (i=0; i<SEM_NSEMS_MAX && semtab[i].sem != sem; i++);
+        if (!--semtab[i].refcnt) {
+                semtab[i].sem = 0;
+                semtab[i].ino = 0;
+        }
+        UNLOCK(lock);
+        munmap(sem, sizeof *sem);
+        return 0;
+}