Python/thread_solaris.h

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <unistd.h>
  35 #include <errno.h>
  36 #include </usr/include/thread.h>
  37 #undef _POSIX_THREADS
  38
  39
  40 /*
  41  * Initialization.
  42  */
  43 static void PyThread__init_thread _P0()
  44 {
  45 }
  46
  47 /*
  48  * Thread support.
  49  */
  50 struct func_arg {
  51         void (*func) _P((void *));
  52         void *arg;
  53 };
  54
  55 static void *new_func _P1(funcarg, void *funcarg)
  56 {
  57         void (*func) _P((void *));
  58         void *arg;
  59
  60         func = ((struct func_arg *) funcarg)->func;
  61         arg = ((struct func_arg *) funcarg)->arg;
  62         free(funcarg);
  63         (*func)(arg);
  64         return 0;
  65 }
  66
  67
  68 int PyThread_start_new_thread _P2(func, void (*func) _P((void *)), arg, void *arg)
  69 {
  70         struct func_arg *funcarg;
  71         int success = 0;        /* init not needed when SOLARIS_THREADS and */
  72                                 /* C_THREADS implemented properly */
  73
  74         dprintf(("PyThread_start_new_thread called\n"));
  75         if (!initialized)
  76                 PyThread_init_thread();
  77         funcarg = (struct func_arg *) malloc(sizeof(struct func_arg));
  78         funcarg->func = func;
  79         funcarg->arg = arg;
  80         if (thr_create(0, 0, new_func, funcarg, THR_DETACHED, 0)) {
  81                 perror("thr_create");
  82                 free((void *) funcarg);
  83                 success = -1;
  84         }
  85         return success < 0 ? 0 : 1;
  86 }
  87
  88 long PyThread_get_thread_ident _P0()
  89 {
  90         if (!initialized)
  91                 PyThread_init_thread();
  92         return thr_self();
  93 }
  94
  95 static void do_PyThread_exit_thread _P1(no_cleanup, int no_cleanup)
  96 {
  97         dprintf(("PyThread_exit_thread called\n"));
  98         if (!initialized)
  99                 if (no_cleanup)
 100                         _exit(0);
 101                 else
 102                         exit(0);
 103         thr_exit(0);
 104 }
 105
 106 void PyThread_exit_thread _P0()
 107 {
 108         do_PyThread_exit_thread(0);
 109 }
 110
 111 void PyThread__exit_thread _P0()
 112 {
 113         do_PyThread_exit_thread(1);
 114 }
 115
 116 #ifndef NO_EXIT_PROG
 117 static void do_PyThread_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
 118 {
 119         dprintf(("PyThread_exit_prog(%d) called\n", status));
 120         if (!initialized)
 121                 if (no_cleanup)
 122                         _exit(status);
 123                 else
 124                         exit(status);
 125         if (no_cleanup)
 126                 _exit(status);
 127         else
 128                 exit(status);
 129 }
 130
 131 void PyThread_exit_prog _P1(status, int status)
 132 {
 133         do_PyThread_exit_prog(status, 0);
 134 }
 135
 136 void PyThread__exit_prog _P1(status, int status)
 137 {
 138         do_PyThread_exit_prog(status, 1);
 139 }
 140 #endif /* NO_EXIT_PROG */
 141
 142 /*
 143  * Lock support.
 144  */
 145 PyThread_type_lock PyThread_allocate_lock _P0()
 146 {
 147         mutex_t *lock;
 148
 149         dprintf(("PyThread_allocate_lock called\n"));
 150         if (!initialized)
 151                 PyThread_init_thread();
 152
 153         lock = (mutex_t *) malloc(sizeof(mutex_t));
 154         if (mutex_init(lock, USYNC_THREAD, 0)) {
 155                 perror("mutex_init");
 156                 free((void *) lock);
 157                 lock = 0;
 158         }
 159         dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
 160         return (PyThread_type_lock) lock;
 161 }
 162
 163 void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
 164 {
 165         dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
 166         mutex_destroy((mutex_t *) lock);
 167         free((void *) lock);
 168 }
 169
 170 int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitflag)
 171 {
 172         int success;
 173
 174         dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
 175         if (waitflag)
 176                 success = mutex_lock((mutex_t *) lock);
 177         else
 178                 success = mutex_trylock((mutex_t *) lock);
 179         if (success < 0)
 180                 perror(waitflag ? "mutex_lock" : "mutex_trylock");
 181         else
 182                 success = !success; /* solaris does it the other way round */
 183         dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
 184         return success;
 185 }
 186
 187 void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
 188 {
 189         dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
 190         if (mutex_unlock((mutex_t *) lock))
 191                 perror("mutex_unlock");
 192 }
 193
 194 /*
 195  * Semaphore support.
 196  */
 197 PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
 198 {
 199         sema_t *sema;
 200         dprintf(("PyThread_allocate_sema called\n"));
 201         if (!initialized)
 202                 PyThread_init_thread();
 203
 204         sema = (sema_t *) malloc(sizeof(sema_t));
 205         if (sema_init(sema, value, USYNC_THREAD, 0)) {
 206                 perror("sema_init");
 207                 free((void *) sema);
 208                 sema = 0;
 209         }
 210         dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
 211         return (PyThread_type_sema) sema;
 212 }
 213
 214 void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
 215 {
 216         dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
 217         if (sema_destroy((sema_t *) sema))
 218                 perror("sema_destroy");
 219         free((void *) sema);
 220 }
 221
 222 int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag)
 223 {
 224         int success;
 225
 226         dprintf(("PyThread_down_sema(%lx) called\n", (long) sema));
 227         if (waitflag)
 228                 success = sema_wait((sema_t *) sema);
 229         else
 230                 success = sema_trywait((sema_t *) sema);
 231         if (success < 0) {
 232                 if (errno == EBUSY)
 233                         success = 0;
 234                 else
 235                         perror("sema_wait");
 236         }
 237         else
 238                 success = !success;
 239         dprintf(("PyThread_down_sema(%lx) return %d\n", (long) sema, success));
 240         return success;
 241 }
 242
 243 void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
 244 {
 245         dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
 246         if (sema_post((sema_t *) sema))
 247                 perror("sema_post");
 248 }