sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Clean up mthread

Browse source
This commit is contained in:
Thomas Veerman 2011-07-27 09:30:26 +00:00
parent b67a7fca8c
commit 9b43de2cb3
10 changed files with 111 additions and 132 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
common/include/minix/mthread.h
View file

@ -9,9 +9,6 @@
#include <ucontext.h>
#include <errno.h>
#include <stdlib.h>
#ifndef __NBSD_LIBC
#include <alloca.h>
#endif
#include <limits.h>
#ifdef __NBSD_LIBC
#include <sys/signal.h>
@ -32,16 +29,20 @@ typedef struct {
struct __mthread_mutex {
mthread_queue_t mm_queue; /* Queue of threads blocked on this mutex */
mthread_thread_t mm_owner; /* Thread ID that currently owns mutex */
#ifdef MTHREAD_STRICT
struct __mthread_mutex *mm_prev;
struct __mthread_mutex *mm_next;
#endif
unsigned int mm_magic;
};
typedef struct __mthread_mutex *mthread_mutex_t;
struct __mthread_cond {
struct __mthread_mutex *mc_mutex; /* Associate mutex with condition */
#ifdef MTHREAD_STRICT
struct __mthread_cond *mc_prev;
struct __mthread_cond *mc_next;
#endif
unsigned int mc_magic;
};
typedef struct __mthread_cond *mthread_cond_t;
@ -64,7 +65,7 @@ typedef struct __mthread_attr *mthread_attr_t;
/* allocate.c */
_PROTOTYPE( int mthread_create, (mthread_thread_t *thread,
mthread_attr_t *tattr,
void (*proc)(void *), void *arg) );
void *(*proc)(void *), void *arg) );
_PROTOTYPE( int mthread_detach, (mthread_thread_t thread) );
_PROTOTYPE( int mthread_equal, (mthread_thread_t l, mthread_thread_t r) );
_PROTOTYPE( void mthread_exit, (void *value) );

66
lib/libmthread/allocate.c
View file

