overhaul cancellation to fix resource leaks and dangerous behavior with signals

this commit addresses two issues:

1. a race condition, whereby a cancellation request occurring after a
syscall returned from kernelspace but before the subsequent
CANCELPT_END would cause cancellable resource-allocating syscalls
(like open) to leak resources.

2. signal handlers invoked while the thread was blocked at a
cancellation point behaved as if asynchronous cancellation mode wer in
effect, resulting in potentially dangerous state corruption if a
cancellation request occurs.

the glibc/nptl implementation of threads shares both of these issues.

with this commit, both are fixed. however, cancellation points
encountered in a signal handler will not be acted upon if the signal
was received while the thread was already at a cancellation point.
they will of course be acted upon after the signal handler returns, so
in real-world usage where signal handlers quickly return, it should
not be a problem. it's possible to solve this problem too by having
sigaction() wrap all signal handlers with a function that uses a
pthread_cleanup handler to catch cancellation, patch up the saved
context, and return into the cancellable function that will catch and
act upon the cancellation. however that would be a lot of complexity
for minimal if any benefit...

diff --git a/arch/i386/pthread_arch.h b/arch/i386/pthread_arch.h
index 155b484..64d75cb 100644 (file)
--- a/arch/i386/pthread_arch.h
+++ b/arch/i386/pthread_arch.h
@@ -4,3 +4,6 @@ static inline struct pthread *__pthread_self()
        __asm__ ("movl %%gs:0,%0" : "=r" (self) );
        return self;
 }
        __asm__ ("movl %%gs:0,%0" : "=r" (self) );
        return self;
 }

+
+#define PC_AT_SYS(c) \
+       (*(uint16_t *)(((ucontext_t *)(c))->uc_mcontext.__gregs[14])==0x80cd)

diff --git a/arch/x86_64/pthread_arch.h b/arch/x86_64/pthread_arch.h
index 40d2679..af7ae86 100644 (file)
--- a/arch/x86_64/pthread_arch.h
+++ b/arch/x86_64/pthread_arch.h
@@ -4,3 +4,6 @@ static inline struct pthread *__pthread_self()
        __asm__ ("movq %%fs:0,%0" : "=r" (self) );
        return self;
 }
        __asm__ ("movq %%fs:0,%0" : "=r" (self) );
        return self;
 }

+
+#define PC_AT_SYS(c) \
+       (*(uint16_t *)(((ucontext_t *)(c))->uc_mcontext.__gregs[16])==0x050f)

diff --git a/src/internal/libc.h b/src/internal/libc.h
index 3d09bf6..bbbb3a4 100644 (file)
--- a/src/internal/libc.h
+++ b/src/internal/libc.h
@@ -44,7 +44,8 @@ void __lockfile(FILE *);
 #define UNLOCK(x) (*(x)=0)
 #define CANCELPT(x) (libc.cancelpt ? libc.cancelpt((x)),0 : (void)(x),0)
 #define CANCELPT_BEGIN CANCELPT(1)
 #define UNLOCK(x) (*(x)=0)
 #define CANCELPT(x) (libc.cancelpt ? libc.cancelpt((x)),0 : (void)(x),0)
 #define CANCELPT_BEGIN CANCELPT(1)

-#define CANCELPT_END CANCELPT(0)
+#define CANCELPT_TRY CANCELPT(0)
+#define CANCELPT_END CANCELPT(-1)

 
 extern char **__environ;
 #define environ __environ
 
 extern char **__environ;
 #define environ __environ

diff --git a/src/process/waitid.c b/src/process/waitid.c
index b1e5e9b..4fa7c02 100644 (file)
--- a/src/process/waitid.c
+++ b/src/process/waitid.c
@@ -1,7 +1,13 @@
 #include <sys/wait.h>
 #include "syscall.h"
 #include <sys/wait.h>
 #include "syscall.h"

+#include "libc.h"

 
 int waitid(idtype_t type, id_t id, siginfo_t *info, int options)
 {
 
 int waitid(idtype_t type, id_t id, siginfo_t *info, int options)
 {

-       return syscall(SYS_waitid, type, id, info, options, 0);
+       int r;
+       CANCELPT_BEGIN;
+       r = syscall(SYS_waitid, type, id, info, options, 0);
+       if (r<0) CANCELPT_TRY;
+       CANCELPT_END;
+       return r;

 }
 }

diff --git a/src/process/waitpid.c b/src/process/waitpid.c
index ec2757b..5e0320f 100644 (file)
--- a/src/process/waitpid.c
+++ b/src/process/waitpid.c
@@ -1,7 +1,13 @@
 #include <sys/wait.h>
 #include "syscall.h"
 #include <sys/wait.h>
 #include "syscall.h"

+#include "libc.h"

 
 pid_t waitpid(pid_t pid, int *status, int options)
 {
 
 pid_t waitpid(pid_t pid, int *status, int options)
 {

-       return syscall(SYS_wait4, pid, status, options, 0);
+       int r;
+       CANCELPT_BEGIN;
+       r = syscall(SYS_wait4, pid, status, options, 0);
+       if (r<0) CANCELPT_TRY;
+       CANCELPT_END;
+       return r;

 }
 }

diff --git a/src/select/pselect.c b/src/select/pselect.c
index 63ea069..155a6eb 100644 (file)
--- a/src/select/pselect.c
+++ b/src/select/pselect.c
@@ -10,6 +10,7 @@ int pselect(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, const struct timesp
        if (ts) ts_tmp = *ts;
        CANCELPT_BEGIN;
        r = syscall(SYS_pselect6, n, rfds, wfds, efds, ts ? &ts_tmp : 0, data);
        if (ts) ts_tmp = *ts;
        CANCELPT_BEGIN;
        r = syscall(SYS_pselect6, n, rfds, wfds, efds, ts ? &ts_tmp : 0, data);

+       CANCELPT_TRY;

        CANCELPT_END;
        return r;
 }
        CANCELPT_END;
        return r;
 }

diff --git a/src/select/select.c b/src/select/select.c
index 1232271..b38e7fd 100644 (file)
--- a/src/select/select.c
+++ b/src/select/select.c
@@ -7,6 +7,7 @@ int select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tv)
        int r;
        CANCELPT_BEGIN;
        r = syscall(SYS_select, n, rfds, wfds, efds, tv);
        int r;
        CANCELPT_BEGIN;
        r = syscall(SYS_select, n, rfds, wfds, efds, tv);

+       CANCELPT_TRY;

        CANCELPT_END;
        return r;
 }
        CANCELPT_END;
        return r;
 }

diff --git a/src/signal/sigsuspend.c b/src/signal/sigsuspend.c
index 6c13fce..9ee7124 100644 (file)
--- a/src/signal/sigsuspend.c
+++ b/src/signal/sigsuspend.c
@@ -7,6 +7,7 @@ int sigsuspend(const sigset_t *mask)
        int ret;
        CANCELPT_BEGIN;
        ret = syscall(__NR_rt_sigsuspend, mask, 8);
        int ret;
        CANCELPT_BEGIN;
        ret = syscall(__NR_rt_sigsuspend, mask, 8);

+       if (ret<0) CANCELPT_TRY;

        CANCELPT_END;
        return ret;
 }
        CANCELPT_END;
        return ret;
 }

diff --git a/src/signal/sigtimedwait.c b/src/signal/sigtimedwait.c
index a0edaaf..86a2c87 100644 (file)
--- a/src/signal/sigtimedwait.c
+++ b/src/signal/sigtimedwait.c
@@ -9,6 +9,7 @@ int sigtimedwait(const sigset_t *mask, siginfo_t *si, const struct timespec *tim
        CANCELPT_BEGIN;
        do {
                ret = syscall(__NR_rt_sigtimedwait, mask, si, timeout, 8);
        CANCELPT_BEGIN;
        do {
                ret = syscall(__NR_rt_sigtimedwait, mask, si, timeout, 8);

+               if (ret<0) CANCELPT_TRY;

        } while (ret<0 && errno==EINTR);
        CANCELPT_END;
        return ret;
        } while (ret<0 && errno==EINTR);
        CANCELPT_END;
        return ret;

diff --git a/src/termios/tcdrain.c b/src/termios/tcdrain.c
index 8e889b5..9ff1ecd 100644 (file)
--- a/src/termios/tcdrain.c
+++ b/src/termios/tcdrain.c
@@ -7,6 +7,7 @@ int tcdrain(int fd)
        int ret;
        CANCELPT_BEGIN;
        ret = ioctl(fd, TCSBRK, 1);
        int ret;
        CANCELPT_BEGIN;
        ret = ioctl(fd, TCSBRK, 1);

+       CANCELPT_TRY;

        CANCELPT_END;
        return ret;
 }
        CANCELPT_END;
        return ret;
 }

diff --git a/src/thread/pthread_cond_timedwait.c b/src/thread/pthread_cond_timedwait.c
index 228f61f..1439aac 100644 (file)
--- a/src/thread/pthread_cond_timedwait.c
+++ b/src/thread/pthread_cond_timedwait.c
@@ -8,19 +8,21 @@ static void relock(void *m)
 int pthread_cond_timedwait(pthread_cond_t *c, pthread_mutex_t *m, const struct timespec *ts)
 {
        int r, e=0;
 int pthread_cond_timedwait(pthread_cond_t *c, pthread_mutex_t *m, const struct timespec *ts)
 {
        int r, e=0;

-       CANCELPT(0);
+       CANCELPT_BEGIN;
+       CANCELPT_END;

 
        pthread_cleanup_push(relock, m);
        c->_c_block = 1;
        if ((r=pthread_mutex_unlock(m))) return r;
 
 
        pthread_cleanup_push(relock, m);
        c->_c_block = 1;
        if ((r=pthread_mutex_unlock(m))) return r;
 

-       CANCELPT(1);
+       CANCELPT_BEGIN;

        e = __timedwait(&c->_c_block, 1, c->_c_clock, ts, 0);
        e = __timedwait(&c->_c_block, 1, c->_c_clock, ts, 0);

-       CANCELPT(0);
+       CANCELPT_END;

 
        pthread_cleanup_pop(0);
        if ((r=pthread_mutex_lock(m))) return r;
 
 
        pthread_cleanup_pop(0);
        if ((r=pthread_mutex_lock(m))) return r;
 

-       CANCELPT(0);
+       CANCELPT_BEGIN;
+       CANCELPT_END;

        return e;
 }
        return e;
 }

diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c
index 17a47f6..785a82b 100644 (file)
--- a/src/thread/pthread_create.c
+++ b/src/thread/pthread_create.c
@@ -42,6 +42,12 @@ void __pthread_unwind_next(struct __ptcb *cb)
 static void docancel(struct pthread *self)
 {
        struct __ptcb cb = { .__next = self->cancelbuf };
 static void docancel(struct pthread *self)
 {
        struct __ptcb cb = { .__next = self->cancelbuf };

+       sigset_t set;
+       self->canceldisable = 1;
+       self->cancelasync = 0;
+       sigemptyset(&set);
+       sigaddset(&set, SIGCANCEL);
+       __libc_sigprocmask(SIG_UNBLOCK, &set, 0);

        __pthread_unwind_next(&cb);
 }
 
        __pthread_unwind_next(&cb);
 }
 


@@ -50,17 +56,17 @@ static void cancel_handler(int sig, siginfo_t *si, void *ctx)
        struct pthread *self = __pthread_self();
        if (si->si_code > 0 || si->si_pid != self->pid) return;
        self->cancel = 1;
        struct pthread *self = __pthread_self();
        if (si->si_code > 0 || si->si_pid != self->pid) return;
        self->cancel = 1;

-       if (self->canceldisable || (!self->cancelasync && !self->cancelpoint))
-               return;
-       docancel(self);
+       if (self->canceldisable) return;
+       if (self->cancelasync || (self->cancelpoint==1 && PC_AT_SYS(ctx)))
+               docancel(self);

 }
 
 static void cancelpt(int x)
 {
        struct pthread *self = __pthread_self();
        if (self->canceldisable) return;
 }
 
 static void cancelpt(int x)
 {
        struct pthread *self = __pthread_self();
        if (self->canceldisable) return;

-       self->cancelpoint = x;
-       if (self->cancel) docancel(self);
+       if ((self->cancelpoint+=x)==1 && x>=0 && self->cancel)
+               docancel(self);

 }
 
 /* "rsyscall" is a mechanism by which a thread can synchronously force all
 }
 
 /* "rsyscall" is a mechanism by which a thread can synchronously force all

diff --git a/src/thread/sem_timedwait.c b/src/thread/sem_timedwait.c
index ad3bf07..11a0170 100644 (file)
--- a/src/thread/sem_timedwait.c
+++ b/src/thread/sem_timedwait.c
@@ -9,15 +9,18 @@ int sem_timedwait(sem_t *sem, const struct timespec *at)
                if (a_fetch_add(sem->__val, -1) > 0) return 0;
                val = a_fetch_add(sem->__val, 1)+1;
                if (val==1) __wake(sem->__val, 1, 0);
                if (a_fetch_add(sem->__val, -1) > 0) return 0;
                val = a_fetch_add(sem->__val, 1)+1;
                if (val==1) __wake(sem->__val, 1, 0);

-               CANCELPT_BEGIN;

                if (at && at->tv_nsec >= 1000000000UL) {
                        errno = EINVAL;
                        return -1;
                }
                if (at && at->tv_nsec >= 1000000000UL) {
                        errno = EINVAL;
                        return -1;
                }

+               CANCELPT_BEGIN;

                if (val <= 0 && __timedwait(sem->__val, val, CLOCK_REALTIME, at, 0) == ETIMEDOUT) {
                        errno = ETIMEDOUT;
                if (val <= 0 && __timedwait(sem->__val, val, CLOCK_REALTIME, at, 0) == ETIMEDOUT) {
                        errno = ETIMEDOUT;

+                       CANCELPT_TRY;
+                       CANCELPT_END;

                        return -1;
                }
                        return -1;
                }

+               CANCELPT_TRY;

                CANCELPT_END;
        }
 }
                CANCELPT_END;
        }
 }

diff --git a/src/time/nanosleep.c b/src/time/nanosleep.c
index 2f65762..0e0753f 100644 (file)
--- a/src/time/nanosleep.c
+++ b/src/time/nanosleep.c
@@ -8,6 +8,7 @@ int nanosleep(const struct timespec *req, struct timespec *rem)
        int ret;
        CANCELPT_BEGIN;
        ret = syscall(SYS_nanosleep, req, rem);
        int ret;
        CANCELPT_BEGIN;
        ret = syscall(SYS_nanosleep, req, rem);

+       CANCELPT_TRY;

        CANCELPT_END;
        return ret;
 }
        CANCELPT_END;
        return ret;
 }