1 

     2 /* This code implemented by Dag.Gruneau@elsa.preseco.comm.se */

     3 /* Fast NonRecursiveMutex support by Yakov Markovitch, markovitch@iso.ru */

     4 /* Eliminated some memory leaks, gsw@agere.com */

     5 

     6 #include <windows.h>

     7 #include <limits.h>

     8 #ifdef HAVE_PROCESS_H

     9 #include <process.h>

    10 #endif

    11 

    12 typedef struct NRMUTEX {

    13 	LONG   owned ;

    14 	DWORD  thread_id ;

    15 	HANDLE hevent ;

    16 } NRMUTEX, *PNRMUTEX ;

    17 

    18 

    19 BOOL

    20 InitializeNonRecursiveMutex(PNRMUTEX mutex)

    21 {

    22 	mutex->owned = -1 ;  /* No threads have entered NonRecursiveMutex */

    23 	mutex->thread_id = 0 ;

    24 	mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;

    25 	return mutex->hevent != NULL ;	/* TRUE if the mutex is created */

    26 }

    27 

    28 VOID

    29 DeleteNonRecursiveMutex(PNRMUTEX mutex)

    30 {

    31 	/* No in-use check */

    32 	CloseHandle(mutex->hevent) ;

    33 	mutex->hevent = NULL ; /* Just in case */

    34 }

    35 

    36 DWORD

    37 EnterNonRecursiveMutex(PNRMUTEX mutex, BOOL wait)

    38 {

    39 	/* Assume that the thread waits successfully */

    40 	DWORD ret ;

    41 

    42 	/* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */

    43 	if (!wait)

    44 	{

    45 		if (InterlockedCompareExchange(&mutex->owned, 0, -1) != -1)

    46 			return WAIT_TIMEOUT ;

    47 		ret = WAIT_OBJECT_0 ;

    48 	}

    49 	else

    50 		ret = InterlockedIncrement(&mutex->owned) ?

    51 			/* Some thread owns the mutex, let's wait... */

    52 			WaitForSingleObject(mutex->hevent, INFINITE) : WAIT_OBJECT_0 ;

    53 

    54 	mutex->thread_id = GetCurrentThreadId() ; /* We own it */

    55 	return ret ;

    56 }

    57 

    58 BOOL

    59 LeaveNonRecursiveMutex(PNRMUTEX mutex)

    60 {

    61 	/* We don't own the mutex */

    62 	mutex->thread_id = 0 ;

    63 	return

    64 		InterlockedDecrement(&mutex->owned) < 0 ||

    65 		SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */

    66 }

    67 

    68 PNRMUTEX

    69 AllocNonRecursiveMutex(void)

    70 {

    71 	PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;

    72 	if (mutex && !InitializeNonRecursiveMutex(mutex))

    73 	{

    74 		free(mutex) ;

    75 		mutex = NULL ;

    76 	}

    77 	return mutex ;

    78 }

    79 

    80 void

    81 FreeNonRecursiveMutex(PNRMUTEX mutex)

    82 {

    83 	if (mutex)

    84 	{

    85 		DeleteNonRecursiveMutex(mutex) ;

    86 		free(mutex) ;

    87 	}

    88 }

    89 

    90 long PyThread_get_thread_ident(void);

    91 

    92 /*

    93  * Initialization of the C package, should not be needed.

    94  */

    95 static void

    96 PyThread__init_thread(void)

    97 {

    98 }

    99 

   100 /*

   101  * Thread support.

   102  */

   103 

   104 typedef struct {

   105 	void (*func)(void*);

   106 	void *arg;

   107 	long id;

   108 	HANDLE done;

   109 } callobj;

   110 

   111 static int

   112 bootstrap(void *call)

   113 {

   114 	callobj *obj = (callobj*)call;

   115 	/* copy callobj since other thread might free it before we're done */

   116 	void (*func)(void*) = obj->func;

   117 	void *arg = obj->arg;

   118 

   119 	obj->id = PyThread_get_thread_ident();

   120 	ReleaseSemaphore(obj->done, 1, NULL);

   121 	func(arg);

   122 	return 0;

   123 }

   124 

   125 long

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

   127 {

   128 	Py_uintptr_t rv;

   129 	callobj obj;

   130 

   131 	dprintf(("%ld: PyThread_start_new_thread called\n",

   132 		 PyThread_get_thread_ident()));

   133 	if (!initialized)

   134 		PyThread_init_thread();

   135 

   136 	obj.id = -1;	/* guilty until proved innocent */

   137 	obj.func = func;

   138 	obj.arg = arg;

   139 	obj.done = CreateSemaphore(NULL, 0, 1, NULL);

   140 	if (obj.done == NULL)

   141 		return -1;

   142 

   143 	rv = _beginthread(bootstrap,

   144 			  Py_SAFE_DOWNCAST(_pythread_stacksize,

   145 					   Py_ssize_t, int),

   146 			  &obj);

   147 	if (rv == (Py_uintptr_t)-1) {

   148 		/* I've seen errno == EAGAIN here, which means "there are

   149 		 * too many threads".

   150 		 */

   151 		dprintf(("%ld: PyThread_start_new_thread failed: %p errno %d\n",

   152 		         PyThread_get_thread_ident(), (void*)rv, errno));

   153 		obj.id = -1;

   154 	}

   155 	else {

   156 		dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",

   157 		         PyThread_get_thread_ident(), (void*)rv));

   158 		/* wait for thread to initialize, so we can get its id */

   159 		WaitForSingleObject(obj.done, INFINITE);

   160 		assert(obj.id != -1);

   161 	}

   162 	CloseHandle((HANDLE)obj.done);

   163 	return obj.id;

   164 }

   165 

   166 /*

   167  * Return the thread Id instead of an handle. The Id is said to uniquely identify the

   168  * thread in the system

   169  */

   170 long

   171 PyThread_get_thread_ident(void)

   172 {

   173 	if (!initialized)

   174 		PyThread_init_thread();

   175 

   176 	return GetCurrentThreadId();

   177 }

   178 

   179 static void

   180 do_PyThread_exit_thread(int no_cleanup)

   181 {

   182 	dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));

   183 	if (!initialized)

   184 		if (no_cleanup)

   185 			_exit(0);

   186 		else

   187 			exit(0);

   188 	_endthread();

   189 }

   190 

   191 void

   192 PyThread_exit_thread(void)

   193 {

   194 	do_PyThread_exit_thread(0);

   195 }

   196 

   197 void

   198 PyThread__exit_thread(void)

   199 {

   200 	do_PyThread_exit_thread(1);

   201 }

   202 

   203 #ifndef NO_EXIT_PROG

   204 static void

   205 do_PyThread_exit_prog(int status, int no_cleanup)

   206 {

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

   208 	if (!initialized)

   209 		if (no_cleanup)

   210 			_exit(status);

   211 		else

   212 			exit(status);

   213 }

   214 

   215 void

   216 PyThread_exit_prog(int status)

   217 {

   218 	do_PyThread_exit_prog(status, 0);

   219 }

   220 

   221 void

   222 PyThread__exit_prog(int status)

   223 {

   224 	do_PyThread_exit_prog(status, 1);

   225 }

   226 #endif /* NO_EXIT_PROG */

   227 

   228 /*

   229  * Lock support. It has too be implemented as semaphores.

   230  * I [Dag] tried to implement it with mutex but I could find a way to

   231  * tell whether a thread already own the lock or not.

   232  */

   233 PyThread_type_lock

   234 PyThread_allocate_lock(void)

   235 {

   236 	PNRMUTEX aLock;

   237 

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

   239 	if (!initialized)

   240 		PyThread_init_thread();

   241 

   242 	aLock = AllocNonRecursiveMutex() ;

   243 

   244 	dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));

   245 

   246 	return (PyThread_type_lock) aLock;

   247 }

   248 

   249 void

   250 PyThread_free_lock(PyThread_type_lock aLock)

   251 {

   252 	dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));

   253 

   254 	FreeNonRecursiveMutex(aLock) ;

   255 }

   256 

   257 /*

   258  * Return 1 on success if the lock was acquired

   259  *

   260  * and 0 if the lock was not acquired. This means a 0 is returned

   261  * if the lock has already been acquired by this thread!

   262  */

   263 int

   264 PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)

   265 {

   266 	int success ;

   267 

   268 	dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));

   269 

   270 	success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;

   271 

   272 	dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));

   273 

   274 	return success;

   275 }

   276 

   277 void

   278 PyThread_release_lock(PyThread_type_lock aLock)

   279 {

   280 	dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));

   281 

   282 	if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))

   283 		dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));

   284 }

   285 

   286 /* minimum/maximum thread stack sizes supported */

   287 #define THREAD_MIN_STACKSIZE	0x8000		/* 32kB */

   288 #define THREAD_MAX_STACKSIZE	0x10000000	/* 256MB */

   289 

   290 /* set the thread stack size.

   291  * Return 0 if size is valid, -1 otherwise.

   292  */

   293 static int

   294 _pythread_nt_set_stacksize(size_t size)

   295 {

   296 	/* set to default */

   297 	if (size == 0) {

   298 		_pythread_stacksize = 0;

   299 		return 0;

   300 	}

   301 

   302 	/* valid range? */

   303 	if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {

   304 		_pythread_stacksize = size;

   305 		return 0;

   306 	}

   307 

   308 	return -1;

   309 }

   310 

   311 #define THREAD_SET_STACKSIZE(x)	_pythread_nt_set_stacksize(x)