#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/prctl.h>
#include <ulocks.h>
#include <errno.h>

#define HDR_SIZE        2680    /* sizeof(ushdr_t) */
#define MAXPROC         100     /* max # of threads that can be started */

static usptr_t *shared_arena;
static ulock_t count_lock;      /* protection for some variables */
static ulock_t wait_lock;       /* lock used to wait for other threads */
static int waiting_for_threads; /* protected by count_lock */
static int nthreads;            /* protected by count_lock */
static int exit_status;
#ifndef NO_EXIT_PROG
static int do_exit;             /* indicates that the program is to exit */
#endif
static int exiting;             /* we're already exiting (for maybe_exit) */
static pid_t my_pid;            /* PID of main thread */
static struct pidlist {
       pid_t parent;
       pid_t child;
} pidlist[MAXPROC];     /* PIDs of other threads; protected by count_lock */
static int maxpidindex;         /* # of PIDs in pidlist */

#ifndef NO_EXIT_PROG
/*
* This routine is called as a signal handler when another thread
* exits.  When that happens, we must see whether we have to exit as
* well (because of an PyThread_exit_prog()) or whether we should continue on.
*/
static void exit_sig(void)
{
       d2printf(("exit_sig called\n"));
       if (exiting && getpid() == my_pid) {
               d2printf(("already exiting\n"));
               return;
       }
       if (do_exit) {
               d2printf(("exiting in exit_sig\n"));
#ifdef Py_DEBUG
               if ((thread_debug & 8) == 0)
                       thread_debug &= ~1; /* don't produce debug messages */
#endif
               PyThread_exit_thread();
       }
}

/*
* This routine is called when a process calls exit().  If that wasn't
* done from the library, we do as if an PyThread_exit_prog() was intended.
*/
static void maybe_exit(void)
{
       dprintf(("maybe_exit called\n"));
       if (exiting) {
               dprintf(("already exiting\n"));
               return;
       }
       PyThread_exit_prog(0);
}
#endif /* NO_EXIT_PROG */

/*
* Initialization.
*/
static void PyThread__init_thread(void)
{
#ifndef NO_EXIT_PROG
       struct sigaction s;
#endif /* NO_EXIT_PROG */
#ifdef USE_DL
       long addr, size;
#endif /* USE_DL */


#ifdef USE_DL
       if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
               perror("usconfig - CONF_INITSIZE (check)");
       if (usconfig(CONF_INITSIZE, size) < 0)
               perror("usconfig - CONF_INITSIZE (reset)");
       addr = (long) dl_getrange(size + HDR_SIZE);
       dprintf(("trying to use addr %p-%p for shared arena\n", addr, addr+size));
       errno = 0;
       if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)
               perror("usconfig - CONF_ATTACHADDR (set)");
#endif /* USE_DL */
       if (usconfig(CONF_INITUSERS, 16) < 0)
               perror("usconfig - CONF_INITUSERS");
       my_pid = getpid();      /* so that we know which is the main thread */
#ifndef NO_EXIT_PROG
       atexit(maybe_exit);
       s.sa_handler = exit_sig;
       sigemptyset(&s.sa_mask);
       /*sigaddset(&s.sa_mask, SIGUSR1);*/
       s.sa_flags = 0;
       sigaction(SIGUSR1, &s, 0);
       if (prctl(PR_SETEXITSIG, SIGUSR1) < 0)
               perror("prctl - PR_SETEXITSIG");
#endif /* NO_EXIT_PROG */
       if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0)
               perror("usconfig - CONF_ARENATYPE");
       usconfig(CONF_LOCKTYPE, US_DEBUG); /* XXX */
#ifdef Py_DEBUG
       if (thread_debug & 4)
               usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);
       else if (thread_debug & 2)
               usconfig(CONF_LOCKTYPE, US_DEBUG);
#endif /* Py_DEBUG */
       if ((shared_arena = usinit(tmpnam(0))) == 0)
               perror("usinit");
