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     ! 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: