Home | History | Annotate | Download | only in Python 
      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 void
     68 PyThread_exit_thread(void)
     69 {
     70     dprintf(("PyThread_exit_thread called\n"));
     71     if (!initialized)
     72         exit(0);
     73     thr_exit(0);
     74 }
     75 
     76 /*
     77  * Lock support.
     78  */
     79 PyThread_type_lock
     80 PyThread_allocate_lock(void)
     81 {
     82     mutex_t *lock;
     83 
     84     dprintf(("PyThread_allocate_lock called\n"));
     85     if (!initialized)
     86         PyThread_init_thread();
     87 
     88     lock = (mutex_t *) malloc(sizeof(mutex_t));
     89     if (mutex_init(lock, USYNC_THREAD, 0)) {
     90         perror("mutex_init");
     91         free((void *) lock);
     92         lock = 0;
     93     }
     94     dprintf(("PyThread_allocate_lock() -> %p\n", lock));
     95     return (PyThread_type_lock) lock;
     96 }
     97 
     98 void
     99 PyThread_free_lock(PyThread_type_lock lock)
    100 {
    101     dprintf(("PyThread_free_lock(%p) called\n", lock));
    102     mutex_destroy((mutex_t *) lock);
    103     free((void *) lock);
    104 }
    105 
    106 int
    107 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
    108 {
    109     int success;
    110 
    111     dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
    112     if (waitflag)
    113         success = mutex_lock((mutex_t *) lock);
    114     else
    115         success = mutex_trylock((mutex_t *) lock);
    116     if (success < 0)
    117         perror(waitflag ? "mutex_lock" : "mutex_trylock");
    118     else
    119         success = !success; /* solaris does it the other way round */
    120     dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
    121     return success;
    122 }
    123 
    124 void
    125 PyThread_release_lock(PyThread_type_lock lock)
    126 {
    127     dprintf(("PyThread_release_lock(%p) called\n", lock));
    128     if (mutex_unlock((mutex_t *) lock))
    129         perror("mutex_unlock");
    130 }
    131