Return to solaris_pthreads.c CVS log

Up to [local] / OpenXM_contrib / gc

Annotation of OpenXM_contrib/gc/solaris_pthreads.c, Revision 1.1.1.1

1.1       maekawa     1: /*
                      2:  * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
                      3:  *
                      4:  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
                      5:  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
                      6:  *
                      7:  * Permission is hereby granted to use or copy this program
                      8:  * for any purpose,  provided the above notices are retained on all copies.
                      9:  * Permission to modify the code and to distribute modified code is granted,
                     10:  * provided the above notices are retained, and a notice that the code was
                     11:  * modified is included with the above copyright notice.
                     12:  */
                     13: /*
                     14:  * Support code for Solaris threads.  Provides functionality we wish Sun
                     15:  * had provided.  Relies on some information we probably shouldn't rely on.
                     16:  * Modified Peter C. for Solaris Posix Threads.
                     17:  */
                     18: /* Boehm, September 14, 1994 4:44 pm PDT */
                     19: /* $Id: solaris_pthreads.c,v 1.10 1997/05/13 23:09:09 peterc Exp $ */
                     20:
                     21: # if defined(_SOLARIS_PTHREADS)
                     22: # include "gc_priv.h"
                     23: # include <pthread.h>
                     24: # include <thread.h>
                     25: # include <signal.h>
                     26: # include <fcntl.h>
                     27: # include <sys/types.h>
                     28: # include <sys/mman.h>
                     29: # include <sys/time.h>
                     30: # include <sys/resource.h>
                     31: # include <sys/stat.h>
                     32: # include <sys/syscall.h>
                     33: # include <sys/procfs.h>
                     34: # include <sys/lwp.h>
                     35: # include <sys/reg.h>
                     36: # define _CLASSIC_XOPEN_TYPES
                     37: # include <unistd.h>
                     38: # include <errno.h>
                     39: # include "solaris_threads.h"
                     40: # include <stdio.h>
                     41:
                     42: #undef pthread_join
                     43: #undef pthread_create
                     44:
                     45: pthread_cond_t GC_prom_join_cv;                /* Broadcast when any thread terminates */
                     46: pthread_cond_t GC_create_cv;           /* Signalled when a new undetached      */
                     47:                                /* thread starts.                       */
                     48:
                     49: extern GC_bool GC_multithreaded;
                     50:
                     51: /* We use the allocation lock to protect thread-related data structures. */
                     52:
                     53: /* We stop the world using /proc primitives.  This makes some  */
                     54: /* minimal assumptions about the threads implementation.       */
                     55: /* We don't play by the rules, since the rules make this       */
                     56: /* impossible (as of Solaris 2.3).  Also note that as of       */
                     57: /* Solaris 2.3 the various thread and lwp suspension           */
                     58: /* primitives failed to stop threads by the time the request   */
                     59: /* is completed.                                               */
                     60:
                     61:
                     62:
                     63: int GC_pthread_join(pthread_t wait_for, void **status)
                     64: {
                     65:        return GC_thr_join((thread_t)wait_for, NULL, status);
                     66: }
                     67:
                     68:
                     69: int
                     70: GC_pthread_create(pthread_t *new_thread,
                     71:           const pthread_attr_t *attr_in,
                     72:           void * (*thread_execp)(void *), void *arg)
                     73: {
                     74:     int result;
                     75:     GC_thread t;
                     76:     pthread_t my_new_thread;
                     77:     pthread_attr_t  attr;
                     78:     word my_flags = 0;
                     79:     int  flag;
                     80:     void * stack;
                     81:     size_t stack_size;
                     82:     int    n;
                     83:     struct sched_param schedparam;
                     84:
                     85:     (void)pthread_attr_getstacksize(attr_in, &stack_size);
                     86:     (void)pthread_attr_getstackaddr(attr_in, &stack);
                     87:     (void)pthread_attr_init(&attr);
                     88:
                     89:     LOCK();
                     90:     if (!GC_thr_initialized) {
                     91:            GC_thr_init();
                     92:     }
                     93:     GC_multithreaded++;
                     94:
                     95:     if (stack == 0) {
                     96:        if (stack_size == 0)
                     97:                stack_size = GC_min_stack_sz;
                     98:        else
                     99:                stack_size += thr_min_stack();
                    100:
                    101:        stack = (void *)GC_stack_alloc(&stack_size);
                    102:        if (stack == 0) {
                    103:            GC_multithreaded--;
                    104:            UNLOCK();
                    105:            errno = ENOMEM;
                    106:            return -1;
                    107:        }
                    108:     } else {
                    109:        my_flags |= CLIENT_OWNS_STACK;
                    110:     }
                    111:     (void)pthread_attr_setstacksize(&attr, stack_size);
                    112:     (void)pthread_attr_setstackaddr(&attr, stack);
                    113:     (void)pthread_attr_getscope(attr_in, &n);
                    114:     (void)pthread_attr_setscope(&attr, n);
                    115:     (void)pthread_attr_getschedparam(attr_in, &schedparam);
                    116:     (void)pthread_attr_setschedparam(&attr, &schedparam);
                    117:     (void)pthread_attr_getschedpolicy(attr_in, &n);
                    118:     (void)pthread_attr_setschedpolicy(&attr, n);
                    119:     (void)pthread_attr_getinheritsched(attr_in, &n);
                    120:     (void)pthread_attr_setinheritsched(&attr, n);
                    121:
                    122:     (void)pthread_attr_getdetachstate(attr_in, &flag);
                    123:     if (flag == PTHREAD_CREATE_DETACHED) {
                    124:            my_flags |= DETACHED;
                    125:     }
                    126:     (void)pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
                    127:     /*
                    128:      * thr_create can call malloc(), which if redirected will
                    129:      * attempt to acquire the allocation lock.
                    130:      * Unlock here to prevent deadlock.
                    131:      */
                    132:
                    133:
                    134: #if 0
                    135: #ifdef I386
                    136:     UNLOCK();
                    137: #endif
                    138: #endif
                    139:     result =
                    140:            pthread_create(&my_new_thread, &attr, thread_execp, arg);
                    141: #if 0
                    142: #ifdef I386
                    143:     LOCK();
                    144: #endif
                    145: #endif
                    146:     if (result == 0) {
                    147:         t = GC_new_thread(my_new_thread);
                    148:         t -> flags = my_flags;
                    149:         if (!(my_flags & DETACHED)) cond_init(&(t->join_cv), USYNC_THREAD, 0);
                    150:         t -> stack = stack;
                    151:         t -> stack_size = stack_size;
                    152:         if (new_thread != 0) *new_thread = my_new_thread;
                    153:         pthread_cond_signal(&GC_create_cv);
                    154:     } else {
                    155:            if (!(my_flags & CLIENT_OWNS_STACK)) {
                    156:                    GC_stack_free(stack, stack_size);
                    157:            }
                    158:            GC_multithreaded--;
                    159:     }
                    160:     UNLOCK();
                    161:     pthread_attr_destroy(&attr);
                    162:     return(result);
                    163: }
                    164:
                    165: # else
                    166:
                    167: #ifndef LINT
                    168:   int GC_no_sunOS_pthreads;
                    169: #endif
                    170:
                    171: # endif /* SOLARIS_THREADS */
                    172: