diff options
Diffstat (limited to 'dec_threads.c')
| -rw-r--r-- | dec_threads.c | 558 |
1 files changed, 558 insertions, 0 deletions
diff --git a/dec_threads.c b/dec_threads.c new file mode 100644 index 00000000..1b323d40 --- /dev/null +++ b/dec_threads.c @@ -0,0 +1,558 @@ +/* dec_threads.c +/* +/* Support for DECthreads in Boehm/Demer/Weiser garbage collector. +/* Depends on a gc.a compiled with -DDEC_PTHREADS, plus local modifications. +/* Final executable must be linked with "-lpthreads -lmach -lc_r". +/* +/* Author: Ian.Piumarta@INRIA.fr +/* +/* Copyright (C) 1996 by INRIA and Ian Piumarta +/* +/* Known problems: +/* +/* - debugging needs to be tidied up +/* +/* - some redundant code should be removed +/* +/* last edited: Wed Nov 13 15:42:21 1996 by piumarta (Ian Piumarta) on xombul +/* +/***************************************************************************/ + +#ifdef DEC_PTHREADS + +/* Turn on debugging output */ +#undef DEBUG + +/* Turn on trace messages for thread creation/deletion */ +#undef TRACE + +/* visual indication of GC: */ +/* * = push stack for GC thread, */ +/* + = push stack for other thread */ +#undef VISUAL_CLUES + +#include <unistd.h> +#include <sys/types.h> +#include <signal.h> +#include <setjmp.h> +#include <pthread.h> +#include <sys/user.h> +#include <sys/table.h> +#include <mach/mach_interface.h> +#include <mach/thread_status.h> + +extern char *GC_malloc_uncollectable(); +extern pthread_mutex_t GC_allocate_ml; +extern int GC_pt_init_ok; + +#define ERR(X) { perror(X); abort(); } + +extern GC_err_printf(); + +#ifdef DEBUG +# define FPRINTF(X) GC_err_printf X +#else +# define FPRINTF(X) +#endif + +#define PRINT_INFO(X,Y,Z) /* or #define PRINT_INFO print_info */ + +#define CHECK_DUPLICATE (2<<0) +#define CHECK_OVERLAP (2<<1) + +#define struct_base(PTR, FLD, TYP) \ + ((TYP*)((char*)(PTR)-(char*)(&(((TYP*)0)->FLD)))) + +typedef struct QUEUE { + struct QUEUE *flink, *blink; +} queue; + +typedef struct GC_PT_THREAD_INFO { + queue q; + /* user thread structure */ + pthread_t thread; + /* start routine and argument */ + pthread_startroutine_t starter; + pthread_addr_t arg; + /* mach port */ + port_t port; + /* stack top */ + void *stack_top; + /* approximate thread status */ + short active; + short exited; + short detached; + /* saved register state */ + struct alpha_thread_state reg_state; +} gc_pt_thread_info; + +#define TID(info) (info->port) + +static queue infos = { &infos, &infos }; + +#define DISABLE_SIGNALS() GC_disable_signals() +#define ENABLE_SIGNALS() GC_enable_signals() + +#define LOCK(ML) \ + if(pthread_mutex_lock(&GC_pt_##ML##_ml)<0) ERR("LOCK(GC_pt_"#ML"_ml)"); + +#define UNLOCK(ML) \ + if(pthread_mutex_unlock(&GC_pt_##ML##_ml)<0) ERR("UNLOCK(GC_pt_"#ML"_ml)"); + +static pthread_mutex_t GC_pt_info_ml; +static pthread_mutex_t GC_pt_init_ml; + +static pthread_key_t info_key; + + +static print_info(gc_pt_thread_info *info, char *msg, long arg) +{ + GC_err_printf("********** INFO structure at %lx size %d for ", + info, sizeof(*info)); + GC_err_printf(msg, arg); + GC_err_printf(":\n"); + /* this is VERY naughty: this structure is supposed to be opaque. */ + GC_err_printf(" thread at %lx = (%lx, %lx)\n", + info->thread, info->thread.field1, info->thread.field2); + GC_err_printf(" startroutine at %lx, arg %lx\n", info->starter, info->arg); + GC_err_printf(" mach port number is %d\n", info->port); + GC_err_printf(" stack_top is %lx\n", info->stack_top); + GC_err_printf(" stack pointer is %lx\n", info->reg_state.r30); + GC_err_printf(" thread is %s", info->active ? "active" : "inactive"); + GC_err_printf(", %s", info->exited ? "exited" : "unexited"); + GC_err_printf(", %s", info->detached ? "detached" : "attached"); + GC_err_printf("\n flink %lx, blink %lx\n", info->q.flink, info->q.blink); +} + + +static print_infos() +{ + queue *ptr= infos.flink; + + GC_err_printf("infos.flink = %lx\n", infos.flink); + print_info(struct_base(ptr, q, gc_pt_thread_info), "flink", 0); + GC_err_printf("infos.blink = %lx\n", infos.flink); + print_info(struct_base(ptr, q, gc_pt_thread_info), "blink", 0); + + while (ptr != &infos) { + GC_err_printf("q ===> %lx:", ptr); + print_info(struct_base(ptr, q, gc_pt_thread_info), "print_infos", 0); + ptr= ptr->flink; + } +} + + +/* GC_pt_check + * + * Check the given gc_pt_thread_info structure is consistent with the others. + * + * Caller must hold the info lock. + */ +static int GC_pt_check(gc_pt_thread_info *info) +{ + queue *ptr= infos.flink; + int fail= 0; + while (ptr != &infos) { + gc_pt_thread_info *old= struct_base(ptr, q, gc_pt_thread_info); +/* + if (info != old && info->port == old->port) { + fail|= CHECK_DUPLICATE; + FPRINTF((stderr, "duplicate thread: %d\n", info->port)); + } +*/ + if (info != old && pthread_equal(info->thread, old->thread)) { + fail|= CHECK_DUPLICATE; + FPRINTF((stderr, "duplicate thread: %d\n", info->port)); + } +/* + if (info != old && + (((char *)info->stack_top > (char *)old->reg_state.r30 && + (char *)info->stack_top < (char *)old->stack_top) || + ((char *)info->reg_state.r30 > (char *)old->reg_state.r30 && + (char *)info->reg_state.r30 < (char *)old->stack_top))) { + fail|= CHECK_OVERLAP; + FPRINTF((stderr, "stack overlaps for threads: %lx and %lx\n", + TID(old), TID(info))); + } +*/ + ptr= ptr->flink; + } + return fail; +} + + +/* This must be called with the info lock set. + */ +static gc_pt_thread_info *GC_pt_find_pthread_info(pthread_t *thread) +{ + queue *ptr= infos.flink; + while (ptr != &infos) { + gc_pt_thread_info *info= struct_base(ptr, q, gc_pt_thread_info); + if (pthread_equal(*thread, info->thread)) + return info; + ptr= ptr->flink; + } + return 0; +} + + +static void GC_pt_info_destroy(pthread_addr_t infop); + + +/* GC_pt_init + * + * Initialises DECthreads-specific data structures. Should be called + * before any threads are created, and before any posibility of GC + * activity. + */ +void GC_pt_init() +{ + gc_pt_thread_info *info; + struct user u; + pthread_mutexattr_t attr; + + if(GC_pt_init_ok) return; + GC_pt_init_ok= 1; + FPRINTF((stderr, "initialising GC_dt...\n")); + FPRINTF((stderr, "ENTER GC_pt_init()\n")); + if (pthread_mutexattr_create(&attr) + || pthread_mutexattr_setkind_np(&attr, MUTEX_RECURSIVE_NP) + || pthread_mutex_init(&GC_pt_info_ml, attr) + || pthread_mutex_init(&GC_pt_init_ml, attr) + || pthread_keycreate(&info_key, GC_pt_info_destroy)) + ERR("GC_pt_init"); + + if (table(TBL_UAREA, getpid(), &u, 1, sizeof(struct user)) < 1) { + GC_err_printf("problem getting u area\n"); + } + + info= (gc_pt_thread_info *)GC_malloc_uncollectable(sizeof(gc_pt_thread_info)); + if (!info) { + GC_err_printf("GC_dt: could not allocate thread_info\n"); + exit(1); + } + + info->port= thread_self(); + info->stack_top= u.u_stack_end; + info->active= 1; + info->exited= 0; + info->detached= 0; + info->q.flink= &infos; + info->q.blink= &infos; + bzero((char *)&info->reg_state, sizeof(info->reg_state)); + + LOCK(info); + infos.flink= infos.blink= &info->q; + UNLOCK(info); + + PRINT_INFO(info, "default thread", 0); + + FPRINTF((stderr, "LEAVE GC_pt_init()\n")); +} + + +static void GC_pt_apply_other_threads(kern_return_t (*func)(port_t)) +{ + port_t me= thread_self(); + + FPRINTF((stderr, "APPLYING for thread %d\n", me)); + + LOCK(info); + { + queue *ptr= infos.flink; + while (ptr != &infos) + { + gc_pt_thread_info *info= struct_base(ptr, q, gc_pt_thread_info); + if (info->port != me && info->active && !info->exited) + { + FPRINTF((stderr, "applying to thread %d:", info->port)); + FPRINTF((stderr, " %s %s %s\n", + info->active ? "active" : "inactive", + info->exited ? "exited" : "unexited", + info->detached ? "detached" : "attached")); + if (func(info->port) != KERN_SUCCESS) + { + UNLOCK(info); + GC_err_printf("GC_pt_apply_other_threads failed:\n"); + print_info(info, "apply failed from thread %d", me); + abort(); + } + } + else + { + FPRINTF((stderr, "NOT applying to thread %d:", info->port)); + FPRINTF((stderr, " %s %s %s\n", + info->active ? "active" : "inactive", + info->exited ? "exited" : "unexited", + info->detached ? "detached" : "attached")); + } + ptr= ptr->flink; + } + } + UNLOCK(info); +} + + +void GC_pt_stop_world() +{ + if (!GC_pt_init_ok) GC_init(); + FPRINTF((stderr, "stopping the world...\n")); + GC_pt_apply_other_threads(thread_suspend); + FPRINTF((stderr, "...stopped!\n")); +} + +void GC_pt_start_world() +{ + FPRINTF((stderr, "starting the world...\n")); + GC_pt_apply_other_threads(thread_resume); + FPRINTF((stderr, "...started!\n")); +} + + +/* GC_pt_push_all_stacks + * + * Pushes all thread stacks, including the default stack. Default stack + * pointer read from /proc, other thread stacks taken from stacks queue. + * Locks the stacks to prevent thread creation/deletion during pushing. + */ +void GC_pt_push_all_stacks() +{ + queue *ptr= infos.flink; + FPRINTF((stderr, "PUSHING THREAD STACKS:\n")); + while (ptr != &infos) + { + gc_pt_thread_info *info= struct_base(ptr, q, gc_pt_thread_info); + if (info->active && !info->exited) + if (info->port == thread_self()) + { +#ifdef VISUAL_CLUES + fputc('*', stderr); +#endif VISUAL_CLUES + FPRINTF((stderr, "[%lx,%lx]\n", &ptr, info->stack_top)); + GC_push_all_stack(&ptr, info->stack_top); + } + else + { + int count= ALPHA_THREAD_STATE_COUNT; + FPRINTF((stderr, "+")); + /* get register state to (a) know sp, and (b) mark registers */ + PRINT_INFO(info, "thread %d PRE-GETSTATE", info->port); + FPRINTF((stderr, " reg_state dumped to %lx, size %d\n", + &(info->reg_state), sizeof(info->reg_state))); + if (thread_get_state(info->port, + ALPHA_THREAD_STATE, + (thread_state_t)&(info->reg_state), + &count) != KERN_SUCCESS) + { + GC_err_printf("problem in thread_get_state"); + exit(1); + } + PRINT_INFO(info, "thread %d POST-GETSTATE", info->port); +#ifdef VISUAL_CLUES + fputc('+', stderr); +#endif VISUAL_CLUES + FPRINTF((stderr, "[%lx,%lx]\n", + info->reg_state.r30, info->stack_top)); + GC_push_all_stack(info->reg_state.r30, info->stack_top); + } + ptr= ptr->flink; + } +} + + +/* GC_pt_thread_init + * + * Creates a gc_pt_thread_info structure describing the calling thread in the + * stacks queue. + */ +static void GC_pt_thread_init(gc_pt_thread_info *info, void *stacktop) +{ + FPRINTF((stderr, "ENTER GC_pt_thread_init(%lx)\n", TID(info))); + { + int status; + info->port= thread_self(); + info->stack_top= stacktop; + PRINT_INFO(info, "thread %d", info->port); + if (status= GC_pt_check(info)) { + if (status & CHECK_DUPLICATE) + GC_err_printf("GC_pt_thread_init: duplicated thread %lx\n", + TID(info)); + if (status & CHECK_OVERLAP) + GC_err_printf("GC_pt_thread_init: stack overlap %lx\n", + TID(info)); + if (status) { + GC_err_printf("GC_pt_thread_init: aborting, sorry...\n"); + abort(); + } + } + } + FPRINTF((stderr, "LEAVE GC_pt_thread_init(%lx)\n", TID(info))); +} + + +/* GC_pt_info_destroy + * + * The thread is finished, and about to exit -- either due to a normal + * return or a cancel request. If it is already detached, remove its + * stack. If not, mark the thread as exited so that its stack will be + * removed when it is eventually detached. + */ +static void GC_pt_info_destroy(pthread_addr_t infop) +{ + gc_pt_thread_info *info= (gc_pt_thread_info *)infop; + + FPRINTF((stderr, "ENTER GC_pt_info_destroy(%lx)\n", infop)); + if (pthread_mutex_lock(&GC_allocate_ml) < 0) + ERR("GC_pt_info_destroy: lock(&GC_allocate_ml)"); + { + /* safety first: check that the info structure really exists */ + queue *target= &info->q; + queue *ptr= infos.flink; + while (ptr != &infos) + { + if (ptr == target) + break; + else + ptr= ptr->flink; + } + if (ptr != target) + { + if (pthread_mutex_unlock(&GC_allocate_ml) < 0) + ERR("GC_pt_info_destroy: unlock(&GC_allocate_ml)"); + GC_err_printf("GC_pt_info_destroy: unknown info -- aborting\n"); + abort(); + } + if (info->detached) + { + /* thread detached => delete stack on exit */ + queue *ptr= &info->q; + ptr->flink->blink= ptr->blink; + ptr->blink->flink= ptr->flink; +#ifdef TRACE + GC_err_printf("DELETE (exit) %lx\n", TID(info)); +#endif TRACE + GC_free(info); + } + else + { + info->exited= 1; /* cancelled thread won't do this otherwise */ + info->active= 0; + } + } + if (pthread_mutex_unlock(&GC_allocate_ml) < 0) + ERR("GC_pt_info_destroy: unlock(&GC_allocate_ml)"); + FPRINTF((stderr, "LEAVE GC_pt_info_destroy(%lx)\n", infop)); +} + + +static pthread_addr_t GC_pt_start_routine(gc_pt_thread_info *info) +{ + pthread_addr_t status; + LOCK(info); + /* wait for GC_pt_pthread_create to finish building info */ + FPRINTF((stderr, "ENTER GC_pt_start_routine(%lx)\n", TID(info))); + GC_pt_thread_init(info, &info); + UNLOCK(info); /* it is now safe to start the next thread */ + pthread_setspecific(info_key, info); /* the reaper for the thread */ + /* this thread might be starting up during a GC! Do not proceed beyond + this point until the allocation lock becomes available. */ + pthread_mutex_lock(&GC_allocate_ml); + info->active= 1; + pthread_mutex_unlock(&GC_allocate_ml); +#ifdef TRACE + GC_err_printf("LAUNCH (start) %lx\n", TID(info)); +#endif TRACE + status= info->starter(info->arg); + info->active= 0; + info->exited= 1; + FPRINTF((stderr, "LEAVE GC_pt_start_routine(%lx)\n", TID(info))); + return status; +} + +/* GC_pt_pthread_create + * + * Creates a new thread, allocates a gc_pt_thread_info object describing the + * new thread, + * + * Get stack information by intercepting thread creation. + */ +int GC_pt_pthread_create(pthread_t *thread, pthread_attr_t attr, + pthread_startroutine_t start_routine, + pthread_addr_t arg) +{ + int result; + gc_pt_thread_info *info; + + FPRINTF((stderr, "ENTER GC_pt_pthread_create(%lx)\n", thread)); + info= (void *)GC_malloc_uncollectable(sizeof(gc_pt_thread_info)); + info->starter= start_routine; + info->arg= arg; + info->active= 0; + info->detached= 0; + info->exited= 0; + LOCK(info); + if (result= pthread_create(thread, attr, + (pthread_startroutine_t)GC_pt_start_routine, + (pthread_addr_t)info)) { + GC_free(info); + FPRINTF((stderr, "LEAVE GC_pt_pthread_create(%lx) ===> ERROR\n", thread)); + goto end; /* something is amiss */ + } + info->thread= *thread; + PRINT_INFO(info, "uninitialized new thread", 0); + /* add to end of info queue */ + { + queue *ptr= &info->q; + ptr->flink= &infos; + ptr->blink= infos.blink; + infos.blink->flink= ptr; + infos.blink= ptr; + } + FPRINTF((stderr, "LEAVE GC_pt_pthread_create(%lx) ===> %lx\n", + thread, TID(info))); + end: + UNLOCK(info); + return result; +} + + +/* GC_pt_pthread_detach + * + * If thread already exited, remove its stack. Otherwise mark the thread + * as detached, so that its stack will be removed when it eventually exits. + */ +int GC_pt_pthread_detach(pthread_t *thread) +{ + int result; + FPRINTF((stderr, "ENTER GC_pt_pthread_detach(%lx)\n", thread)); + LOCK(info); + { + gc_pt_thread_info *info= GC_pt_find_pthread_info(thread); + if (!info) + { + UNLOCK(info); + errno= ESRCH; + return -1; + } + if (info->exited) + { + /* thread exited => delete stack on detach */ + queue *ptr= &info->q; + ptr->flink->blink= ptr->blink; + ptr->blink->flink= ptr->flink; + FPRINTF((stderr, "DELETE (detach) %lx\n", TID(info))); + GC_free(info); + } + else + { + info->detached= 1; + } + } + UNLOCK(info); + result= pthread_detach(thread); + FPRINTF((stderr, "LEAVE GC_pt_pthread_detach(%lx)\n", thread)); + return result; +} + + +#endif DEC_PTHREADS |