Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 1 | /* This code implemented by cvale@netcom.com */ |
| 2 | |
| 3 | #define INCL_DOSPROCESS |
| 4 | #define INCL_DOSSEMAPHORES |
| 5 | #include "os2.h" |
| 6 | #include "limits.h" |
| 7 | |
| 8 | #include "process.h" |
| 9 | |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 10 | #if defined(PYCC_GCC) |
| 11 | #include <sys/builtin.h> |
| 12 | #include <sys/fmutex.h> |
| 13 | #else |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 14 | long PyThread_get_thread_ident(void); |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 15 | #endif |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 16 | |
| 17 | /* |
| 18 | * Initialization of the C package, should not be needed. |
| 19 | */ |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 20 | static void |
| 21 | PyThread__init_thread(void) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 22 | { |
| 23 | } |
| 24 | |
| 25 | /* |
| 26 | * Thread support. |
| 27 | */ |
Guido van Rossum | 3c28863 | 2001-10-16 21:13:49 +0000 | [diff] [blame] | 28 | long |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 29 | PyThread_start_new_thread(void (*func)(void *), void *arg) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 30 | { |
| 31 | int aThread; |
Guido van Rossum | 3c28863 | 2001-10-16 21:13:49 +0000 | [diff] [blame] | 32 | int success = 0; |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 33 | |
Guido van Rossum | 8e9ebfd | 1997-11-22 21:53:48 +0000 | [diff] [blame] | 34 | aThread = _beginthread(func,NULL,65536,arg); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 35 | |
| 36 | if( aThread == -1 ) { |
Guido van Rossum | 3c28863 | 2001-10-16 21:13:49 +0000 | [diff] [blame] | 37 | success = -1; |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 38 | fprintf(stderr,"aThread failed == %d",aThread); |
| 39 | dprintf(("_beginthread failed. return %ld\n", errno)); |
| 40 | } |
| 41 | |
| 42 | return success; |
| 43 | } |
| 44 | |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 45 | long |
| 46 | PyThread_get_thread_ident(void) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 47 | { |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 48 | #if !defined(PYCC_GCC) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 49 | PPIB pib; |
| 50 | PTIB tib; |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 51 | #endif |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 52 | |
| 53 | if (!initialized) |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 54 | PyThread_init_thread(); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 55 | |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 56 | #if defined(PYCC_GCC) |
| 57 | return _gettid(); |
| 58 | #else |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 59 | DosGetInfoBlocks(&tib,&pib); |
| 60 | return tib->tib_ptib2->tib2_ultid; |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 61 | #endif |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 62 | } |
| 63 | |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 64 | static void |
| 65 | do_PyThread_exit_thread(int no_cleanup) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 66 | { |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 67 | dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident())); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 68 | if (!initialized) |
| 69 | if (no_cleanup) |
| 70 | _exit(0); |
| 71 | else |
| 72 | exit(0); |
| 73 | _endthread(); |
| 74 | } |
| 75 | |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 76 | void |
| 77 | PyThread_exit_thread(void) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 78 | { |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 79 | do_PyThread_exit_thread(0); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 80 | } |
| 81 | |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 82 | void |
| 83 | PyThread__exit_thread(void) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 84 | { |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 85 | do_PyThread_exit_thread(1); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | #ifndef NO_EXIT_PROG |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 89 | static void |
| 90 | do_PyThread_exit_prog(int status, int no_cleanup) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 91 | { |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 92 | dprintf(("PyThread_exit_prog(%d) called\n", status)); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 93 | if (!initialized) |
| 94 | if (no_cleanup) |
| 95 | _exit(status); |
| 96 | else |
| 97 | exit(status); |
| 98 | } |
| 99 | |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 100 | void |
| 101 | PyThread_exit_prog(int status) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 102 | { |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 103 | do_PyThread_exit_prog(status, 0); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 104 | } |
| 105 | |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 106 | void |
| 107 | PyThread__exit_prog(int status) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 108 | { |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 109 | do_PyThread_exit_prog(status, 1); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 110 | } |
| 111 | #endif /* NO_EXIT_PROG */ |
| 112 | |
| 113 | /* |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 114 | * Lock support. This is implemented with an event semaphore and critical |
| 115 | * sections to make it behave more like a posix mutex than its OS/2 |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 116 | * counterparts. |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 117 | */ |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 118 | |
| 119 | typedef struct os2_lock_t { |
| 120 | int is_set; |
| 121 | HEV changed; |
| 122 | } *type_os2_lock; |
| 123 | |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 124 | PyThread_type_lock |
| 125 | PyThread_allocate_lock(void) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 126 | { |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 127 | #if defined(PYCC_GCC) |
| 128 | _fmutex *sem = malloc(sizeof(_fmutex)); |
| 129 | if (!initialized) |
| 130 | PyThread_init_thread(); |
| 131 | dprintf(("%ld: PyThread_allocate_lock() -> %lx\n", |
| 132 | PyThread_get_thread_ident(), |
| 133 | (long)sem)); |
| 134 | if (_fmutex_create(sem, 0)) { |
| 135 | free(sem); |
| 136 | sem = NULL; |
| 137 | } |
| 138 | return (PyThread_type_lock) sem; |
| 139 | #else |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 140 | APIRET rc; |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 141 | type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t)); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 142 | |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 143 | dprintf(("PyThread_allocate_lock called\n")); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 144 | if (!initialized) |
Guido van Rossum | 65d5b57 | 1998-12-21 19:32:43 +0000 | [diff] [blame] | 145 | PyThread_init_thread(); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 146 | |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 147 | lock->is_set = 0; |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 148 | |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 149 | DosCreateEventSem(NULL, &lock->changed, 0, 0); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 150 | |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 151 | dprintf(("%ld: PyThread_allocate_lock() -> %p\n", |
| 152 | PyThread_get_thread_ident(), |
| 153 | lock->changed)); |
| 154 | |
| 155 | return (PyThread_type_lock) lock; |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 156 | #endif |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 157 | } |
| 158 | |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 159 | void |
| 160 | PyThread_free_lock(PyThread_type_lock aLock) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 161 | { |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 162 | #if !defined(PYCC_GCC) |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 163 | type_os2_lock lock = (type_os2_lock)aLock; |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 164 | #endif |
| 165 | |
Fred Drake | a44d353 | 2000-06-30 15:01:00 +0000 | [diff] [blame] | 166 | dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock)); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 167 | |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 168 | #if defined(PYCC_GCC) |
| 169 | if (aLock) { |
| 170 | _fmutex_close((_fmutex *)aLock); |
| 171 | free((_fmutex *)aLock); |
| 172 | } |
| 173 | #else |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 174 | DosCloseEventSem(lock->changed); |
| 175 | free(aLock); |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 176 | #endif |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 177 | } |
| 178 | |
| 179 | /* |
| 180 | * Return 1 on success if the lock was acquired |
| 181 | * |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 182 | * and 0 if the lock was not acquired. |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 183 | */ |
Thomas Wouters | f70ef4f | 2000-07-22 18:47:25 +0000 | [diff] [blame] | 184 | int |
| 185 | PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 186 | { |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 187 | #if !defined(PYCC_GCC) |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 188 | int done = 0; |
| 189 | ULONG count; |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 190 | PID pid = 0; |
| 191 | TID tid = 0; |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 192 | type_os2_lock lock = (type_os2_lock)aLock; |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 193 | #endif |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 194 | |
Fred Drake | a44d353 | 2000-06-30 15:01:00 +0000 | [diff] [blame] | 195 | dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(), |
| 196 | aLock, waitflag)); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 197 | |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 198 | #if defined(PYCC_GCC) |
| 199 | /* always successful if the lock doesn't exist */ |
| 200 | if (aLock && _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT)) |
| 201 | return 0; |
| 202 | #else |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 203 | while (!done) { |
| 204 | /* if the lock is currently set, we have to wait for the state to change */ |
| 205 | if (lock->is_set) { |
| 206 | if (!waitflag) |
| 207 | return 0; |
| 208 | DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 209 | } |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 210 | |
| 211 | /* |
| 212 | * enter a critical section and try to get the semaphore. If |
| 213 | * it is still locked, we will try again. |
| 214 | */ |
| 215 | if (DosEnterCritSec()) |
| 216 | return 0; |
| 217 | |
| 218 | if (!lock->is_set) { |
| 219 | lock->is_set = 1; |
| 220 | DosResetEventSem(lock->changed, &count); |
| 221 | done = 1; |
| 222 | } |
| 223 | |
| 224 | DosExitCritSec(); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 225 | } |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 226 | #endif |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 227 | |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 228 | return 1; |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 229 | } |
| 230 | |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 231 | void PyThread_release_lock(PyThread_type_lock aLock) |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 232 | { |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 233 | #if defined(PYCC_GCC) |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 234 | type_os2_lock lock = (type_os2_lock)aLock; |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 235 | #endif |
| 236 | |
Fred Drake | a44d353 | 2000-06-30 15:01:00 +0000 | [diff] [blame] | 237 | dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock)); |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 238 | |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 239 | #if defined(PYCC_GCC) |
| 240 | if (aLock) |
| 241 | _fmutex_release((_fmutex *)aLock); |
| 242 | #else |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 243 | if (!lock->is_set) { |
Fred Drake | a44d353 | 2000-06-30 15:01:00 +0000 | [diff] [blame] | 244 | dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", |
| 245 | PyThread_get_thread_ident(), aLock, GetLastError())); |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 246 | return; |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 247 | } |
Tim Peters | a6ca4f4 | 2001-10-31 03:50:45 +0000 | [diff] [blame] | 248 | |
| 249 | |
| 250 | if (DosEnterCritSec()) { |
| 251 | dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", |
| 252 | PyThread_get_thread_ident(), aLock, GetLastError())); |
| 253 | return; |
| 254 | } |
| 255 | |
| 256 | lock->is_set = 0; |
| 257 | DosPostEventSem(lock->changed); |
| 258 | |
| 259 | DosExitCritSec(); |
Andrew MacIntyre | d940054 | 2002-02-26 11:41:34 +0000 | [diff] [blame] | 260 | #endif |
Guido van Rossum | 6233293 | 1995-04-10 11:36:14 +0000 | [diff] [blame] | 261 | } |