summaryrefslogtreecommitdiff
path: root/src/thread
diff options
context:
space:
mode:
authorRich Felker <dalias@aerifal.cx>2011-03-24 14:18:00 -0400
committerRich Felker <dalias@aerifal.cx>2011-03-24 14:18:00 -0400
commitb470030f839a375e5030ec9d44903ef7581c15a2 (patch)
tree462b1df89a3ea45bcf50b9d0a844472576ed6585 /src/thread
parent095820016689dfdc9141f477a86de22054c86078 (diff)
downloadmusl-b470030f839a375e5030ec9d44903ef7581c15a2.tar.gz
musl-b470030f839a375e5030ec9d44903ef7581c15a2.tar.bz2
musl-b470030f839a375e5030ec9d44903ef7581c15a2.tar.xz
musl-b470030f839a375e5030ec9d44903ef7581c15a2.zip
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...
Diffstat (limited to 'src/thread')
-rw-r--r--src/thread/pthread_cond_timedwait.c10
-rw-r--r--src/thread/pthread_create.c16
-rw-r--r--src/thread/sem_timedwait.c5
3 files changed, 21 insertions, 10 deletions
diff --git a/src/thread/pthread_cond_timedwait.c b/src/thread/pthread_cond_timedwait.c
index 228f61f7..1439aace 100644
--- 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;
- CANCELPT(0);
+ CANCELPT_BEGIN;
+ CANCELPT_END;
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);
- CANCELPT(0);
+ CANCELPT_END;
pthread_cleanup_pop(0);
if ((r=pthread_mutex_lock(m))) return r;
- CANCELPT(0);
+ CANCELPT_BEGIN;
+ CANCELPT_END;
return e;
}
diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c
index 17a47f6a..785a82b8 100644
--- 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 };
+ sigset_t set;
+ self->canceldisable = 1;
+ self->cancelasync = 0;
+ sigemptyset(&set);
+ sigaddset(&set, SIGCANCEL);
+ __libc_sigprocmask(SIG_UNBLOCK, &set, 0);
__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;
- 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;
- 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
diff --git a/src/thread/sem_timedwait.c b/src/thread/sem_timedwait.c
index ad3bf075..11a01700 100644
--- 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);
- CANCELPT_BEGIN;
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;
+ CANCELPT_TRY;
+ CANCELPT_END;
return -1;
}
+ CANCELPT_TRY;
CANCELPT_END;
}
}