./usr/lib/libm.so minix-sys
./usr/lib/libmthread.a minix-sys
./usr/lib/libmthread_pic.a minix-sys
+./usr/lib/libmthread.so.0.0 minix-sys
+./usr/lib/libmthread.so.0 minix-sys
+./usr/lib/libmthread.so minix-sys
./usr/lib/libnetdriver.a minix-sys
./usr/lib/libnetdriver_pic.a minix-sys
./usr/lib/libnetsock.a minix-sys
#define MTHREAD_STACK_MIN MINSIGSTKSZ
#define MTHREAD_KEYS_MAX 128
+__BEGIN_DECLS
/* allocate.c */
int mthread_create(mthread_thread_t *thread, mthread_attr_t *tattr, void
*(*proc)(void *), void *arg);
int mthread_rwlock_unlock(mthread_rwlock_t *rwlock);
/* schedule.c */
-void mthread_init(void);
int mthread_yield(void);
void mthread_yield_all(void);
+__END_DECLS
+
+#if defined(_MTHREADIFY_PTHREADS)
+typedef mthread_thread_t pthread_t;
+typedef mthread_once_t pthread_once_t;
+typedef mthread_key_t pthread_key_t;
+typedef mthread_cond_t pthread_cond_t;
+typedef mthread_mutex_t pthread_mutex_t;
+typedef mthread_condattr_t pthread_condattr_t;
+typedef mthread_mutexattr_t pthread_mutexattr_t;
+typedef mthread_attr_t pthread_attr_t;
+typedef mthread_event_t pthread_event_t;
+typedef mthread_rwlock_t pthread_rwlock_t;
+
+/* LSC: No equivalent, so void* for now. */
+typedef void *pthread_rwlockattr_t;
+
+#define PTHREAD_ONCE_INIT 0
+#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) -1)
+#define PTHREAD_COND_INITIALIZER ((pthread_cond_t) -1)
+
+__BEGIN_DECLS
+/* allocate.c */
+int pthread_create(pthread_t *thread, pthread_attr_t *tattr, void
+ *(*proc)(void *), void *arg);
+int pthread_detach(pthread_t thread);
+int pthread_equal(pthread_t l, pthread_t r);
+void pthread_exit(void *value);
+int pthread_join(pthread_t thread, void **value);
+int pthread_once(pthread_once_t *once, void (*proc)(void));
+pthread_t pthread_self(void);
+
+/* attribute.c */
+int pthread_attr_destroy(pthread_attr_t *tattr);
+int pthread_attr_getdetachstate(pthread_attr_t *tattr, int
+ *detachstate);
+int pthread_attr_getstack(pthread_attr_t *tattr, void **stackaddr,
+ size_t *stacksize);
+int pthread_attr_getstacksize(pthread_attr_t *tattr, size_t *stacksize);
+int pthread_attr_init(pthread_attr_t *tattr);
+int pthread_attr_setdetachstate(pthread_attr_t *tattr, int detachstate);
+int pthread_attr_setstack(pthread_attr_t *tattr, void *stackaddr, size_t
+ stacksize);
+int pthread_attr_setstacksize(pthread_attr_t *tattr, size_t stacksize);
+
+/* condition.c */
+int pthread_cond_broadcast(pthread_cond_t *cond);
+int pthread_cond_destroy(pthread_cond_t *cond);
+int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cattr);
+int pthread_cond_signal(pthread_cond_t *cond);
+int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
+
+/* key.c */
+int pthread_key_create(pthread_key_t *key, void (*destructor)(void *));
+int pthread_key_delete(pthread_key_t key);
+void *pthread_getspecific(pthread_key_t key);
+int pthread_setspecific(pthread_key_t key, void *value);
+
+/* mutex.c */
+int pthread_mutex_destroy(pthread_mutex_t *mutex);
+int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t
+ *mattr);
+int pthread_mutex_lock(pthread_mutex_t *mutex);
+int pthread_mutex_trylock(pthread_mutex_t *mutex);
+int pthread_mutex_unlock(pthread_mutex_t *mutex);
+
+/* event.c */
+int pthread_event_destroy(pthread_event_t *event);
+int pthread_event_init(pthread_event_t *event);
+int pthread_event_wait(pthread_event_t *event);
+int pthread_event_fire(pthread_event_t *event);
+int pthread_event_fire_all(pthread_event_t *event);
+
+/* rwlock.c */
+int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
+int pthread_rwlock_init(pthread_rwlock_t *rwlock,
+ pthread_rwlockattr_t *UNUSED(attr));
+int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
+int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
+int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
+
+/* schedule.c */
+int pthread_yield(void);
+int sched_yield(void);
+void pthread_yield_all(void);
+
+/* LSC: FIXME: Maybe we should really do something with those... */
+#define pthread_mutexattr_init(u) (0)
+#define pthread_mutexattr_destroy(u) (0)
+
+#define PTHREAD_MUTEX_RECURSIVE 0
+#define pthread_mutexattr_settype(x, y) (EINVAL)
+__END_DECLS
+#endif /* defined(_MTHREADIFY_PTHREADS) */
#endif
. endif
.endif
-#LSC MINIX libc depends on libminlib because of minix/malloc-debug.c
+#LSC MINIX libc depends on
+# - libminlib because of minix/malloc-debug.c
+# - libmthread because of sys/lib/libunwind
SUBDIR+= libminlib
SUBDIR+= .WAIT
SUBDIR+= libsys
+SUBDIR+= libmthread
SUBDIR+= .WAIT
SUBDIR+= libc
libinputdriver \
libminc \
libminixfs \
- libmthread \
libnetdriver \
libsffs \
libtimers \
assert(bdp != NULL);
assert(bdp->bdr_device != NULL);
- mthread_init();
-
bdtab = bdp;
/* Initialize device-specific data structures. */
SRCS= \
allocate.c \
attribute.c \
- mutex.c \
+ condition.c \
event.c \
- rwlock.c \
+ key.c \
misc.c \
+ mutex.c \
+ pthread_compat.c \
queue.c \
- condition.c \
+ rwlock.c \
scheduler.c \
- key.c
WARNS?= 4
mthread_thread_t r;
{
/* Compare two thread ids */
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
return(l == r);
}
/* Register procedure proc for execution in a thread. */
mthread_thread_t thread;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (proc == NULL)
return(EINVAL);
* this thread are automatically freed.
*/
mthread_tcb_t *tcb;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
if (!isokthreadid(detach))
return(ESRCH);
/* Make a thread stop running and store the result value. */
mthread_tcb_t *tcb;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
tcb = mthread_find_tcb(current_thread);
if (tcb->m_state == MS_EXITING) /* Already stopping, nothing to do. */
/*===========================================================================*
* mthread_init *
*===========================================================================*/
-void mthread_init(void)
+static void __attribute__((__constructor__, __used__)) mthread_init(void)
{
/* Initialize thread system; allocate thread structures and start creating
* threads.
mthread_tcb_t *tcb;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (!isokthreadid(join))
return(ESRCH);
else if (join == current_thread)
{
/* Run procedure proc just once */
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (once == NULL || proc == NULL)
return(EINVAL);
{
/* Return the thread id of the thread calling this function. */
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
return(current_thread);
}
mthread_exit(r);
}
+/* pthread compatibility layer. */
+__weak_alias(pthread_create, mthread_create)
+__weak_alias(pthread_detach, mthread_detach)
+__weak_alias(pthread_equal, mthread_equal)
+__weak_alias(pthread_exit, mthread_exit)
+__weak_alias(pthread_join, mthread_join)
+__weak_alias(pthread_once, mthread_once)
+__weak_alias(pthread_self, mthread_self)
+
{
/* Invalidate attribute and deallocate resources. */
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (attr == NULL)
return(EINVAL);
/* Initialize the attribute to a known state. */
struct __mthread_attr *a;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (attr == NULL)
return(EAGAIN);
else if (mthread_attr_valid(attr))
/* Get detachstate of a thread attribute */
struct __mthread_attr *a;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (attr == NULL)
return(EINVAL);
/* Set detachstate of a thread attribute */
struct __mthread_attr *a;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (attr == NULL)
return(EINVAL);
/* Get stack attribute */
struct __mthread_attr *a;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (attr == NULL)
return(EINVAL);
/* Get stack size attribute */
struct __mthread_attr *a;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (attr == NULL)
return(EINVAL);
/* Set stack attribute */
struct __mthread_attr *a;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (attr == NULL)
return(EINVAL);
/* Set stack size attribute */
struct __mthread_attr *a;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (attr == NULL)
return(EINVAL);
/* Check to see if attribute is on the list of valid attributes */
struct __mthread_attr *loopitem;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
loopitem = va_front;
while (loopitem != NULL) {
/* Return true when no attributes are in use */
struct __mthread_attr *loopitem;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
loopitem = va_front;
while (loopitem != NULL) {
}
#endif
+/* pthread compatibility layer. */
+__weak_alias(pthread_attr_destroy, mthread_attr_destroy)
+__weak_alias(pthread_attr_getdetachstate, mthread_attr_getdetachstate)
+__weak_alias(pthread_attr_getstack, mthread_attr_getstack)
+__weak_alias(pthread_attr_getstacksize, mthread_attr_getstacksize)
+__weak_alias(pthread_attr_init, mthread_attr_init)
+__weak_alias(pthread_attr_setdetachstate, mthread_attr_setdetachstate)
+__weak_alias(pthread_attr_setstack, mthread_attr_setstack)
+__weak_alias(pthread_attr_setstacksize, mthread_attr_setstacksize)
mthread_thread_t t;
mthread_tcb_t *tcb;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (cond == NULL)
return(EINVAL);
else if (!mthread_cond_valid(cond))
mthread_thread_t t;
mthread_tcb_t *tcb;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (cond == NULL)
return(EINVAL);
else if (!mthread_cond_valid(cond))
/* Initialize condition variable to a known state. cattr is ignored */
struct __mthread_cond *c;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (cond == NULL)
return(EINVAL);
else if (cattr != NULL)
mthread_thread_t t;
mthread_tcb_t *tcb;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (cond == NULL)
return(EINVAL);
else if (!mthread_cond_valid(cond))
/* Check to see if cond is on the list of valid conditions */
struct __mthread_cond *loopitem;
- MTHREAD_CHECK_INIT();
-
loopitem = vc_front;
while (loopitem != NULL) {
{
/* Return true in case no condition variables are in use. */
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
return(vc_front == NULL);
}
#endif
struct __mthread_cond *c;
struct __mthread_mutex *m;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (cond == NULL || mutex == NULL)
return(EINVAL);
return(0);
}
+/* pthread compatibility layer. */
+__weak_alias(pthread_cond_init, mthread_cond_init)
return mthread_mutex_unlock(&event->mutex);
}
+
+/* pthread compatibility layer. */
+__weak_alias(pthread_event_destroy, mthread_event_destroy)
+__weak_alias(pthread_event_init, mthread_event_init)
+__weak_alias(pthread_event_wait, mthread_event_wait)
+__weak_alias(pthread_event_fire, mthread_event_fire)
+__weak_alias(pthread_event_fire_all, mthread_event_fire_all)
+
*/
mthread_key_t k;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
keys_used = 1;
/* We do not yet allocate storage space for the values here, because we can
/* Free up a key, as well as any associated storage space.
*/
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (key < 0 || key >= MTHREAD_KEYS_MAX || !keys[key].used)
return(EINVAL);
/* Get this thread's local value for the given key. The default is NULL.
*/
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (key < 0 || key >= MTHREAD_KEYS_MAX || !keys[key].used)
return(NULL);
*/
void **p;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (key < 0 || key >= MTHREAD_KEYS_MAX || !keys[key].used)
return(EINVAL);
}
} while (found);
}
+
+/* pthread compatibility layer. */
+__weak_alias(pthread_key_create, mthread_key_create)
+__weak_alias(pthread_key_delete, mthread_key_delete)
+__weak_alias(pthread_getspecific, mthread_getspecific)
+__weak_alias(pthread_setspecific, mthread_setspecific)
+
mthread_thread_t t;
mthread_tcb_t *tcb;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (mutex == NULL)
return(EINVAL);
struct __mthread_mutex *m;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (mutex == NULL)
return(EAGAIN);
else if (mattr != NULL)
struct __mthread_mutex *m;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (mutex == NULL)
return(EINVAL);
struct __mthread_mutex *m;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (mutex == NULL)
return(EINVAL);
struct __mthread_mutex *m;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
if (mutex == NULL)
return(EINVAL);
/* Check to see if mutex is on the list of valid mutexes */
struct __mthread_mutex *loopitem;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
loopitem = vm_front;
while (loopitem != NULL) {
int r = 1;
struct __mthread_mutex *loopitem;
- MTHREAD_CHECK_INIT(); /* Make sure mthreads is initialized */
-
#ifdef MTHREAD_STRICT
loopitem = vm_front;
return(r);
}
#endif
-
-
#ifdef MTHREAD_STRICT
int mthread_mutex_valid(mthread_mutex_t *mutex);
-# define MTHREAD_CHECK_INIT() mthread_init()
#else
# define mthread_mutex_valid(x) ((*x)->mm_magic == MTHREAD_INIT_MAGIC)
-# define MTHREAD_CHECK_INIT()
#endif
#ifdef MDEBUG
--- /dev/null
+#define _MTHREADIFY_PTHREADS
+#include <minix/mthread.h>
+#include "global.h"
+#include "proto.h"
+
+/* WARNING:
+ * The following works under the hypothesis that we have only green threads,
+ * which implies that we have no preemption, unless explicit yield or possible
+ * calls done to mthread functions.
+ *
+ * This has impact on the fact we do not maintain a table of currently being
+ * initialized mutexes or condition variables, to prevent double initialization
+ * and/or TOCTU problems. TOCTU could appear between the test against the
+ * initializer value, and the actual initialization, which could lead to double
+ * initialization of the same mutex AND get two threads at the same time in the
+ * critical section as they both hold a (different) mutex.
+ */
+
+
+/*===========================================================================*
+ * pthread_mutex_init *
+ *===========================================================================*/
+int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *mattr)
+{
+ return mthread_mutex_init(mutex, mattr);
+}
+
+/*===========================================================================*
+ * pthread_mutex_destroy *
+ *===========================================================================*/
+int pthread_mutex_destroy(pthread_mutex_t *mutex)
+{
+ if (PTHREAD_MUTEX_INITIALIZER == *mutex) {
+ *mutex = NULL;
+ return 0;
+ }
+
+ return mthread_mutex_destroy(mutex);
+}
+
+/*===========================================================================*
+ * pthread_mutex_lock *
+ *===========================================================================*/
+int pthread_mutex_lock(pthread_mutex_t *mutex)
+{
+ if (PTHREAD_MUTEX_INITIALIZER == *mutex) {
+ mthread_mutex_init(mutex, NULL);
+ }
+
+ return mthread_mutex_lock(mutex);
+}
+
+/*===========================================================================*
+ * pthread_mutex_trylock *
+ *===========================================================================*/
+int pthread_mutex_trylock(pthread_mutex_t *mutex)
+{
+ if (PTHREAD_MUTEX_INITIALIZER == *mutex) {
+ mthread_mutex_init(mutex, NULL);
+ }
+
+ return pthread_mutex_trylock(mutex);
+}
+
+/*===========================================================================*
+ * pthread_mutex_unlock *
+ *===========================================================================*/
+int pthread_mutex_unlock(pthread_mutex_t *mutex)
+{
+ if (PTHREAD_MUTEX_INITIALIZER == *mutex) {
+ mthread_mutex_init(mutex, NULL);
+ }
+
+ return mthread_mutex_unlock(mutex);
+}
+
+/*===========================================================================*
+ * pthread_cond_init *
+ *===========================================================================*/
+int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cattr)
+{
+ return mthread_cond_init(cond, cattr);
+}
+
+/*===========================================================================*
+ * pthread_cond_broadcast *
+ *===========================================================================*/
+int pthread_cond_broadcast(pthread_cond_t *cond)
+{
+ if (PTHREAD_COND_INITIALIZER == *cond) {
+ mthread_cond_init(cond, NULL);
+ }
+
+ return mthread_cond_broadcast(cond);
+}
+
+/*===========================================================================*
+ * pthread_cond_destroy *
+ *===========================================================================*/
+int pthread_cond_destroy(pthread_cond_t *cond)
+{
+ if (PTHREAD_COND_INITIALIZER == *cond) {
+ *cond = NULL;
+ return 0;
+ }
+
+ return mthread_cond_destroy(cond);
+}
+
+/*===========================================================================*
+ * pthread_cond_signal *
+ *===========================================================================*/
+int pthread_cond_signal(pthread_cond_t *cond)
+{
+ if (PTHREAD_COND_INITIALIZER == *cond) {
+ mthread_cond_init(cond, NULL);
+ }
+
+ return mthread_cond_signal(cond);
+}
+
+/*===========================================================================*
+ * pthread_cond_wait *
+ *===========================================================================*/
+int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+ if (PTHREAD_COND_INITIALIZER == *cond) {
+ mthread_cond_init(cond, NULL);
+ }
+
+ return mthread_cond_wait(cond, mutex);
+}
+
+/*===========================================================================*
+ * pthread_rwlock_init *
+ *===========================================================================*/
+int pthread_rwlock_init(pthread_rwlock_t *rwlock, pthread_rwlockattr_t *UNUSED(attr))
+{
+ return mthread_rwlock_init(rwlock);
+}
+
+#if !defined(__weak_alias)
+#error __weak_alias is required to compile the pthread compat library
+#endif
+
return r;
}
+
+/* pthread compatibility layer. */
+__weak_alias(pthread_rwlock_destroy, mthread_rwlock_destroy)
+__weak_alias(pthread_rwlock_rdlock, mthread_rwlock_rdlock)
+__weak_alias(pthread_rwlock_wrlock, mthread_rwlock_wrlock)
+__weak_alias(pthread_rwlock_unlock, mthread_rwlock_unlock)
+
mthread_tcb_t *new_tcb, *old_tcb;
ucontext_t *new_ctx, *old_ctx;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
old_thread = current_thread;
if (mthread_queue_isempty(&run_queue)) {
mthread_tcb_t *tcb;
mthread_thread_t t;
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
/* Detached threads cannot clean themselves up. This is a perfect moment to
* do it */
for (t = (mthread_thread_t) 0; need_reset > 0 && t < no_threads; t++) {
* this function will lead to a deadlock.
*/
- MTHREAD_CHECK_INIT(); /* Make sure libmthread is initialized */
-
if (yield_all) mthread_panic("Deadlock: two threads trying to yield_all");
yield_all = 1;
yield_all = 0;
}
+/* pthread compatibility layer. */
+__weak_alias(pthread_yield, mthread_yield)
+__weak_alias(sched_yield, mthread_yield)
+__weak_alias(pthread_yield_all, mthread_yield_all)
+
--- /dev/null
+major=0
+minor=0
#define cond_t mthread_cond_t
#define attr_t mthread_attr_t
-#define threads_init mthread_init
#define yield mthread_yield
#define yield_all mthread_yield_all
struct worker_thread *wp;
int i;
- threads_init();
if (mthread_attr_init(&tattr) != 0)
panic("failed to initialize attribute");
if (mthread_attr_setstacksize(&tattr, TH_STACKSIZE) != 0)
.endif
.else
.if ${LIB} != "c" && ${LIB:Mgcc*} == "" \
- && ${LIB} != "minlib" && ${LIB} != "sys" && ${LIB} != "minc" # Minix-specific libs
+ && ${LIB} != "minlib" && ${LIB} != "sys" && ${LIB} != "minc" && ${LIB} != "mthread" # Minix-specific libs
.if !empty(LIBC_SO)
DPLIBC ?= ${DESTDIR}${LIBC_SO}
.endif
devman \
minc \
minlib \
+ mthread \
netdriver \
sffs \
sys \
once = MTHREAD_ONCE_INIT;
start(59);
- mthread_init();
test_scheduling();
test_mutex();
test_event();