upstream/opnsense-src
1
0
Fork 0
mirror of https://github.com/opnsense/src.git synced 2026-05-28 04:12:45 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Block almost all signals in the default locking method instead of

Browse source 
just a few of them.  This looks like it solves the recent

  ld-elf.so.1: assert failed: /usr/src/libexec/rtld-elf/lockdflt.c:55

failures seen by some applications such as JDK.
This commit is contained in:
John Polstra 2000-01-25 01:32:56 +00:00
parent 69a3468578
commit 5bc2f0f789
4 changed files with 40 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
libexec/rtld-elf/alpha/lockdflt.c
View file

@ -28,10 +28,9 @@
/*
* Default thread locking implementation for the dynamic linker. It
* is used until the client registers a different implementation with
* dllockinit(). The default implementation does mutual exclusion
* by blocking the SIGVTALRM, SIGPROF, and SIGALRM signals. This is
* based on the observation that most userland thread packages use one
* of these signals to support preemption.
* dllockinit(). The default implementation does mutual exclusion by
* blocking almost all signals. This is based on the observation that
* most userland thread packages use signals to support preemption.
*/
#include <dlfcn.h>
@ -63,10 +62,13 @@ lockdflt_create(void *context)
l = NEW(LockDflt);
l->depth = 0;
sigemptyset(&l->lock_mask);
sigaddset(&l->lock_mask, SIGVTALRM);
sigaddset(&l->lock_mask, SIGPROF);
sigaddset(&l->lock_mask, SIGALRM);
sigfillset(&l->lock_mask);
sigdelset(&l->lock_mask, SIGTRAP);
sigdelset(&l->lock_mask, SIGABRT);
sigdelset(&l->lock_mask, SIGBUS);
sigdelset(&l->lock_mask, SIGSEGV);
sigdelset(&l->lock_mask, SIGKILL);
sigdelset(&l->lock_mask, SIGSTOP);
return l;
}

18
libexec/rtld-elf/amd64/lockdflt.c
View file

@ -28,10 +28,9 @@
/*
* Default thread locking implementation for the dynamic linker. It
* is used until the client registers a different implementation with
* dllockinit(). The default implementation does mutual exclusion
* by blocking the SIGVTALRM, SIGPROF, and SIGALRM signals. This is
* based on the observation that most userland thread packages use one
* of these signals to support preemption.
* dllockinit(). The default implementation does mutual exclusion by
* blocking almost all signals. This is based on the observation that
* most userland thread packages use signals to support preemption.
*/
#include <dlfcn.h>
@ -63,10 +62,13 @@ lockdflt_create(void *context)
l = NEW(LockDflt);
l->depth = 0;
sigemptyset(&l->lock_mask);
sigaddset(&l->lock_mask, SIGVTALRM);
sigaddset(&l->lock_mask, SIGPROF);
sigaddset(&l->lock_mask, SIGALRM);
sigfillset(&l->lock_mask);
sigdelset(&l->lock_mask, SIGTRAP);
sigdelset(&l->lock_mask, SIGABRT);
sigdelset(&l->lock_mask, SIGBUS);
sigdelset(&l->lock_mask, SIGSEGV);
sigdelset(&l->lock_mask, SIGKILL);
sigdelset(&l->lock_mask, SIGSTOP);
return l;
}

18
libexec/rtld-elf/i386/lockdflt.c
View file

@ -28,10 +28,9 @@
/*
* Default thread locking implementation for the dynamic linker. It
* is used until the client registers a different implementation with
* dllockinit(). The default implementation does mutual exclusion
* by blocking the SIGVTALRM, SIGPROF, and SIGALRM signals. This is
* based on the observation that most userland thread packages use one
* of these signals to support preemption.
* dllockinit(). The default implementation does mutual exclusion by
* blocking almost all signals. This is based on the observation that
* most userland thread packages use signals to support preemption.
*/
#include <dlfcn.h>
@ -63,10 +62,13 @@ lockdflt_create(void *context)
l = NEW(LockDflt);
l->depth = 0;
sigemptyset(&l->lock_mask);
sigaddset(&l->lock_mask, SIGVTALRM);
sigaddset(&l->lock_mask, SIGPROF);
sigaddset(&l->lock_mask, SIGALRM);
sigfillset(&l->lock_mask);
sigdelset(&l->lock_mask, SIGTRAP);
sigdelset(&l->lock_mask, SIGABRT);
sigdelset(&l->lock_mask, SIGBUS);
sigdelset(&l->lock_mask, SIGSEGV);
sigdelset(&l->lock_mask, SIGKILL);
sigdelset(&l->lock_mask, SIGSTOP);
return l;
}

18
libexec/rtld-elf/lockdflt.c
View file

@ -28,10 +28,9 @@
/*
* Default thread locking implementation for the dynamic linker. It
* is used until the client registers a different implementation with
* dllockinit(). The default implementation does mutual exclusion
* by blocking the SIGVTALRM, SIGPROF, and SIGALRM signals. This is
* based on the observation that most userland thread packages use one
* of these signals to support preemption.
* dllockinit(). The default implementation does mutual exclusion by
* blocking almost all signals. This is based on the observation that
* most userland thread packages use signals to support preemption.
*/
#include <dlfcn.h>
@ -63,10 +62,13 @@ lockdflt_create(void *context)
l = NEW(LockDflt);
l->depth = 0;
sigemptyset(&l->lock_mask);
sigaddset(&l->lock_mask, SIGVTALRM);
sigaddset(&l->lock_mask, SIGPROF);
sigaddset(&l->lock_mask, SIGALRM);
sigfillset(&l->lock_mask);
sigdelset(&l->lock_mask, SIGTRAP);
sigdelset(&l->lock_mask, SIGABRT);
sigdelset(&l->lock_mask, SIGBUS);
sigdelset(&l->lock_mask, SIGSEGV);
sigdelset(&l->lock_mask, SIGKILL);
sigdelset(&l->lock_mask, SIGSTOP);
return l;
}