Python/thread_solaris.h

   1
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <errno.h>
   5 #include </usr/include/thread.h>
   6 #undef _POSIX_THREADS
   7
   8
   9 /*
  10  * Initialization.
  11  */
  12 static void PyThread__init_thread(void)
  13 {
  14 }
  15
  16 /*
  17  * Thread support.
  18  */
  19 struct func_arg {
  20         void (*func)(void *);
  21         void *arg;
  22 };
  23
  24 static void *
  25 new_func(void *funcarg)
  26 {
  27         void (*func)(void *);
  28         void *arg;
  29
  30         func = ((struct func_arg *) funcarg)->func;
  31         arg = ((struct func_arg *) funcarg)->arg;
  32         free(funcarg);
  33         (*func)(arg);
  34         return 0;
  35 }
  36
  37
  38 long
  39 PyThread_start_new_thread(void (*func)(void *), void *arg)
  40 {
  41         thread_t tid;
  42         struct func_arg *funcarg;
  43
  44         dprintf(("PyThread_start_new_thread called\n"));
  45         if (!initialized)
  46                 PyThread_init_thread();
  47         funcarg = (struct func_arg *) malloc(sizeof(struct func_arg));
  48         funcarg->func = func;
  49         funcarg->arg = arg;
  50         if (thr_create(0, 0, new_func, funcarg,
  51                        THR_DETACHED | THR_NEW_LWP, &tid)) {
  52                 perror("thr_create");
  53                 free((void *) funcarg);
  54                 return -1;
  55         }
  56         return tid;
  57 }
  58
  59 long
  60 PyThread_get_thread_ident(void)
  61 {
  62         if (!initialized)
  63                 PyThread_init_thread();
  64         return thr_self();
  65 }
  66
  67 static void
  68 do_PyThread_exit_thread(int no_cleanup)
  69 {
  70         dprintf(("PyThread_exit_thread called\n"));
  71         if (!initialized)
  72                 if (no_cleanup)
  73                         _exit(0);
  74                 else
  75                         exit(0);
  76         thr_exit(0);
  77 }
  78
  79 void
  80 PyThread_exit_thread(void)
  81 {
  82         do_PyThread_exit_thread(0);
  83 }
  84
  85 void
  86 PyThread__exit_thread(void)
  87 {
  88         do_PyThread_exit_thread(1);
  89 }
  90
  91 #ifndef NO_EXIT_PROG
  92 static void
  93 do_PyThread_exit_prog(int status, int no_cleanup)
  94 {
  95         dprintf(("PyThread_exit_prog(%d) called\n", status));
  96         if (!initialized)
  97                 if (no_cleanup)
  98                         _exit(status);
  99                 else
 100                         exit(status);
 101         if (no_cleanup)
 102                 _exit(status);
 103         else
 104                 exit(status);
 105 }
 106
 107 void
 108 PyThread_exit_prog(int status)
 109 {
 110         do_PyThread_exit_prog(status, 0);
 111 }
 112
 113 void
 114 PyThread__exit_prog(int status)
 115 {
 116         do_PyThread_exit_prog(status, 1);
 117 }
 118 #endif /* NO_EXIT_PROG */
 119
 120 /*
 121  * Lock support.
 122  */
 123 PyThread_type_lock
 124 PyThread_allocate_lock(void)
 125 {
 126         mutex_t *lock;
 127
 128         dprintf(("PyThread_allocate_lock called\n"));
 129         if (!initialized)
 130                 PyThread_init_thread();
 131
 132         lock = (mutex_t *) malloc(sizeof(mutex_t));
 133         if (mutex_init(lock, USYNC_THREAD, 0)) {
 134                 perror("mutex_init");
 135                 free((void *) lock);
 136                 lock = 0;
 137         }
 138         dprintf(("PyThread_allocate_lock() -> %p\n", lock));
 139         return (PyThread_type_lock) lock;
 140 }
 141
 142 void
 143 PyThread_free_lock(PyThread_type_lock lock)
 144 {
 145         dprintf(("PyThread_free_lock(%p) called\n", lock));
 146         mutex_destroy((mutex_t *) lock);
 147         free((void *) lock);
 148 }
 149
 150 int
 151 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 152 {
 153         int success;
 154
 155         dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
 156         if (waitflag)
 157                 success = mutex_lock((mutex_t *) lock);
 158         else
 159                 success = mutex_trylock((mutex_t *) lock);
 160         if (success < 0)
 161                 perror(waitflag ? "mutex_lock" : "mutex_trylock");
 162         else
 163                 success = !success; /* solaris does it the other way round */
 164         dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
 165         return success;
 166 }
 167
 168 void
 169 PyThread_release_lock(PyThread_type_lock lock)
 170 {
 171         dprintf(("PyThread_release_lock(%p) called\n", lock));
 172         if (mutex_unlock((mutex_t *) lock))
 173                 perror("mutex_unlock");
 174 }