#ifdef USE_DL
       if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */
               perror("usconfig - CONF_ATTACHADDR (reset)");
#endif /* USE_DL */
       if ((count_lock = usnewlock(shared_arena)) == NULL)
               perror("usnewlock (count_lock)");
       (void) usinitlock(count_lock);
       if ((wait_lock = usnewlock(shared_arena)) == NULL)
               perror("usnewlock (wait_lock)");
       dprintf(("arena start: %p, arena size: %ld\n",  shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena)));
}

/*
* Thread support.
*/

static void clean_threads(void)
{
       int i, j;
       pid_t mypid, pid;

       /* clean up any exited threads */
       mypid = getpid();
       i = 0;
       while (i < maxpidindex) {
               if (pidlist[i].parent == mypid && (pid = pidlist[i].child) > 0) {
                       pid = waitpid(pid, 0, WNOHANG);
                       if (pid > 0) {
                               /* a thread has exited */
                               pidlist[i] = pidlist[--maxpidindex];
                               /* remove references to children of dead proc */
                               for (j = 0; j < maxpidindex; j++)
                                       if (pidlist[j].parent == pid)
                                               pidlist[j].child = -1;
                               continue; /* don't increment i */
                       }
               }
               i++;
       }
       /* clean up the list */
       i = 0;
       while (i < maxpidindex) {
               if (pidlist[i].child == -1) {
                       pidlist[i] = pidlist[--maxpidindex];
                       continue; /* don't increment i */
               }
               i++;
       }
}

long PyThread_start_new_thread(void (*func)(void *), void *arg)
{
#ifdef USE_DL
       long addr, size;
       static int local_initialized = 0;
#endif /* USE_DL */
       int success = 0;        /* init not needed when SOLARIS_THREADS and */
                               /* C_THREADS implemented properly */

       dprintf(("PyThread_start_new_thread called\n"));
       if (!initialized)
               PyThread_init_thread();
       switch (ussetlock(count_lock)) {
       case 0: return 0;
       case -1: perror("ussetlock (count_lock)");
       }
       if (maxpidindex >= MAXPROC)
               success = -1;
       else {
#ifdef USE_DL
               if (!local_initialized) {
                       if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
                               perror("usconfig - CONF_INITSIZE (check)");
                       if (usconfig(CONF_INITSIZE, size) < 0)
                               perror("usconfig - CONF_INITSIZE (reset)");
                       addr = (long) dl_getrange(size + HDR_SIZE);
                       dprintf(("trying to use addr %p-%p for sproc\n",
                                addr, addr+size));
                       errno = 0;
                       if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 &&
                           errno != 0)
                               perror("usconfig - CONF_ATTACHADDR (set)");
               }
#endif /* USE_DL */
               clean_threads();
               if ((success = sproc(func, PR_SALL, arg)) < 0)
                       perror("sproc");
#ifdef USE_DL
               if (!local_initialized) {
                       if (usconfig(CONF_ATTACHADDR, addr) < 0)
                               /* reset address */
                               perror("usconfig - CONF_ATTACHADDR (reset)");
                       local_initialized = 1;
               }
#endif /* USE_DL */
               if (success >= 0) {
                       nthreads++;
                       pidlist[maxpidindex].parent = getpid();
                       pidlist[maxpidindex++].child = success;
                       dprintf(("pidlist[%d] = %d\n",
                                maxpidindex-1, success));
               }
       }
       if (usunsetlock(count_lock) < 0)
               perror("usunsetlock (count_lock)");
       return success;
}

long PyThread_get_thread_ident(void)
{
       return getpid();
}