@ -5,13 +5,10 @@
#include "global.h"
#include "proto.h"
#define FALLBACK_CTX (&(fallback.m_context))
FORWARD _PROTOTYPE( void mthread_fallback, (void) );
FORWARD _PROTOTYPE( int mthread_increase_thread_pool, (void) );
FORWARD _PROTOTYPE( void mthread_thread_init, (mthread_thread_t thread,
mthread_attr_t *tattr,
void (*proc)(void *),
void *(*proc)(void *),
void *arg) );
FORWARD _PROTOTYPE( void mthread_thread_reset, (mthread_thread_t thread));
@ -45,7 +42,7 @@ mthread_thread_t r;
PUBLIC int mthread_create(threadid, tattr, proc, arg)
mthread_thread_t *threadid;
mthread_attr_t *tattr;
void (*proc)(void *);
void *(*proc)(void *);
void *arg;
{
/* Register procedure proc for execution in a thread. */
@ -111,7 +108,6 @@ PUBLIC void mthread_exit(value)
void *value;
{
/* Make a thread stop running and store the result value. */
int fallback_exit = 0;
mthread_tcb_t *tcb;
mthread_init(); /* Make sure libmthread is initialized */
@ -123,13 +119,6 @@ void *value;
mthread_cleanup_values();
/* When we're called from the fallback thread, the fallback thread
* will invoke the scheduler. However, if the thread itself called
* mthread_exit, _we_ will have to wake up the scheduler.
*/
if (tcb->m_state == MS_FALLBACK_EXITING)
fallback_exit = 1;
tcb->m_result = value;
tcb->m_state = MS_EXITING;
@ -145,42 +134,9 @@ void *value;
*/
}
/* The fallback thread does a mthread_schedule. If we're not running from
* that thread, we have to do it ourselves.
*/
if (!fallback_exit)
mthread_schedule();
}
/*===========================================================================*
* mthread_fallback *
*===========================================================================*/
PRIVATE void mthread_fallback(void)
{
/* The libmthread fallback thread. The idea is that every thread calls
* mthread_exit(...) to stop running when it has nothing to do anymore.
* However, in case a thread forgets to do that, the whole process exit()s and
* that might be a bit problematic. Therefore, all threads will run this
* fallback thread when they exit, giving the scheduler a chance to fix the
* situation.
*/
mthread_tcb_t *tcb;
tcb = mthread_find_tcb(current_thread);
tcb->m_state = MS_FALLBACK_EXITING;
mthread_exit(NULL);
/* Reconstruct fallback context for next invocation */
makecontext(FALLBACK_CTX, (void (*) (void)) mthread_fallback, 0);
/* Let another thread run */
mthread_schedule();
}
/*===========================================================================*
* mthread_find_tcb *
*===========================================================================*/
@ -288,15 +244,6 @@ PUBLIC void mthread_init(void)
mthread_init_keys();
mthread_init_scheduler();
/* Initialize the fallback thread */
if (mthread_getcontext(FALLBACK_CTX) == -1)
mthread_panic("Could not initialize fallback thread");
FALLBACK_CTX->uc_link = &(mainthread.m_context);
FALLBACK_CTX->uc_stack.ss_sp = fallback_stack;
FALLBACK_CTX->uc_stack.ss_size = STACKSZ;
memset(fallback_stack, '\0', STACKSZ);
makecontext(FALLBACK_CTX, (void (*) (void)) mthread_fallback, 0);
initialized = 1;
}
}
@ -399,7 +346,7 @@ PUBLIC mthread_thread_t mthread_self(void)
PRIVATE void mthread_thread_init(thread, tattr, proc, arg)
mthread_thread_t thread;
mthread_attr_t *tattr;
void (*proc)(void *);
void *(*proc)(void *);
void *arg;
{
/* Initialize a thread so that it, when unsuspended, will run the given
@ -414,7 +361,7 @@ void *arg;
tcb = mthread_find_tcb(thread);
tcb->m_next = NULL;
tcb->m_state = MS_DEAD;
tcb->m_proc = (void *(*)(void *)) proc; /* Yikes */
tcb->m_proc = proc;
tcb->m_arg = arg;
/* Threads use a copy of the provided attributes. This way, if another
* thread modifies the attributes (such as detach state), already running
@ -429,10 +376,9 @@ void *arg;
if (mthread_cond_init(&(tcb->m_exited), NULL) != 0)
mthread_panic("Could not initialize thread");
/* First set the fallback thread, */
tcb->m_context.uc_link = FALLBACK_CTX;
tcb->m_context.uc_link = NULL;
/* then construct this thread's context to run procedure proc. */
/* Construct this thread's context to run procedure proc. */
if (mthread_getcontext(&(tcb->m_context)) == -1)
mthread_panic("Failed to initialize context state");

4
lib/libmthread/condition.c
View file

@ -2,8 +2,8 @@
#include "global.h"
#include "proto.h"
PRIVATE struct __mthread_cond *vc_front, *vc_rear;
#ifdef MTHREAD_STRICT
PRIVATE struct __mthread_cond *vc_front, *vc_rear;
FORWARD _PROTOTYPE( void mthread_cond_add, (mthread_cond_t *c) );
FORWARD _PROTOTYPE( void mthread_cond_remove, (mthread_cond_t *c) );
FORWARD _PROTOTYPE( int mthread_cond_valid, (mthread_cond_t *c) );
@ -19,8 +19,10 @@ FORWARD _PROTOTYPE( int mthread_cond_valid, (mthread_cond_t *c) );
*===========================================================================*/
PUBLIC void mthread_init_valid_conditions(void)
{
#ifdef MTHREAD_STRICT
/* Initialize condition variable list */
vc_front = vc_rear = NULL;
#endif
}

4
lib/libmthread/global.h
View file

@ -16,7 +16,7 @@
#define MTHREAD_NOT_INUSE 0xdefec7
typedef enum {
MS_CONDITION, MS_DEAD, MS_EXITING, MS_FALLBACK_EXITING, MS_MUTEX, MS_RUNNABLE
MS_CONDITION, MS_DEAD, MS_EXITING, MS_MUTEX, MS_RUNNABLE
} mthread_state_t;
struct __mthread_tcb {
@ -40,10 +40,8 @@ EXTERN mthread_thread_t current_thread;
EXTERN mthread_queue_t free_threads;
EXTERN mthread_queue_t run_queue; /* FIFO of runnable threads */
EXTERN mthread_tcb_t **threads;
EXTERN mthread_tcb_t fallback;
EXTERN mthread_tcb_t mainthread;
EXTERN int no_threads;
EXTERN int used_threads;
EXTERN int running_main_thread;
EXTERN char fallback_stack[STACKSZ];

4
lib/libmthread/key.c
View file

@ -3,6 +3,7 @@
#include "global.h"
#include "proto.h"
PRIVATE int keys_used = 0;
PRIVATE struct {
int used;
int nvalues;
@ -34,6 +35,7 @@ PUBLIC int mthread_key_create(mthread_key_t *key, void (*destructor)(void *))
mthread_key_t k;
mthread_init(); /* Make sure libmthread is initialized */
keys_used = 1;
/* We do not yet allocate storage space for the values here, because we can
* not estimate how many threads will be created in the common case that the
@ -150,6 +152,8 @@ PUBLIC void mthread_cleanup_values(void)
void *value;
int found;
if (!keys_used) return; /* Only clean up if we used any keys at all */
/* Any of the destructors may set a new value on any key, so we may have to
* loop over the table of keys multiple times. This implementation has no
* protection against infinite loops in this case.

32
lib/libmthread/misc.c
View file

@ -6,18 +6,18 @@
/*===========================================================================*
* mthread_debug_f *
*===========================================================================*/
#ifdef MDEBUG
PUBLIC void mthread_debug_f(const char *file, int line, const char *msg)
{
/* Print debug message */
#ifdef MDEBUG
printf("MTH (%s:%d): %s\n", file, line, msg);
#endif
}
#endif
/*===========================================================================*
* mthread_panic_f *
*===========================================================================*/
#ifdef MDEBUG
PUBLIC void mthread_panic_f(const char *file, int line, const char *msg)
{
/* Print panic message to stdout and exit */
@ -32,6 +32,17 @@ PUBLIC void mthread_panic_f(const char *file, int line, const char *msg)
*((int *) sf ) = 1; /* Cause segfault to generate trace */
exit(1);
}
#else
PUBLIC void mthread_panic_s(void)
{
/* Silent panic */
volatile int *sf;
sf = NULL;
*((int *) sf ) = 1; /* Cause segfault to generate trace */
exit(1);
}
#endif
/*===========================================================================*
@ -68,9 +79,6 @@ PUBLIC void mthread_verify_f(char *file, int line)
if(!threads_ok || !conditions_ok || !mutexes_ok)
mthread_panic("Library state corrupt\n");
}
#else
PUBLIC void mthread_verify_f(char *f, int l) { ; }
#endif
/*===========================================================================*
@ -80,8 +88,8 @@ PUBLIC void mthread_stats(void)
{
mthread_thread_t t;
mthread_tcb_t *tcb;
int st_run, st_dead, st_cond, st_mutex, st_exit, st_fbexit;
st_run = st_dead = st_cond = st_mutex = st_exit = st_fbexit = 0;
int st_run, st_dead, st_cond, st_mutex, st_exit;
st_run = st_dead = st_cond = st_mutex = st_exit = 0;
for (t = (mthread_thread_t) 0; t < no_threads; t++) {
tcb = mthread_find_tcb(t);
@ -91,13 +99,13 @@ PUBLIC void mthread_stats(void)
case MS_MUTEX: st_mutex++; break;
case MS_CONDITION: st_cond++; break;
case MS_EXITING: st_exit++; break;
case MS_FALLBACK_EXITING: st_fbexit++; break;
default: mthread_panic("Unknown state");
}
}
printf("Pool: %-5d In use: %-5d R: %-5d D: %-5d M: %-5d C: %-5d E: %-5d"
"F: %-5d\n",
printf("Pool: %-5d In use: %-5d R: %-5d D: %-5d M: %-5d C: %-5d E: %-5d\n",
no_threads, used_threads, st_run, st_dead, st_mutex, st_cond,
st_exit, st_fbexit);
st_exit);
}
#endif

18
lib/libmthread/mutex.c
View file

@ -2,8 +2,8 @@
#include "global.h"
#include "proto.h"
PRIVATE struct __mthread_mutex *vm_front, *vm_rear;
#ifdef MTHREAD_STRICT
PRIVATE struct __mthread_mutex *vm_front, *vm_rear;
FORWARD _PROTOTYPE( void mthread_mutex_add, (mthread_mutex_t *m) );
FORWARD _PROTOTYPE( void mthread_mutex_remove, (mthread_mutex_t *m) );
#else
@ -16,8 +16,10 @@ FORWARD _PROTOTYPE( void mthread_mutex_remove, (mthread_mutex_t *m) );
*===========================================================================*/
PUBLIC void mthread_init_valid_mutexes(void)
{
#ifdef MTHREAD_STRICT
/* Initialize list of valid mutexes */
vm_front = vm_rear = NULL;
#endif
}
@ -135,14 +137,10 @@ mthread_mutex_t *mutex; /* Mutex that is to be locked */
return(EINVAL);
else if (m->mm_owner == NO_THREAD) { /* Not locked */
m->mm_owner = current_thread;
if (current_thread == MAIN_THREAD)
mthread_debug("MAIN_THREAD now mutex owner\n");
} else if (m->mm_owner == current_thread) {
return(EDEADLK);
} else {
mthread_queue_add(&m->mm_queue, current_thread);
if (m->mm_owner == MAIN_THREAD)
mthread_dump_queue(&m->mm_queue);
mthread_suspend(MS_MUTEX);
}
@ -244,10 +242,10 @@ mthread_mutex_t *m;
loopitem = vm_front;
while (loopitem != NULL) {
if (loopitem == *m)
return(1);
if (loopitem == *m)
return(1);
loopitem = loopitem->mm_next;
loopitem = loopitem->mm_next;
}
return(0);
@ -266,13 +264,15 @@ PUBLIC int mthread_mutex_verify(void)
mthread_init(); /* Make sure mthreads is initialized */
#ifdef MTHREAD_STRICT
loopitem = vm_front;
while (loopitem != NULL) {
printf("mutex corruption: owner: %d\n", loopitem->mm_owner);
loopitem = loopitem->next;
loopitem = loopitem->mm_next;
r = 0;
}
#endif
return(r);
}

8
lib/libmthread/proto.h
View file

@ -21,12 +21,18 @@ _PROTOTYPE( void mthread_init_keys, (void) );
_PROTOTYPE( void mthread_cleanup_values, (void) );
/* misc.c */
#ifdef MDEBUG
#define mthread_panic(m) mthread_panic_f(__FILE__, __LINE__, (m))
_PROTOTYPE( void mthread_panic_f, (const char *file, int line,
const char *msg) );
#define mthread_debug(m) mthread_debug_f(__FILE__, __LINE__, (m))
_PROTOTYPE( void mthread_debug_f, (const char *file, int line,
const char *msg) );
#else
_PROTOTYPE( void mthread_panic_s, (void) );
# define mthread_panic(m) mthread_panic_s()
# define mthread_debug(m)
#endif
/* mutex.c */
_PROTOTYPE( void mthread_init_valid_mutexes, (void) );
@ -49,7 +55,9 @@ _PROTOTYPE( void mthread_suspend, (mthread_state_t state) );
_PROTOTYPE( void mthread_unsuspend, (mthread_thread_t thread) );
/* queue.c */
#ifdef MDEBUG
_PROTOTYPE( void mthread_dump_queue, (mthread_queue_t *queue) );
#endif
_PROTOTYPE( void mthread_queue_init, (mthread_queue_t *queue) );
_PROTOTYPE( void mthread_queue_add, (mthread_queue_t *queue,
mthread_thread_t thread) );

14
lib/libmthread/queue.c
View file

@ -54,6 +54,7 @@ mthread_queue_t *queue;
/*===========================================================================*
* mthread_dump_queue *
*===========================================================================*/
#ifdef MDEBUG
PUBLIC void mthread_dump_queue(queue)
mthread_queue_t *queue;
{
@ -61,39 +62,30 @@ mthread_queue_t *queue;
mthread_tcb_t *t;
mthread_thread_t tid;
threshold = no_threads;
#ifdef MDEBUG
printf("Dumping queue: ");
#endif
if(queue->mq_head != NULL) {
t = queue->mq_head;
if (t == &mainthread) tid = MAIN_THREAD;
else tid = t->m_tid;
#ifdef MDEBUG
printf("%d ", tid);
#endif
count++;
t = t->m_next;
while (t != NULL) {
if (t == &mainthread) tid = MAIN_THREAD;
else tid = t->m_tid;
#ifdef MDEBUG
printf("%d ", tid);
#endif
t = t->m_next;
count++;
if (count > threshold) break;
}
} else {
#ifdef MDEBUG
printf("[empty]");
#endif
}
#ifdef MDEBUG
printf("\n");
#endif
}
#endif
/*===========================================================================*
* mthread_queue_remove *

84
test/test59.c
View file

@ -3,6 +3,7 @@
* lets you check the internal integrity of the library. */
#include <stdio.h>
#include <minix/mthread.h>
#include <signal.h>
#define thread_t mthread_thread_t
#define mutex_t mthread_mutex_t
@ -38,16 +39,18 @@ PRIVATE int first;
#define THRESH1 3
#define THRESH2 8
#define MEG 1024*1024
#define MAGIC 0xb4a3f1c2
#define MAGIC ((signed) 0xb4a3f1c2)
FORWARD _PROTOTYPE( void thread_a, (void *arg) );
FORWARD _PROTOTYPE( void thread_b, (void *arg) );
FORWARD _PROTOTYPE( void thread_c, (void *arg) );
FORWARD _PROTOTYPE( void thread_d, (void *arg) );
FORWARD _PROTOTYPE( void destr_a, (void *arg) );
FORWARD _PROTOTYPE( void destr_b, (void *arg) );
FORWARD _PROTOTYPE( void *thread_a, (void *arg) );
FORWARD _PROTOTYPE( void *thread_b, (void *arg) );
FORWARD _PROTOTYPE( void *thread_c, (void *arg) );
FORWARD _PROTOTYPE( void *thread_d, (void *arg) );
FORWARD _PROTOTYPE( void thread_e, (void) );
FORWARD _PROTOTYPE( void thread_f, (void *arg) );
FORWARD _PROTOTYPE( void thread_g, (void *arg) );
FORWARD _PROTOTYPE( void thread_h, (void *arg) );
FORWARD _PROTOTYPE( void *thread_f, (void *arg) );
FORWARD _PROTOTYPE( void *thread_g, (void *arg) );
FORWARD _PROTOTYPE( void *thread_h, (void *arg) );
FORWARD _PROTOTYPE( void test_scheduling, (void) );
FORWARD _PROTOTYPE( void test_mutex, (void) );
FORWARD _PROTOTYPE( void test_condition, (void) );
@ -58,34 +61,38 @@ FORWARD _PROTOTYPE( void err, (int subtest, int error) );
/*===========================================================================*
* thread_a *
*===========================================================================*/
PRIVATE void thread_a(void *arg) {
PRIVATE void *thread_a(void *arg) {
th_a++;
return(NULL);
}
/*===========================================================================*
* thread_b *
*===========================================================================*/
PRIVATE void thread_b(void *arg) {
PRIVATE void *thread_b(void *arg) {
th_b++;
if (mthread_once(&once, thread_e) != 0) err(10, 1);
return(NULL);
}
/*===========================================================================*
* thread_c *
*===========================================================================*/
PRIVATE void thread_c(void *arg) {
PRIVATE void *thread_c(void *arg) {
th_c++;
return(NULL);
}
/*===========================================================================*
* thread_d *
*===========================================================================*/
PRIVATE void thread_d(void *arg) {
PRIVATE void *thread_d(void *arg) {
th_d++;
mthread_exit(NULL); /* Thread wants to stop running */
return(NULL);
}
@ -100,31 +107,33 @@ PRIVATE void thread_e(void) {
/*===========================================================================*
* thread_f *
*===========================================================================*/
PRIVATE void thread_f(void *arg) {
PRIVATE void *thread_f(void *arg) {
if (mthread_mutex_lock(condition_mutex) != 0) err(12, 1);
th_f++;
if (mthread_cond_signal(&condition) != 0) err(12, 2);
if (mthread_mutex_unlock(condition_mutex) != 0) err(12, 3);
return(NULL);
}
/*===========================================================================*
* thread_g *
*===========================================================================*/
PRIVATE void thread_g(void *arg) {
PRIVATE void *thread_g(void *arg) {
char bigarray[MTHREAD_STACK_MIN + 1];
if (mthread_mutex_lock(condition_mutex) != 0) err(13, 1);
memset(bigarray, '\0', MTHREAD_STACK_MIN + 1); /* Actually allocate it */
th_g++;
if (mthread_cond_signal(&condition) != 0) err(13, 2);
if (mthread_mutex_unlock(condition_mutex) != 0) err(13, 3);
return(NULL);
}
/*===========================================================================*
* thread_h *
*===========================================================================*/
PRIVATE void thread_h(void *arg) {
PRIVATE void *thread_h(void *arg) {
char bigarray[2 * MEG];
int reply;
if (mthread_mutex_lock(condition_mutex) != 0) err(14, 1);
@ -134,6 +143,7 @@ PRIVATE void thread_h(void *arg) {
if (mthread_mutex_unlock(condition_mutex) != 0) err(14, 3);
reply = *((int *) arg);
mthread_exit((void *) reply);
return(NULL);
}
@ -154,7 +164,7 @@ PRIVATE void err(int sub, int error) {
*===========================================================================*/
PRIVATE void test_scheduling(void)
{
int i;
unsigned int i;
thread_t t[7];
#ifdef MDEBUG
@ -217,10 +227,9 @@ PRIVATE void test_scheduling(void)
/*===========================================================================*
* mutex_a *
*===========================================================================*/
PRIVATE void mutex_a(void *arg)
PRIVATE void *mutex_a(void *arg)
{
mutex_t *mu = (mutex_t *) arg;
mutex_t mu2;
VERIFY_MUTEX(0, 0, 0, 3, 1);
if (mthread_mutex_lock(&mu[0]) != 0) err(3, 2);
@ -267,13 +276,14 @@ PRIVATE void mutex_a(void *arg)
if (mthread_mutex_unlock(NULL) == 0) err(3, 19);
if (mthread_mutex_unlock(&mu[2]) != 0) err(3, 20);
return(NULL);
}
/*===========================================================================*
* mutex_b *
*===========================================================================*/
PRIVATE void mutex_b(void *arg)
PRIVATE void *mutex_b(void *arg)
{
mutex_t *mu = (mutex_t *) arg;
@ -302,13 +312,14 @@ PRIVATE void mutex_b(void *arg)
if (mthread_mutex_unlock(&mu[1]) != 0) err(4, 8);
mutex_b_step = 4;
return(NULL);
}
/*===========================================================================*
* mutex_c *
*===========================================================================*/
PRIVATE void mutex_c(void *arg)
PRIVATE void *mutex_c(void *arg)
{
mutex_t *mu = (mutex_t *) arg;
@ -329,6 +340,7 @@ PRIVATE void mutex_c(void *arg)
if (mthread_mutex_unlock(&mu[0]) != 0) err(5, 9);
mutex_c_step = 4;
return(NULL);
}
@ -337,7 +349,7 @@ PRIVATE void mutex_c(void *arg)
*===========================================================================*/
PRIVATE void test_mutex(void)
{
int i;
unsigned int i;
thread_t t[3];
#ifdef MDEBUG
mthread_verify();
@ -381,7 +393,7 @@ PRIVATE void test_mutex(void)
/*===========================================================================*
* cond_a *
*===========================================================================*/
PRIVATE void cond_a(void *arg)
PRIVATE void *cond_a(void *arg)
{
cond_t c;
int did_count = 0;
@ -406,6 +418,7 @@ PRIVATE void cond_a(void *arg)
/* Try faulty addresses */
if (mthread_mutex_lock(condition_mutex) != 0) err(6, 7);
#ifdef MTHREAD_STRICT
/* Condition c is not initialized, so whatever we do with it should fail. */
if (mthread_cond_wait(&c, condition_mutex) == 0) err(6, 8);
if (mthread_cond_wait(NULL, condition_mutex) == 0) err(6, 9);
@ -415,19 +428,21 @@ PRIVATE void cond_a(void *arg)
/* Try again with an unlocked mutex */
if (mthread_cond_wait(&c, condition_mutex) == 0) err(6, 12);
if (mthread_cond_signal(&c) == 0) err(6, 13);
#endif
/* And again with an unlocked mutex, but initialized c */
if (mthread_cond_init(&c, NULL) != 0) err(6, 14);
if (mthread_cond_wait(&c, condition_mutex) == 0) err(6, 15);
if (mthread_cond_signal(&c) != 0) err(6, 16);/*c.f., 6.10 this should work!*/
if (mthread_cond_destroy(&c) != 0) err(6, 17);
return(NULL);
}
/*===========================================================================*
* cond_b *
*===========================================================================*/
PRIVATE void cond_b(void *arg)
PRIVATE void *cond_b(void *arg)
{
int did_count = 0;
while(1) {
@ -448,14 +463,14 @@ PRIVATE void cond_b(void *arg)
if (!(did_count >= count - (THRESH2 - THRESH1 + 1))) err(7, 6);
return(NULL);
}
/*===========================================================================*
* cond_broadcast *
*===========================================================================*/
PRIVATE void cond_broadcast(void *arg)
PRIVATE void *cond_broadcast(void *arg)
{
int rounds = 0;
if (mthread_mutex_lock(condition_mutex) != 0) err(9, 1);
while(!condition_met)
@ -466,6 +481,7 @@ PRIVATE void cond_broadcast(void *arg)
if (mthread_mutex_lock(count_mutex) != 0) err(9, 4);
count++;
if (mthread_mutex_unlock(count_mutex) != 0) err(9, 5);
return(NULL);
}
/*===========================================================================*
@ -474,7 +490,7 @@ PRIVATE void cond_broadcast(void *arg)
PRIVATE void test_condition(void)
{
#define NTHREADS 10
int i, r;
int i;
thread_t t[2], s[NTHREADS];
count_mutex = &mu[0];
condition_mutex = &mu[1];
@ -498,7 +514,7 @@ PRIVATE void test_condition(void)
if (mthread_create(&t[0], NULL, cond_a, NULL) != 0) err(8, 4);
if (mthread_create(&t[1], NULL, cond_b, NULL) != 0) err(8, 5);
for (i = 0; i < (sizeof(t) / sizeof(thread_t)); i++)
for (i = 0; i < (sizeof(t) / sizeof(thread_t)); i++)
if (mthread_join(t[i], NULL) != 0) err(8, 6);
if (mthread_mutex_destroy(count_mutex) != 0) err(8, 7);
@ -564,7 +580,7 @@ PRIVATE void test_attributes(void)
attr_t tattr;
thread_t tid;
int detachstate = -1, status = 0;
int i, no_ints, stack_untouched = 1;
unsigned int i, no_ints, stack_untouched = 1;
void *stackaddr, *newstackaddr;
int *stackp;
size_t stacksize, newstacksize;
@ -720,7 +736,7 @@ PRIVATE void test_attributes(void)
#endif
if (mthread_join(tid, (void *) &status) != 0) err(11, 69);
if (status != stacksize) err(11, 70);
if ((size_t) status != stacksize) err(11, 70);
if (mthread_attr_destroy(&tattr) != 0) err(11, 71);
if (mthread_mutex_destroy(condition_mutex) != 0) err(11, 72);
if (mthread_cond_destroy(&condition) != 0) err(11, 73);
@ -759,7 +775,7 @@ PRIVATE void destr_b(void *value)
/*===========================================================================*
* key_a *
*===========================================================================*/
PRIVATE void key_a(void *arg)
PRIVATE void *key_a(void *arg)
{
int i;
@ -785,12 +801,13 @@ PRIVATE void key_a(void *arg)
/* If a key's value is set to NULL, its destructor must not be called. */
if (mthread_setspecific(key[4], NULL) != 0) err(17, 5);
return(NULL);
}
/*===========================================================================*
* key_b *
*===========================================================================*/
PRIVATE void key_b(void *arg)
PRIVATE void *key_b(void *arg)
{
int i;
@ -810,12 +827,13 @@ PRIVATE void key_b(void *arg)
if (mthread_key_delete(key[3]) != 0) err(18, 3);
mthread_exit(NULL);
return(NULL);
}
/*===========================================================================*
* key_c *
*===========================================================================*/
PRIVATE void key_c(void *arg)
PRIVATE void *key_c(void *arg)
{
/* The only thing that this thread should do, is set a value. */
if (mthread_setspecific(key[0], (void *) mthread_self()) != 0) err(19, 1);
@ -824,6 +842,7 @@ PRIVATE void key_c(void *arg)
if (!mthread_equal((thread_t) mthread_getspecific(key[0]), mthread_self()))
err(19, 2);
return(NULL);
}
/*===========================================================================*
@ -919,5 +938,6 @@ int main(void)
test_attributes();
test_keys();
quit();
return(0); /* Not reachable */
}