move rsyscall out of pthread_create module

this is something of a tradeoff, as now set*id() functions, rather
than pthread_create, are what pull in the code overhead for dealing
with linux's refusal to implement proper POSIX thread-vs-process
semantics. my motivations are:

1. it's cleaner this way, especially cleaner to optimize out the
rsyscall locking overhead from pthread_create when it's not needed.
2. it's expected that only a tiny number of core system programs will
ever use set*id() functions, whereas many programs may want to use
threads, and making thread overhead tiny is an incentive for "light"
programs to try threads.

diff --git a/src/internal/libc.h b/src/internal/libc.h
index be88dc04c28cafd6a02c3ed73f6a70b4a8fb67a2..c0039e77913a0d79dd09a08e0bd9a729d96030f3 100644 (file)
--- a/src/internal/libc.h
+++ b/src/internal/libc.h
@@ -10,7 +10,6 @@ struct __libc {
        void (*lock)(volatile int *);
        void (*lockfile)(FILE *);
        void (*fork_handler)(int);
-       int (*rsyscall)(int, long, long, long, long, long, long);
        int (*atexit)(void (*)(void));
        void (*fini)(void);
        void (*ldso_fini)(void);
@@ -48,6 +47,8 @@ void __lockfile(FILE *);
 #define CANCELPT_INHIBIT CANCELPT(2)
 #define CANCELPT_RESUME CANCELPT(-2)
 
+int __rsyscall(int, long, long, long, long, long, long);
+
 extern char **__environ;
 #define environ __environ
 

diff --git a/src/internal/pthread_impl.h b/src/internal/pthread_impl.h
index 7ab6243dcb620930f356ece33994c4f7d3693c44..0bcc54cc62e2d3620f7080c70d2d7c8903f8ed11 100644 (file)
--- a/src/internal/pthread_impl.h
+++ b/src/internal/pthread_impl.h
@@ -86,6 +86,9 @@ int __timedwait(volatile int *, int, clockid_t, const struct timespec *, int);
 void __wait(volatile int *, volatile int *, int, int);
 void __wake(volatile int *, int, int);
 
+void __rsyscall_lock();
+void __rsyscall_unlock();
+
 #define DEFAULT_STACK_SIZE (16384-PAGE_SIZE)
 #define DEFAULT_GUARD_SIZE PAGE_SIZE
 

diff --git a/src/thread/__rsyscall.c b/src/thread/__rsyscall.c
new file mode 100644 (file)
index 0000000..923db2b
--- /dev/null
+++ b/src/thread/__rsyscall.c
@@ -0,0 +1,113 @@
+#include "pthread_impl.h"
+
+/* "rsyscall" is a mechanism by which a thread can synchronously force all
+ * other threads to perform an arbitrary syscall. It is necessary to work
+ * around the non-conformant implementation of setuid() et al on Linux,
+ * which affect only the calling thread and not the whole process. This
+ * implementation performs some tricks with signal delivery to work around
+ * the fact that it does not keep any list of threads in userspace. */
+
+static struct {
+       volatile int lock, hold, blocks, cnt;
+       unsigned long arg[6];
+       int nr;
+       int err;
+       int init;
+} rs;
+
+static void rsyscall_handler(int sig, siginfo_t *si, void *ctx)
+{
+       struct pthread *self = __pthread_self();
+       long r;
+
+       if (!rs.hold || rs.cnt == libc.threads_minus_1) return;
+
+       /* Threads which have already decremented themselves from the
+        * thread count must not increment rs.cnt or otherwise act. */
+       if (self->dead) {
+               sigfillset(&((ucontext_t *)ctx)->uc_sigmask);
+               return;
+       }
+
+       r = __syscall(rs.nr, rs.arg[0], rs.arg[1],
+               rs.arg[2], rs.arg[3], rs.arg[4], rs.arg[5]);
+       if (r < 0) rs.err=-r;
+
+       a_inc(&rs.cnt);
+       __wake(&rs.cnt, 1, 1);
+       while(rs.hold)
+               __wait(&rs.hold, 0, 1, 1);
+       a_dec(&rs.cnt);
+       if (!rs.cnt) __wake(&rs.cnt, 1, 1);
+}
+
+int __rsyscall(int nr, long a, long b, long c, long d, long e, long f)
+{
+       int i, ret;
+       sigset_t set = { 0 };
+       struct pthread *self;
+
+       if (!libc.threads_minus_1)
+               return syscall(nr, a, b, c, d, e, f);
+
+       self = __pthread_self();
+
+       LOCK(&rs.lock);
+       while ((i=rs.blocks))
+               __wait(&rs.blocks, 0, i, 1);
+
+       sigfillset(&set);
+       __libc_sigprocmask(SIG_BLOCK, &set, &set);
+
+       if (!rs.init) {
+               struct sigaction sa = {
+                       .sa_sigaction = rsyscall_handler,
+                       .sa_mask = set
+               };
+               sigfillset(&sa.sa_mask);
+               sa.sa_sigaction = rsyscall_handler;
+               __libc_sigaction(SIGSYSCALL, &sa, 0);
+       }
+
+       rs.nr = nr;
+       rs.arg[0] = a; rs.arg[1] = b;
+       rs.arg[2] = c; rs.arg[3] = d;
+       rs.arg[4] = d; rs.arg[5] = f;
+       rs.err = 0;
+       rs.cnt = 0;
+       rs.hold = 1;
+
+       /* Dispatch signals until all threads respond */
+       for (i=libc.threads_minus_1; i; i--)
+               sigqueue(self->pid, SIGSYSCALL, (union sigval){0});
+       while ((i=rs.cnt) < libc.threads_minus_1) {
+               sigqueue(self->pid, SIGSYSCALL, (union sigval){0});
+               __wait(&rs.cnt, 0, i, 1);
+       }
+
+       /* Handle any lingering signals with no-op */
+       __libc_sigprocmask(SIG_UNBLOCK, &set, &set);
+
+       /* Resume other threads' signal handlers and wait for them */
+       rs.hold = 0;
+       __wake(&rs.hold, -1, 0);
+       while((i=rs.cnt)) __wait(&rs.cnt, 0, i, 1);
+
+       if (rs.err) errno = rs.err, ret = -1;
+       else ret = syscall(nr, a, b, c, d, e, f);
+
+       UNLOCK(&rs.lock);
+       return ret;
+}
+
+void __rsyscall_lock()
+{
+       a_inc(&rs.blocks);
+       while (rs.lock) __wait(&rs.lock, 0, 1, 1);
+}
+
+void __rsyscall_unlock()
+{
+       a_dec(&rs.blocks);
+       if (rs.lock) __wake(&rs.blocks, 1, 1);
+}

diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c
index a9a08171c0c4d09c9ab497d9d8fd231fd6977562..ec329f5072ded734198fb1de54fe2c6b7a82c9e5 100644 (file)
--- a/src/thread/pthread_create.c
+++ b/src/thread/pthread_create.c
@@ -1,5 +1,11 @@
 #include "pthread_impl.h"
 
+static void dummy_0()
+{
+}
+weak_alias(dummy_0, __rsyscall_lock);
+weak_alias(dummy_0, __rsyscall_unlock);
+
 static void dummy_1(pthread_t self)
 {
 }
@@ -72,101 +78,12 @@ static void cancelpt(int x)
        }
 }
 
