1 

     2 /* Posix threads interface */

     3 

     4 #include <stdlib.h>

     5 #include <string.h>

     6 #if defined(__APPLE__) || defined(HAVE_PTHREAD_DESTRUCTOR)

     7 #define destructor xxdestructor

     8 #endif

     9 #include <pthread.h>

    10 #if defined(__APPLE__) || defined(HAVE_PTHREAD_DESTRUCTOR)

    11 #undef destructor

    12 #endif

    13 #include <signal.h>

    14 

    15 /* The POSIX spec requires that use of pthread_attr_setstacksize

    16    be conditional on _POSIX_THREAD_ATTR_STACKSIZE being defined. */

    17 #ifdef _POSIX_THREAD_ATTR_STACKSIZE

    18 #ifndef THREAD_STACK_SIZE

    19 #define	THREAD_STACK_SIZE	0	/* use default stack size */

    20 #endif

    21 /* for safety, ensure a viable minimum stacksize */

    22 #define	THREAD_STACK_MIN	0x8000	/* 32kB */

    23 #else  /* !_POSIX_THREAD_ATTR_STACKSIZE */

    24 #ifdef THREAD_STACK_SIZE

    25 #error "THREAD_STACK_SIZE defined but _POSIX_THREAD_ATTR_STACKSIZE undefined"

    26 #endif

    27 #endif

    28 

    29 /* The POSIX spec says that implementations supporting the sem_*

    30    family of functions must indicate this by defining

    31    _POSIX_SEMAPHORES. */   

    32 #ifdef _POSIX_SEMAPHORES

    33 /* On FreeBSD 4.x, _POSIX_SEMAPHORES is defined empty, so 

    34    we need to add 0 to make it work there as well. */

    35 #if (_POSIX_SEMAPHORES+0) == -1

    36 #define HAVE_BROKEN_POSIX_SEMAPHORES

    37 #else

    38 #include <semaphore.h>

    39 #include <errno.h>

    40 #endif

    41 #endif

    42 

    43 /* Before FreeBSD 5.4, system scope threads was very limited resource

    44    in default setting.  So the process scope is preferred to get

    45    enough number of threads to work. */

    46 #ifdef __FreeBSD__

    47 #include <osreldate.h>

    48 #if __FreeBSD_version >= 500000 && __FreeBSD_version < 504101

    49 #undef PTHREAD_SYSTEM_SCHED_SUPPORTED

    50 #endif

    51 #endif

    52 

    53 #if !defined(pthread_attr_default)

    54 #  define pthread_attr_default ((pthread_attr_t *)NULL)

    55 #endif

    56 #if !defined(pthread_mutexattr_default)

    57 #  define pthread_mutexattr_default ((pthread_mutexattr_t *)NULL)

    58 #endif

    59 #if !defined(pthread_condattr_default)

    60 #  define pthread_condattr_default ((pthread_condattr_t *)NULL)

    61 #endif

    62 

    63 

    64 /* Whether or not to use semaphores directly rather than emulating them with

    65  * mutexes and condition variables:

    66  */

    67 #if defined(_POSIX_SEMAPHORES) && !defined(HAVE_BROKEN_POSIX_SEMAPHORES)

    68 #  define USE_SEMAPHORES

    69 #else

    70 #  undef USE_SEMAPHORES

    71 #endif

    72 

    73 

    74 /* On platforms that don't use standard POSIX threads pthread_sigmask()

    75  * isn't present.  DEC threads uses sigprocmask() instead as do most

    76  * other UNIX International compliant systems that don't have the full

    77  * pthread implementation.

    78  */

    79 #if defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK)

    80 #  define SET_THREAD_SIGMASK pthread_sigmask

    81 #else

    82 #  define SET_THREAD_SIGMASK sigprocmask

    83 #endif

    84 

    85 

    86 /* A pthread mutex isn't sufficient to model the Python lock type

    87  * because, according to Draft 5 of the docs (P1003.4a/D5), both of the

    88  * following are undefined:

    89  *  -> a thread tries to lock a mutex it already has locked

    90  *  -> a thread tries to unlock a mutex locked by a different thread

    91  * pthread mutexes are designed for serializing threads over short pieces

    92  * of code anyway, so wouldn't be an appropriate implementation of

    93  * Python's locks regardless.

    94  *

    95  * The pthread_lock struct implements a Python lock as a "locked?" bit

    96  * and a <condition, mutex> pair.  In general, if the bit can be acquired

    97  * instantly, it is, else the pair is used to block the thread until the

    98  * bit is cleared.     9 May 1994 tim@ksr.com

    99  */

   100 

   101 typedef struct {

   102 	char             locked; /* 0=unlocked, 1=locked */

   103 	/* a <cond, mutex> pair to handle an acquire of a locked lock */

   104 	pthread_cond_t   lock_released;

   105 	pthread_mutex_t  mut;

   106 } pthread_lock;

   107 

   108 #define CHECK_STATUS(name)  if (status != 0) { perror(name); error = 1; }

   109 

   110 /*

   111  * Initialization.

   112  */

   113 

   114 #ifdef _HAVE_BSDI

   115 static

   116 void _noop(void)

   117 {

   118 }

   119 

   120 static void

   121 PyThread__init_thread(void)

   122 {

   123 	/* DO AN INIT BY STARTING THE THREAD */

   124 	static int dummy = 0;

   125 	pthread_t thread1;

   126 	pthread_create(&thread1, NULL, (void *) _noop, &dummy);

   127 	pthread_join(thread1, NULL);

   128 }

   129 

   130 #else /* !_HAVE_BSDI */

   131 

   132 static void

   133 PyThread__init_thread(void)

   134 {

   135 #if defined(_AIX) && defined(__GNUC__)

   136 	pthread_init();

   137 #endif

   138 }

   139 

   140 #endif /* !_HAVE_BSDI */

   141 

   142 /*

   143  * Thread support.

   144  */

   145 

   146 

   147 long

   148 PyThread_start_new_thread(void (*func)(void *), void *arg)

   149 {

   150 	pthread_t th;

   151 	int status;

   152 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

   153 	pthread_attr_t attrs;

   154 #endif

   155 #if defined(THREAD_STACK_SIZE)

   156 	size_t	tss;

   157 #endif

   158 

   159 	dprintf(("PyThread_start_new_thread called\n"));

   160 	if (!initialized)

   161 		PyThread_init_thread();

   162 

   163 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

   164 	if (pthread_attr_init(&attrs) != 0)

   165 		return -1;

   166 #endif

   167 #if defined(THREAD_STACK_SIZE)

   168 	tss = (_pythread_stacksize != 0) ? _pythread_stacksize

   169 					 : THREAD_STACK_SIZE;

   170 	if (tss != 0) {

   171 		if (pthread_attr_setstacksize(&attrs, tss) != 0) {

   172 			pthread_attr_destroy(&attrs);

   173 			return -1;

   174 		}

   175 	}

   176 #endif

   177 #if defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

   178         pthread_attr_setscope(&attrs, PTHREAD_SCOPE_SYSTEM);

   179 #endif

   180 

   181 	status = pthread_create(&th, 

   182 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

   183 				 &attrs,

   184 #else

   185 				 (pthread_attr_t*)NULL,

   186 #endif

   187 				 (void* (*)(void *))func,

   188 				 (void *)arg

   189 				 );

   190 

   191 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

   192 	pthread_attr_destroy(&attrs);

   193 #endif

   194 	if (status != 0)

   195             return -1;

   196 

   197         pthread_detach(th);

   198 

   199 #if SIZEOF_PTHREAD_T <= SIZEOF_LONG

   200 	return (long) th;

   201 #else

   202 	return (long) *(long *) &th;

   203 #endif

   204 }

   205 

   206 /* XXX This implementation is considered (to quote Tim Peters) "inherently

   207    hosed" because:

   208      - It does not guarantee the promise that a non-zero integer is returned.

   209      - The cast to long is inherently unsafe.

   210      - It is not clear that the 'volatile' (for AIX?) and ugly casting in the

   211        latter return statement (for Alpha OSF/1) are any longer necessary.

   212 */

   213 long 

   214 PyThread_get_thread_ident(void)

   215 {

   216 	volatile pthread_t threadid;

   217 	if (!initialized)

   218 		PyThread_init_thread();

   219 	/* Jump through some hoops for Alpha OSF/1 */

   220 	threadid = pthread_self();

   221 #if SIZEOF_PTHREAD_T <= SIZEOF_LONG

   222 	return (long) threadid;

   223 #else

   224 	return (long) *(long *) &threadid;

   225 #endif

   226 }

   227 

   228 static void 

   229 do_PyThread_exit_thread(int no_cleanup)

   230 {

   231 	dprintf(("PyThread_exit_thread called\n"));

   232 	if (!initialized) {

   233 		if (no_cleanup)

   234 			_exit(0);

   235 		else

   236 			exit(0);

   237 	}

   238 }

   239 

   240 void 

   241 PyThread_exit_thread(void)

   242 {

   243 	do_PyThread_exit_thread(0);

   244 }

   245 

   246 void 

   247 PyThread__exit_thread(void)

   248 {

   249 	do_PyThread_exit_thread(1);

   250 }

   251 

   252 #ifndef NO_EXIT_PROG

   253 static void 

   254 do_PyThread_exit_prog(int status, int no_cleanup)

   255 {

   256 	dprintf(("PyThread_exit_prog(%d) called\n", status));

   257 	if (!initialized)

   258 		if (no_cleanup)

   259 			_exit(status);

   260 		else

   261 			exit(status);

   262 }

   263 

   264 void 

   265 PyThread_exit_prog(int status)

   266 {

   267 	do_PyThread_exit_prog(status, 0);

   268 }

   269 

   270 void 

   271 PyThread__exit_prog(int status)

   272 {

   273 	do_PyThread_exit_prog(status, 1);

   274 }

   275 #endif /* NO_EXIT_PROG */

   276 

   277 #ifdef USE_SEMAPHORES

   278 

   279 /*

   280  * Lock support.

   281  */

   282 

   283 PyThread_type_lock 

   284 PyThread_allocate_lock(void)

   285 {

   286 	sem_t *lock;

   287 	int status, error = 0;

   288 

   289 	dprintf(("PyThread_allocate_lock called\n"));

   290 	if (!initialized)

   291 		PyThread_init_thread();

   292 

   293 	lock = (sem_t *)malloc(sizeof(sem_t));

   294 

   295 	if (lock) {

   296 		status = sem_init(lock,0,1);

   297 		CHECK_STATUS("sem_init");

   298 

   299 		if (error) {

   300 			free((void *)lock);

   301 			lock = NULL;

   302 		}

   303 	}

   304 

   305 	dprintf(("PyThread_allocate_lock() -> %p\n", lock));

   306 	return (PyThread_type_lock)lock;

   307 }

   308 

   309 void 

   310 PyThread_free_lock(PyThread_type_lock lock)

   311 {

   312 	sem_t *thelock = (sem_t *)lock;

   313 	int status, error = 0;

   314 

   315 	dprintf(("PyThread_free_lock(%p) called\n", lock));

   316 

   317 	if (!thelock)

   318 		return;

   319 

   320 	status = sem_destroy(thelock);

   321 	CHECK_STATUS("sem_destroy");

   322 

   323 	free((void *)thelock);

   324 }

   325 

   326 /*

   327  * As of February 2002, Cygwin thread implementations mistakenly report error

   328  * codes in the return value of the sem_ calls (like the pthread_ functions).

   329  * Correct implementations return -1 and put the code in errno. This supports

   330  * either.

   331  */

   332 static int

   333 fix_status(int status)

   334 {

   335 	return (status == -1) ? errno : status;

   336 }

   337 

   338 int 

   339 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)

   340 {

   341 	int success;

   342 	sem_t *thelock = (sem_t *)lock;

   343 	int status, error = 0;

   344 

   345 	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));

   346 

   347 	do {

   348 		if (waitflag)

   349 			status = fix_status(sem_wait(thelock));

   350 		else

   351 			status = fix_status(sem_trywait(thelock));

   352 	} while (status == EINTR); /* Retry if interrupted by a signal */

   353 

   354 	if (waitflag) {

   355 		CHECK_STATUS("sem_wait");

   356 	} else if (status != EAGAIN) {

   357 		CHECK_STATUS("sem_trywait");

   358 	}

   359 	

   360 	success = (status == 0) ? 1 : 0;

   361 

   362 	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));

   363 	return success;

   364 }

   365 

   366 void 

   367 PyThread_release_lock(PyThread_type_lock lock)

   368 {

   369 	sem_t *thelock = (sem_t *)lock;

   370 	int status, error = 0;

   371 

   372 	dprintf(("PyThread_release_lock(%p) called\n", lock));

   373 

   374 	status = sem_post(thelock);

   375 	CHECK_STATUS("sem_post");

   376 }

   377 

   378 #else /* USE_SEMAPHORES */

   379 

   380 /*

   381  * Lock support.

   382  */

   383 PyThread_type_lock 

   384 PyThread_allocate_lock(void)

   385 {

   386 	pthread_lock *lock;

   387 	int status, error = 0;

   388 

   389 	dprintf(("PyThread_allocate_lock called\n"));

   390 	if (!initialized)

   391 		PyThread_init_thread();

   392 

   393 	lock = (pthread_lock *) malloc(sizeof(pthread_lock));

   394 	if (lock) {

   395 		memset((void *)lock, '\0', sizeof(pthread_lock));

   396 		lock->locked = 0;

   397 

   398 		status = pthread_mutex_init(&lock->mut,

   399 					    pthread_mutexattr_default);

   400 		CHECK_STATUS("pthread_mutex_init");

   401 

   402 		status = pthread_cond_init(&lock->lock_released,

   403 					   pthread_condattr_default);

   404 		CHECK_STATUS("pthread_cond_init");

   405 

   406 		if (error) {

   407 			free((void *)lock);

   408 			lock = 0;

   409 		}

   410 	}

   411 

   412 	dprintf(("PyThread_allocate_lock() -> %p\n", lock));

   413 	return (PyThread_type_lock) lock;

   414 }

   415 

   416 void 

   417 PyThread_free_lock(PyThread_type_lock lock)

   418 {

   419 	pthread_lock *thelock = (pthread_lock *)lock;

   420 	int status, error = 0;

   421 

   422 	dprintf(("PyThread_free_lock(%p) called\n", lock));

   423 

   424 	status = pthread_mutex_destroy( &thelock->mut );

   425 	CHECK_STATUS("pthread_mutex_destroy");

   426 

   427 	status = pthread_cond_destroy( &thelock->lock_released );

   428 	CHECK_STATUS("pthread_cond_destroy");

   429 

   430 	free((void *)thelock);

   431 }

   432 

   433 int 

   434 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)

   435 {

   436 	int success;

   437 	pthread_lock *thelock = (pthread_lock *)lock;

   438 	int status, error = 0;

   439 

   440 	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));

   441 

   442 	status = pthread_mutex_lock( &thelock->mut );

   443 	CHECK_STATUS("pthread_mutex_lock[1]");

   444 	success = thelock->locked == 0;

   445 

   446 	if ( !success && waitflag ) {

   447 		/* continue trying until we get the lock */

   448 

   449 		/* mut must be locked by me -- part of the condition

   450 		 * protocol */

   451 		while ( thelock->locked ) {

   452 			status = pthread_cond_wait(&thelock->lock_released,

   453 						   &thelock->mut);

   454 			CHECK_STATUS("pthread_cond_wait");

   455 		}

   456 		success = 1;

   457 	}

   458 	if (success) thelock->locked = 1;

   459 	status = pthread_mutex_unlock( &thelock->mut );

   460 	CHECK_STATUS("pthread_mutex_unlock[1]");

   461 

   462 	if (error) success = 0;

   463 	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));

   464 	return success;

   465 }

   466 

   467 void 

   468 PyThread_release_lock(PyThread_type_lock lock)

   469 {

   470 	pthread_lock *thelock = (pthread_lock *)lock;

   471 	int status, error = 0;

   472 

   473 	dprintf(("PyThread_release_lock(%p) called\n", lock));

   474 

   475 	status = pthread_mutex_lock( &thelock->mut );

   476 	CHECK_STATUS("pthread_mutex_lock[3]");

   477 

   478 	thelock->locked = 0;

   479 

   480 	status = pthread_mutex_unlock( &thelock->mut );

   481 	CHECK_STATUS("pthread_mutex_unlock[3]");

   482 

   483 	/* wake up someone (anyone, if any) waiting on the lock */

   484 	status = pthread_cond_signal( &thelock->lock_released );

   485 	CHECK_STATUS("pthread_cond_signal");

   486 }

   487 

   488 #endif /* USE_SEMAPHORES */

   489 

   490 /* set the thread stack size.

   491  * Return 0 if size is valid, -1 if size is invalid,

   492  * -2 if setting stack size is not supported.

   493  */

   494 static int

   495 _pythread_pthread_set_stacksize(size_t size)

   496 {

   497 #if defined(THREAD_STACK_SIZE)

   498 	pthread_attr_t attrs;

   499 	size_t tss_min;

   500 	int rc = 0;

   501 #endif

   502 

   503 	/* set to default */

   504 	if (size == 0) {

   505 		_pythread_stacksize = 0;

   506 		return 0;

   507 	}

   508 

   509 #if defined(THREAD_STACK_SIZE)

   510 #if defined(PTHREAD_STACK_MIN)

   511 	tss_min = PTHREAD_STACK_MIN > THREAD_STACK_MIN ? PTHREAD_STACK_MIN

   512 						       : THREAD_STACK_MIN;

   513 #else

   514 	tss_min = THREAD_STACK_MIN;

   515 #endif

   516 	if (size >= tss_min) {

   517 		/* validate stack size by setting thread attribute */

   518 		if (pthread_attr_init(&attrs) == 0) {

   519 			rc = pthread_attr_setstacksize(&attrs, size);

   520 			pthread_attr_destroy(&attrs);

   521 			if (rc == 0) {

   522 				_pythread_stacksize = size;

   523 				return 0;

   524 			}

   525 		}

   526 	}

   527 	return -1;

   528 #else

   529 	return -2;

   530 #endif

   531 }

   532 

   533 #define THREAD_SET_STACKSIZE(x)	_pythread_pthread_set_stacksize(x)