static void do_PyThread_exit_thread(int no_cleanup)
{
       dprintf(("PyThread_exit_thread called\n"));
       if (!initialized)
               if (no_cleanup)
                       _exit(0);
               else
                       exit(0);
       if (ussetlock(count_lock) < 0)
               perror("ussetlock (count_lock)");
       nthreads--;
       if (getpid() == my_pid) {
               /* main thread; wait for other threads to exit */
               exiting = 1;
#ifndef NO_EXIT_PROG
               if (do_exit) {
                       int i;

                       /* notify other threads */
                       clean_threads();
                       if (nthreads >= 0) {
                               dprintf(("kill other threads\n"));
                               for (i = 0; i < maxpidindex; i++)
                                       if (pidlist[i].child > 0)
                                               (void) kill(pidlist[i].child,
                                                           SIGKILL);
                               _exit(exit_status);
                       }
               }
#endif /* NO_EXIT_PROG */
               waiting_for_threads = 1;
               if (ussetlock(wait_lock) < 0)
                       perror("ussetlock (wait_lock)");
               for (;;) {
                       if (nthreads < 0) {
                               dprintf(("really exit (%d)\n", exit_status));
                               if (no_cleanup)
                                       _exit(exit_status);
                               else
                                       exit(exit_status);
                       }
                       if (usunsetlock(count_lock) < 0)
                               perror("usunsetlock (count_lock)");
                       dprintf(("waiting for other threads (%d)\n", nthreads));
                       if (ussetlock(wait_lock) < 0)
                               perror("ussetlock (wait_lock)");
                       if (ussetlock(count_lock) < 0)
                               perror("ussetlock (count_lock)");
               }
       }
       /* not the main thread */
       if (waiting_for_threads) {
               dprintf(("main thread is waiting\n"));
               if (usunsetlock(wait_lock) < 0)
                       perror("usunsetlock (wait_lock)");
       }
#ifndef NO_EXIT_PROG
       else if (do_exit)
               (void) kill(my_pid, SIGUSR1);
#endif /* NO_EXIT_PROG */
       if (usunsetlock(count_lock) < 0)
               perror("usunsetlock (count_lock)");
       _exit(0);
}

void PyThread_exit_thread(void)
{
       do_PyThread_exit_thread(0);
}

void PyThread__exit_thread(void)
{
       do_PyThread_exit_thread(1);
}

#ifndef NO_EXIT_PROG
static void do_PyThread_exit_prog(int status, int no_cleanup)
{
       dprintf(("PyThread_exit_prog(%d) called\n", status));
       if (!initialized)
               if (no_cleanup)
                       _exit(status);
               else
                       exit(status);
       do_exit = 1;
       exit_status = status;
       do_PyThread_exit_thread(no_cleanup);
}

void PyThread_exit_prog(int status)
{
       do_PyThread_exit_prog(status, 0);
}

void PyThread__exit_prog(int status)
{
       do_PyThread_exit_prog(status, 1);
}
#endif /* NO_EXIT_PROG */

/*
* Lock support.
*/
PyThread_type_lock PyThread_allocate_lock(void)
{
       ulock_t lock;

       dprintf(("PyThread_allocate_lock called\n"));
       if (!initialized)
               PyThread_init_thread();

       if ((lock = usnewlock(shared_arena)) == NULL)
               perror("usnewlock");
       (void) usinitlock(lock);
       dprintf(("PyThread_allocate_lock() -> %p\n", lock));
       return (PyThread_type_lock) lock;
}

void PyThread_free_lock(PyThread_type_lock lock)
{
       dprintf(("PyThread_free_lock(%p) called\n", lock));
       usfreelock((ulock_t) lock, shared_arena);
}

int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
{
       int success;

       dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
       errno = 0;              /* clear it just in case */
       if (waitflag)
               success = ussetlock((ulock_t) lock);
       else
               success = uscsetlock((ulock_t) lock, 1); /* Try it once */
       if (success < 0)
               perror(waitflag ? "ussetlock" : "uscsetlock");
       dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
       return success;
}

void PyThread_release_lock(PyThread_type_lock lock)
{
       dprintf(("PyThread_release_lock(%p) called\n", lock));
       if (usunsetlock((ulock_t) lock) < 0)
               perror("usunsetlock");
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.