-/* "rsyscall" is a mechanism by which a thread can synchronously force all
- * other threads to perform an arbitrary syscall. It is necessary to work
- * around the non-conformant implementation of setuid() et al on Linux,
- * which affect only the calling thread and not the whole process. This
- * implementation performs some tricks with signal delivery to work around
- * the fact that it does not keep any list of threads in userspace. */
-
-static struct {
-       volatile int lock, hold, blocks, cnt;
-       unsigned long arg[6];
-       int nr;
-       int err;
-} rs;
-
-static void rsyscall_handler(int sig, siginfo_t *si, void *ctx)
-{
-       struct pthread *self = __pthread_self();
-       long r;
-
-       if (!rs.hold || rs.cnt == libc.threads_minus_1) return;
-
-       /* Threads which have already decremented themselves from the
-        * thread count must not increment rs.cnt or otherwise act. */
-       if (self->dead) {
-               sigfillset(&((ucontext_t *)ctx)->uc_sigmask);
-               return;
-       }
-
-       r = __syscall(rs.nr, rs.arg[0], rs.arg[1],
-               rs.arg[2], rs.arg[3], rs.arg[4], rs.arg[5]);
-       if (r < 0) rs.err=-r;
-
-       a_inc(&rs.cnt);
-       __wake(&rs.cnt, 1, 1);
-       while(rs.hold)
-               __wait(&rs.hold, 0, 1, 1);
-       a_dec(&rs.cnt);
-       if (!rs.cnt) __wake(&rs.cnt, 1, 1);
-}
-
-static int rsyscall(int nr, long a, long b, long c, long d, long e, long f)
-{
-       int i, ret;
-       sigset_t set = { 0 };
-       struct pthread *self = __pthread_self();
-       sigaddset(&set, SIGSYSCALL);
-
-       LOCK(&rs.lock);
-       while ((i=rs.blocks))
-               __wait(&rs.blocks, 0, i, 1);
-
-       __libc_sigprocmask(SIG_BLOCK, &set, 0);
-
-       rs.nr = nr;
-       rs.arg[0] = a; rs.arg[1] = b;
-       rs.arg[2] = c; rs.arg[3] = d;
-       rs.arg[4] = d; rs.arg[5] = f;
-       rs.err = 0;
-       rs.cnt = 0;
-       rs.hold = 1;
-
-       /* Dispatch signals until all threads respond */
-       for (i=libc.threads_minus_1; i; i--)
-               sigqueue(self->pid, SIGSYSCALL, (union sigval){0});
-       while ((i=rs.cnt) < libc.threads_minus_1) {
-               sigqueue(self->pid, SIGSYSCALL, (union sigval){0});
-               __wait(&rs.cnt, 0, i, 1);
-       }
-
-       /* Handle any lingering signals with no-op */
-       __libc_sigprocmask(SIG_UNBLOCK, &set, 0);
-
-       /* Resume other threads' signal handlers and wait for them */
-       rs.hold = 0;
-       __wake(&rs.hold, -1, 0);
-       while((i=rs.cnt)) __wait(&rs.cnt, 0, i, 1);
-
-       if (rs.err) errno = rs.err, ret = -1;
-       else ret = syscall(nr, a, b, c, d, e, f);
-
-       UNLOCK(&rs.lock);
-       return ret;
-}
-
 static void init_threads()
 {
        struct sigaction sa = { .sa_flags = SA_SIGINFO | SA_RESTART };
        libc.lock = __lock;
        libc.lockfile = __lockfile;
        libc.cancelpt = cancelpt;
-       libc.rsyscall = rsyscall;
-
-       sigfillset(&sa.sa_mask);
-       sa.sa_sigaction = rsyscall_handler;
-       __libc_sigaction(SIGSYSCALL, &sa, 0);
 
        sigemptyset(&sa.sa_mask);
        sa.sa_sigaction = cancel_handler;
@@ -205,7 +122,7 @@ int pthread_create(pthread_t *res, const pthread_attr_t *attr, void *(*entry)(vo
        size_t size, guard;
        struct pthread *self = pthread_self(), *new;
        unsigned char *map, *stack, *tsd;
-       static const pthread_attr_t default_attr;
+       const pthread_attr_t default_attr = { 0 };
 
        if (!self) return ENOSYS;
        if (!init && ++init) init_threads();
@@ -236,16 +153,12 @@ int pthread_create(pthread_t *res, const pthread_attr_t *attr, void *(*entry)(vo
        new->tlsdesc[1] = (uintptr_t)new;
        stack = (void *)((uintptr_t)new-1 & ~(uintptr_t)15);
 
-       /* We must synchronize new thread creation with rsyscall
-        * delivery. This looks to be the least expensive way: */
-       a_inc(&rs.blocks);
-       while (rs.lock) __wait(&rs.lock, 0, 1, 1);
+       __rsyscall_lock();
 
        a_inc(&libc.threads_minus_1);
        ret = __uniclone(stack, start, new);
 
-       a_dec(&rs.blocks);
-       if (rs.lock) __wake(&rs.blocks, 1, 1);
+       __rsyscall_unlock();
 
        if (ret < 0) {
                a_dec(&libc.threads_minus_1);

diff --git a/src/unistd/setgid.c b/src/unistd/setgid.c
index e98a2982a6ece851310c17a3f6f4ef662d393d43..b54d2b22a0366d88d60af2b89d868bf53e9b2654 100644 (file)
--- a/src/unistd/setgid.c
+++ b/src/unistd/setgid.c
@@ -4,6 +4,5 @@
 
 int setgid(gid_t gid)
 {
-       if (libc.rsyscall) return libc.rsyscall(__NR_setgid, gid, 0, 0, 0, 0, 0);
-       return syscall(SYS_setgid, gid);
+       return __rsyscall(__NR_setgid, gid, 0, 0, 0, 0, 0);
 }

diff --git a/src/unistd/setregid.c b/src/unistd/setregid.c
index ff2607dc2459130eb4ac8af951a84b06c5d083a1..49c59858dffda69b10eea6dc9e52b4b32e665857 100644 (file)
--- a/src/unistd/setregid.c
+++ b/src/unistd/setregid.c
@@ -4,6 +4,5 @@
 
 int setregid(gid_t rgid, gid_t egid)
 {
-       if (libc.rsyscall) return libc.rsyscall(__NR_setregid, rgid, egid, 0, 0, 0, 0);
-       return syscall(SYS_setregid, rgid, egid);
+       return __rsyscall(__NR_setregid, rgid, egid, 0, 0, 0, 0);
 }

diff --git a/src/unistd/setresgid.c b/src/unistd/setresgid.c
index 3c85a82885cd35d9a260153a33138c1106ae72c9..2b0c96d8708de8142887ac668025d6edc59d4b4e 100644 (file)
--- a/src/unistd/setresgid.c
+++ b/src/unistd/setresgid.c
@@ -5,6 +5,5 @@
 
 int setresgid(gid_t rgid, gid_t egid, gid_t sgid)
 {
-       if (libc.rsyscall) return libc.rsyscall(__NR_setresgid, rgid, egid, sgid, 0, 0, 0);
-       return syscall(SYS_setresgid, rgid, egid, sgid);
+       return __rsyscall(__NR_setresgid, rgid, egid, sgid, 0, 0, 0);
 }

diff --git a/src/unistd/setresuid.c b/src/unistd/setresuid.c
index 376ce406a456e931b15929bd4357f17cb757e60b..7fa6bc3876f093863e1466e250855d7555eeb75b 100644 (file)
--- a/src/unistd/setresuid.c
+++ b/src/unistd/setresuid.c
@@ -5,6 +5,5 @@
 
 int setresuid(uid_t ruid, uid_t euid, uid_t suid)
 {
-       if (libc.rsyscall) return libc.rsyscall(__NR_setresuid, ruid, euid, suid, 0, 0, 0);
-       return syscall(SYS_setresuid, ruid, euid, suid);
+       return __rsyscall(__NR_setresuid, ruid, euid, suid, 0, 0, 0);
 }

diff --git a/src/unistd/setreuid.c b/src/unistd/setreuid.c
index 505e8bc1f2496699f5b32343c5973a0b3809b601..d926454a97dba5e48cb851865ebe1a11e5fdc5d0 100644 (file)
--- a/src/unistd/setreuid.c
+++ b/src/unistd/setreuid.c
@@ -4,6 +4,5 @@
 
 int setreuid(uid_t ruid, uid_t euid)
 {
-       if (libc.rsyscall) return libc.rsyscall(__NR_setreuid, ruid, euid, 0, 0, 0, 0);
-       return syscall(SYS_setreuid, ruid, euid);
+       return __rsyscall(__NR_setreuid, ruid, euid, 0, 0, 0, 0);
 }

diff --git a/src/unistd/setuid.c b/src/unistd/setuid.c
index 61e8be557d9a8a6b9a32489e96f4c1c82569c3bf..da6816de0e545daa98bdad1457e3e278f076805f 100644 (file)
--- a/src/unistd/setuid.c
+++ b/src/unistd/setuid.c
@@ -4,6 +4,5 @@
 
 int setuid(uid_t uid)
 {
-       if (libc.rsyscall) return libc.rsyscall(__NR_setuid, uid, 0, 0, 0, 0, 0);
-       return syscall(SYS_setuid, uid);
+       return __rsyscall(__NR_setuid, uid, 0, 0, 0, 0, 0);
 }