Date: Thu, 31 Oct 2002 15:46:45 +0000 (GMT) From: Doug Rabson <dfr@nlsystems.com> To: Daniel Eischen <eischen@pcnet1.pcnet.com> Cc: ak03@gte.com, <tlambert2@mindspring.com>, <current@freebsd.org> Subject: Re: [PATCH: libc]Re: gnome on current Message-ID: <20021031154052.L69202-100000@herring.nlsystems.com> In-Reply-To: <Pine.GSO.4.10.10210311020180.3821-100000@pcnet1.pcnet.com>
next in thread | previous in thread | raw e-mail | index | archive | help
On Thu, 31 Oct 2002, Daniel Eischen wrote:
> On Thu, 31 Oct 2002, Doug Rabson wrote:
> > On Thu, 31 Oct 2002, Daniel Eischen wrote:
> > > You can also play the libgcc game inside of libc for those applications
> > > or libraries that are too lazy to do it for themselves. Have the
> > > libc pthread stubs key on a weak reference to pthread_create and
> > > call the pthread_* if they are present. libXThrStub should be
> > > able to do that though.
> >
> > It almost doesn't matter which of the solutions we use as long as we do
> > something. What we currently have is clearly wrong but I'll list it along
> > with the others. Solutions so far proposed are:
> >
> > 0. (Current behaviour). Define _pthread_* weakly in libc. A pthreads
> > implementation defines strong _pthread_* symbols and weak pthread_*
> > aliases for them. Anyone else which defines pthread_* symbols (either weak
> > or strong) can take over and will normally end up breaking libc.
>
> We only use _pthread_* in libc, so it doesn't break libc unless
> they provide strong symbols for _pthread_*. Our implementation
> relies on the use of single underscore versions in libc so we
> can tell the difference between the implementation locks and
> application locks. The weak references from pthread_* in libc_r
> are to the double underscore versions (mostly, the locking
> functions) so that applications actually resolve to __pthread_mutex_lock
> and libc uses will resolve to _pthread_mutex_lock.
Actually its pretty easy to break libc. Someone calls flockfile() which in
turn calls _pthread_mutex_lock(). This ends up in libc_r which notices
that the mutex is uninitialised and calls init_static(). That calls
pthread_mutex_init() and dies shortly afterwards (note the non-_pthread
call from init_static()).
> >
> > Right now, I can't tell what Solaris does. Alexander suggested that it was
> > (1) but you disagree. It would be interesting to see the output of 'nm |
> > grep pthread' for both libc.so and libpthread.so.
>
> I've already done that and posted it. Here it is again.
>
> ...
Ok then. Next attempt. This one defines weak pthread_foo stubs which call
_pthread_foo. It also defines weak _pthread_foo stubs which are noops. All
symbols weak. Everyone happy. Actually, I haven't tested this since my
test system is at home. For kicks, I also staticised the stubs.
Index: gen/_pthread_stubs.c
===================================================================
RCS file: /home/ncvs/src/lib/libc/gen/_pthread_stubs.c,v
retrieving revision 1.7
diff -u -r1.7 _pthread_stubs.c
--- gen/_pthread_stubs.c 19 Sep 2002 01:09:49 -0000 1.7
+++ gen/_pthread_stubs.c 31 Oct 2002 15:39:50 -0000
@@ -31,6 +31,9 @@
#include <pthread.h>
#include <pthread_np.h>
+void *_pthread_getspecific(pthread_key_t key);
+pthread_t _pthread_self(void);
+
/*
* Weak symbols: All libc internal usage of these functions should
* use the weak symbol versions (_pthread_XXX). If libpthread is
@@ -42,6 +45,7 @@
*/
__weak_reference(_pthread_cond_init_stub, _pthread_cond_init);
__weak_reference(_pthread_cond_signal_stub, _pthread_cond_signal);
+__weak_reference(_pthread_cond_broadcast_stub, _pthread_cond_broadcast);
__weak_reference(_pthread_cond_wait_stub, _pthread_cond_wait);
__weak_reference(_pthread_cond_destroy_stub, _pthread_cond_destroy);
__weak_reference(_pthread_getspecific_stub, _pthread_getspecific);
@@ -59,9 +63,10 @@
__weak_reference(_pthread_once_stub, _pthread_once);
__weak_reference(_pthread_self_stub, _pthread_self);
__weak_reference(_pthread_rwlock_init_stub, _pthread_rwlock_init);
+__weak_reference(_pthread_rwlock_destroy_stub, _pthread_rwlock_destroy);
__weak_reference(_pthread_rwlock_rdlock_stub, _pthread_rwlock_rdlock);
__weak_reference(_pthread_rwlock_tryrdlock_stub, _pthread_rwlock_tryrdlock);
-__weak_reference(_pthread_rwlock_trywrlock_stub, _pthread_rwlock_trywrloc);
+__weak_reference(_pthread_rwlock_trywrlock_stub, _pthread_rwlock_trywrlock);
__weak_reference(_pthread_rwlock_unlock_stub, _pthread_rwlock_unlock);
__weak_reference(_pthread_rwlock_wrlock_stub, _pthread_rwlock_wrlock);
__weak_reference(_pthread_setspecific_stub, _pthread_setspecific);
@@ -73,166 +78,371 @@
static struct pthread main_thread;
-int
+static int
_pthread_cond_init_stub(pthread_cond_t *cond,
const pthread_condattr_t *cond_attr)
{
return (0);
}
-int
+static int
_pthread_cond_signal_stub(pthread_cond_t *cond)
{
return (0);
}
-int
+static int
+_pthread_cond_broadcast_stub(pthread_cond_t *cond)
+{
+ return (0);
+}
+
+static int
_pthread_cond_wait_stub(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
return (0);
}
-int
+static int
_pthread_cond_destroy_stub(pthread_cond_t *cond)
{
return (0);
}
-void *
+static void *
_pthread_getspecific_stub(pthread_key_t key)
{
return (NULL);
}
-int
+static int
_pthread_key_create_stub(pthread_key_t *key, void (*destructor) (void *))
{
return (0);
}
-int
+static int
_pthread_key_delete_stub(pthread_key_t key)
{
return (0);
}
-int
+static int
_pthread_main_np_stub()
{
return (-1);
}
-int
+static int
_pthread_mutex_destroy_stub(pthread_mutex_t *mattr)
{
return (0);
}
-int
+static int
_pthread_mutex_init_stub(pthread_mutex_t *mutex, const pthread_mutexattr_t *mattr)
{
return (0);
}
-int
+static int
_pthread_mutex_lock_stub(pthread_mutex_t *mutex)
{
return (0);
}
-int
+static int
_pthread_mutex_trylock_stub(pthread_mutex_t *mutex)
{
return (0);
}
-int
+static int
_pthread_mutex_unlock_stub(pthread_mutex_t *mutex)
{
return (0);
}
-int
+static int
_pthread_mutexattr_init_stub(pthread_mutexattr_t *mattr)
{
return (0);
}
-int
+static int
_pthread_mutexattr_destroy_stub(pthread_mutexattr_t *mattr)
{
return (0);
}
-int
+static int
_pthread_mutexattr_settype_stub(pthread_mutexattr_t *mattr, int type)
{
return (0);
}
-int
+static int
_pthread_once_stub(pthread_once_t *once_control, void (*init_routine) (void))
{
return (0);
}
-int
+static int
_pthread_rwlock_init_stub(pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr)
{
return (0);
}
-int
+static int
_pthread_rwlock_destroy_stub(pthread_rwlock_t *rwlock)
{
return (0);
}
-int
+static int
_pthread_rwlock_rdlock_stub(pthread_rwlock_t *rwlock)
{
return (0);
}
-int
+static int
_pthread_rwlock_tryrdlock_stub(pthread_rwlock_t *rwlock)
{
return (0);
}
-int
+static int
_pthread_rwlock_trywrlock_stub(pthread_rwlock_t *rwlock)
{
return (0);
}
-int
+static int
_pthread_rwlock_unlock_stub(pthread_rwlock_t *rwlock)
{
return (0);
}
-int
+static int
_pthread_rwlock_wrlock_stub(pthread_rwlock_t *rwlock)
{
return (0);
}
-pthread_t
+static pthread_t
_pthread_self_stub(void)
{
return (&main_thread);
}
-int
+static int
_pthread_setspecific_stub(pthread_key_t key, const void *value)
{
return (0);
}
-int
+static int
_pthread_sigmask_stub(int how, const sigset_t *set, sigset_t *oset)
{
return (0);
}
+
+static int
+pthread_cond_init_stub(pthread_cond_t *cond,
+ const pthread_condattr_t *cond_attr)
+{
+ return (_pthread_cond_init(cond, cond_attr));
+}
+
+static int
+pthread_cond_signal_stub(pthread_cond_t *cond)
+{
+ return (_pthread_cond_signal(cond));
+}
+
+static int
+pthread_cond_broadcast_stub(pthread_cond_t *cond)
+{
+ return (_pthread_cond_broadcast(cond));
+}
+
+static int
+pthread_cond_wait_stub(pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+ return (_pthread_cond_wait(cond, mutex));
+}
+
+static int
+pthread_cond_destroy_stub(pthread_cond_t *cond)
+{
+ return (_pthread_cond_destroy(cond));
+}
+
+static void *
+pthread_getspecific_stub(pthread_key_t key)
+{
+ return (_pthread_getspecific(key));
+}
+
+static int
+pthread_key_create_stub(pthread_key_t *key, void (*destructor) (void *))
+{
+ return (_pthread_key_create(key, destructor));
+}
+
+static int
+pthread_key_delete_stub(pthread_key_t key)
+{
+ return (_pthread_key_delete(key));
+}
+
+static int
+pthread_main_np_stub()
+{
+ return (_pthread_main_np());
+}
+
+static int
+pthread_mutex_destroy_stub(pthread_mutex_t *mattr)
+{
+ return (_pthread_mutex_destroy(mattr));
+}
+
+static int
+pthread_mutex_init_stub(pthread_mutex_t *mutex, const pthread_mutexattr_t *mattr)
+{
+ return (_pthread_mutex_init(mutex, mattr));
+}
+
+static int
+pthread_mutex_lock_stub(pthread_mutex_t *mutex)
+{
+ return (_pthread_mutex_lock(mutex));
+}
+
+static int
+pthread_mutex_trylock_stub(pthread_mutex_t *mutex)
+{
+ return (_pthread_mutex_trylock(mutex));
+}
+
+static int
+pthread_mutex_unlock_stub(pthread_mutex_t *mutex)
+{
+ return (_pthread_mutex_unlock(mutex));
+}
+
+static int
+pthread_mutexattr_init_stub(pthread_mutexattr_t *mattr)
+{
+ return (_pthread_mutexattr_init(mattr));
+}
+
+static int
+pthread_mutexattr_destroy_stub(pthread_mutexattr_t *mattr)
+{
+ return (_pthread_mutexattr_destroy(mattr));
+}
+
+static int
+pthread_mutexattr_settype_stub(pthread_mutexattr_t *mattr, int type)
+{
+ return (_pthread_mutexattr_settype(mattr, type));
+}
+
+static int
+pthread_once_stub(pthread_once_t *once_control, void (*init_routine) (void))
+{
+ return (_pthread_once(once_control, init_routine));
+}
+
+static int
+pthread_rwlock_init_stub(pthread_rwlock_t *rwlock,
+ const pthread_rwlockattr_t *attr)
+{
+ return (_pthread_rwlock_init(rwlock, attr));
+}
+
+static int
+pthread_rwlock_destroy_stub(pthread_rwlock_t *rwlock)
+{
+ return (_pthread_rwlock_destroy(rwlock));
+}
+
+static int
+pthread_rwlock_rdlock_stub(pthread_rwlock_t *rwlock)
+{
+ return (_pthread_rwlock_rdlock(rwlock));
+}
+
+static int
+pthread_rwlock_tryrdlock_stub(pthread_rwlock_t *rwlock)
+{
+ return (_pthread_rwlock_tryrdlock(rwlock));
+}
+
+static int
+pthread_rwlock_trywrlock_stub(pthread_rwlock_t *rwlock)
+{
+ return (_pthread_rwlock_trywrlock(rwlock));
+}
+
+static int
+pthread_rwlock_unlock_stub(pthread_rwlock_t *rwlock)
+{
+ return (_pthread_rwlock_unlock(rwlock));
+}
+
+static int
+pthread_rwlock_wrlock_stub(pthread_rwlock_t *rwlock)
+{
+ return (_pthread_rwlock_wrlock(rwlock));
+}
+
+static pthread_t
+pthread_self_stub(void)
+{
+ return (_pthread_self());
+}
+
+static int
+pthread_setspecific_stub(pthread_key_t key, const void *value)
+{
+ return (_pthread_setspecific(key, value));
+}
+
+static int
+pthread_sigmask_stub(int how, const sigset_t *set, sigset_t *oset)
+{
+ return (_pthread_sigmask(how, set, oset));
+}
+
+__weak_reference(pthread_cond_init_stub, pthread_cond_init);
+__weak_reference(pthread_cond_signal_stub, pthread_cond_signal);
+__weak_reference(pthread_cond_broadcast_stub, pthread_cond_broadcast);
+__weak_reference(pthread_cond_wait_stub, pthread_cond_wait);
+__weak_reference(pthread_cond_destroy_stub, pthread_cond_destroy);
+__weak_reference(pthread_getspecific_stub, pthread_getspecific);
+__weak_reference(pthread_key_create_stub, pthread_key_create);
+__weak_reference(pthread_key_delete_stub, pthread_key_delete);
+__weak_reference(pthread_main_np_stub, pthread_main_np);
+__weak_reference(pthread_mutex_destroy_stub, pthread_mutex_destroy);
+__weak_reference(pthread_mutex_init_stub, pthread_mutex_init);
+__weak_reference(pthread_mutex_lock_stub, pthread_mutex_lock);
+__weak_reference(pthread_mutex_trylock_stub, pthread_mutex_trylock);
+__weak_reference(pthread_mutex_unlock_stub, pthread_mutex_unlock);
+__weak_reference(pthread_mutexattr_init_stub, pthread_mutexattr_init);
+__weak_reference(pthread_mutexattr_destroy_stub, pthread_mutexattr_destroy);
+__weak_reference(pthread_mutexattr_settype_stub, pthread_mutexattr_settype);
+__weak_reference(pthread_once_stub, pthread_once);
+__weak_reference(pthread_self_stub, pthread_self);
+__weak_reference(pthread_rwlock_init_stub, pthread_rwlock_init);
+__weak_reference(pthread_rwlock_destroy_stub, pthread_rwlock_destroy);
+__weak_reference(pthread_rwlock_rdlock_stub, pthread_rwlock_rdlock);
+__weak_reference(pthread_rwlock_tryrdlock_stub, pthread_rwlock_tryrdlock);
+__weak_reference(pthread_rwlock_trywrlock_stub, pthread_rwlock_trywrlock);
+__weak_reference(pthread_rwlock_unlock_stub, pthread_rwlock_unlock);
+__weak_reference(pthread_rwlock_wrlock_stub, pthread_rwlock_wrlock);
+__weak_reference(pthread_setspecific_stub, pthread_setspecific);
+__weak_reference(pthread_sigmask_stub, pthread_sigmask);
Index: include/namespace.h
===================================================================
RCS file: /home/ncvs/src/lib/libc/include/namespace.h,v
retrieving revision 1.9
diff -u -r1.9 namespace.h
--- include/namespace.h 29 Mar 2002 22:43:42 -0000 1.9
+++ include/namespace.h 30 Oct 2002 20:04:44 -0000
@@ -77,6 +77,7 @@
#define open _open
#define poll _poll
#define pthread_cond_signal _pthread_cond_signal
+#define pthread_cond_broadcast _pthread_cond_broadcast
#define pthread_cond_wait _pthread_cond_wait
#define pthread_cond_init _pthread_cond_init
#define pthread_exit _pthread_exit
Index: include/reentrant.h
===================================================================
RCS file: /home/ncvs/src/lib/libc/include/reentrant.h,v
retrieving revision 1.1
diff -u -r1.1 reentrant.h
--- include/reentrant.h 19 Mar 2001 12:49:49 -0000 1.1
+++ include/reentrant.h 30 Oct 2002 20:04:44 -0000
@@ -109,6 +109,8 @@
#define cond_init(c, a, p) _pthread_cond_init(c, a)
#define cond_signal(m) if (__isthreaded) \
_pthread_cond_signal(m)
+#define cond_broadcast(m) if (__isthreaded) \
+ _pthread_cond_broadcast(m)
#define cond_wait(c, m) if (__isthreaded) \
_pthread_cond_wait(c, m)
--
Doug Rabson Mail: dfr@nlsystems.com
Phone: +44 20 8348 6160
To Unsubscribe: send mail to majordomo@FreeBSD.org
with "unsubscribe freebsd-current" in the body of the message
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?20021031154052.L69202-100000>